@meshcore/cli/dist/services/api.js

Official CLI for managing AI agents in MeshCore.ai with LLM-powered metadata extraction

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ApiService = void 0;
const axios_1 = __importDefault(require("axios"));
const config_1 = require("./config");
class ApiService {
    constructor() {
        this.config = config_1.ConfigService.getInstance();
        this.client = axios_1.default.create({
            baseURL: this.config.getApiUrl(),
            headers: {
                'Content-Type': 'application/json'
            }
        });
        this.client.interceptors.request.use((config) => {
            const token = this.config.getAuthToken();
            if (token) {
                config.headers.Authorization = `Bearer ${token}`;
            }
            console.log(`[API] Making request to: ${config.baseURL}${config.url}`);
            return config;
        });
        this.client.interceptors.response.use((response) => response, (error) => {
            const message = error.response?.data?.message || error.message;
            const enhancedError = new Error(message);
            enhancedError.code = error.response?.status;
            enhancedError.details = error.response?.data?.details;
            // Debug logging
            console.error(`[API] Error ${error.response?.status}: ${message}`);
            if (error.response?.data?.details) {
                console.error(`[API] Details:`, JSON.stringify(error.response.data.details, null, 2));
            }
            return Promise.reject(enhancedError);
        });
    }
    static getInstance() {
        if (!ApiService.instance) {
            ApiService.instance = new ApiService();
        }
        return ApiService.instance;
    }
    async validateToken() {
        try {
            await this.getMyAgents();
            return true;
        }
        catch (error) {
            return false;
        }
    }
    async logout() {
        this.config.clearAuth();
    }
    async createAgent(agent) {
        const response = await this.client.post('/agents', agent);
        return response.data;
    }
    async getMyAgents() {
        const response = await this.client.get('/agents/my');
        return response.data;
    }
    async getAgent(id) {
        const response = await this.client.get(`/agents/${id}`);
        return response.data;
    }
    async updateAgent(id, updates) {
        const response = await this.client.put(`/agents/${id}`, updates);
        return response.data;
    }
    async deleteAgent(id) {
        await this.client.delete(`/agents/${id}`);
    }
    async checkAgentHealth(id) {
        const response = await this.client.get(`/agents/${id}/health-check`);
        return response.data;
    }
    async checkAllAgentsHealth() {
        const response = await this.client.get('/agents/health-check-all');
        return response.data;
    }
    async rewriteReadme(agentId, request) {
        const response = await this.client.post(`/agents/${agentId}/rewrite-readme`, request);
        return response.data;
    }
    async generateMetadata(request) {
        const response = await this.client.post('/agents/generate-metadata', request);
        return response.data;
    }
    async getUserProfile() {
        const response = await this.client.get('/users/profile');
        return response.data;
    }
    async getUserTeams() {
        try {
            const response = await this.client.get('/teams');
            console.log('[API] Teams response:', JSON.stringify(response.data, null, 2));
            // For testing: uncomment the next line to simulate no teams scenario
            // return [];
            // The response might be wrapped in an object, so handle both cases
            if (Array.isArray(response.data)) {
                return response.data;
            }
            else if (response.data && response.data.teams) {
                return response.data.teams;
            }
            else if (response.data && response.data.data) {
                return response.data.data;
            }
            return [];
        }
        catch (error) {
            console.error('[API] Failed to fetch teams:', error);
            throw error;
        }
    }
    async getDefaultTeamId() {
        try {
            const teams = await this.getUserTeams();
            if (teams && teams.length > 0) {
                // Return the first team ID as default
                return teams[0].id;
            }
            throw new Error('No teams found for user');
        }
        catch (error) {
            console.error('[API] Failed to get team ID:', error);
            // If we can't get team info due to permissions, try some fallback strategies
            if (error.code === 401 || error.code === 403) {
                console.log('[API] Using fallback team ID strategy...');
                // Use a default UUID for personal workspace
                return '00000000-0000-0000-0000-000000000000'; // Default UUID fallback
            }
            throw new Error('Unable to retrieve team ID');
        }
    }
}
exports.ApiService = ApiService;
//# sourceMappingURL=api.js.map