lua-cli 1.2.1 → 1.3.0

package/dist/services/api.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Centralized API service for all Lua CLI API calls
+ * This service handles all HTTP requests to various Lua endpoints
+ */
+export interface ApiResponse<T = any> {
+    success: boolean;
+    data?: T;
+    error?: {
+        message: string;
+        statusCode?: number;
+    };
+}
+export interface UserData {
+    uid: string;
+    email: string;
+    emailVerified: boolean;
+    fullName: string;
+    mobileNumbers: any[];
+    emailAddresses: any[];
+    country: any;
+    admin: any;
+    channels: Record<string, any>;
+    rights: Record<string, any>;
+    setupPersona: Record<string, any>;
+    notifications: Record<string, any>;
+}
+export interface Organization {
+    id: string;
+    name: string;
+    agents: string[];
+}
+export interface Agent {
+    id: string;
+    name: string;
+    persona?: string;
+    welcomeMessage?: string;
+    featuresOverride?: Record<string, any>;
+}
+export interface SkillVersion {
+    version: string;
+    createdAt: string;
+    status: string;
+}
+export interface DevVersionResponse {
+    success: boolean;
+    data?: {
+        message: string;
+        skillId: string;
+        version: string;
+    };
+    error?: {
+        message: string;
+        statusCode: number;
+    };
+}
+export interface UpdateDevVersionResponse {
+    success: boolean;
+    data?: {
+        message: string;
+        version: string;
+    };
+    error?: {
+        message: string;
+        statusCode: number;
+    };
+}
+export interface AgentType {
+    id: string;
+    name: string;
+    features: Record<string, any>;
+    requiredSubAgentMetadata?: string[];
+}
+export interface CreateAgentRequest {
+    id: string;
+    type: string;
+    metadata: Record<string, any>;
+    persona: {
+        agentName: string;
+        businessType: string;
+        brandPersonality: string;
+        brandTraits: string;
+    };
+    features: Record<string, boolean>;
+    channels: any[];
+    org: {
+        registeredName: string;
+    };
+}
+export interface CreateAgentResponse {
+    agentId: string;
+    name: string;
+    baseAgentId: string;
+    persona: string;
+    createdAt: string;
+    welcomeMessage: string;
+    featuresOverride: Record<string, any>;
+    org: {
+        registeredName: string;
+        type: string;
+        agents: string[];
+        paymentMethods: any[];
+        _id: string;
+        id: string;
+        createdAt: number;
+        __v: number;
+    };
+}
+export interface ChatMessage {
+    type: 'text';
+    text: string;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    navigate: boolean;
+    skillOverride: Array<{
+        skillId: string;
+        sandboxId: string;
+    }>;
+}
+export interface ChatResponse {
+    success: boolean;
+    text?: string;
+    error?: string;
+}
+/**
+ * Authentication API calls
+ */
+export declare class AuthApi {
+    static checkApiKey(apiKey: string): Promise<ApiResponse<UserData>>;
+    static sendOtp(email: string): Promise<ApiResponse<{
+        message: string;
+    }>>;
+    static verifyOtp(email: string, otp: string): Promise<ApiResponse<{
+        signInToken: string;
+    }>>;
+    static getApiKey(signInToken: string): Promise<ApiResponse<{
+        apiKey: string;
+    }>>;
+}
+/**
+ * Agent API calls
+ */
+export declare class AgentApi {
+    static getOrganizations(apiKey: string): Promise<ApiResponse<Organization[]>>;
+    static getAgentTypes(apiKey: string): Promise<ApiResponse<AgentType[]>>;
+    static createAgent(apiKey: string, agentData: CreateAgentRequest): Promise<ApiResponse<CreateAgentResponse>>;
+    static getAgent(apiKey: string, agentId: string): Promise<ApiResponse<Agent>>;
+}
+/**
+ * Skill API calls
+ */
+export declare class SkillApi {
+    static createSkill(apiKey: string, agentId: string, skillData: any): Promise<ApiResponse<{
+        skillId: string;
+        name: string;
+    }>>;
+    static pushSkill(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<ApiResponse<DevVersionResponse>>;
+    static pushDevSkill(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<ApiResponse<DevVersionResponse>>;
+    static updateDevSkill(apiKey: string, agentId: string, skillId: string, sandboxVersionId: string, versionData: any): Promise<ApiResponse<UpdateDevVersionResponse>>;
+    static getSkillVersions(apiKey: string, agentId: string, skillId: string): Promise<ApiResponse<{
+        versions: any[];
+    }>>;
+    static publishSkillVersion(apiKey: string, agentId: string, skillId: string, version: string): Promise<ApiResponse<{
+        message: string;
+        skillId: string;
+        activeVersionId: string;
+        publishedAt: string;
+    }>>;
+}
+/**
+ * Chat API calls
+ */
+export declare class ChatApi {
+    static sendMessage(agentId: string, chatData: ChatRequest, apiKey: string): Promise<ApiResponse<ChatResponse>>;
+}
+/**
+ * Tool API calls (for compile command)
+ */
+export declare class ToolApi {
+    static getTool(url: string, apiKey: string): Promise<ApiResponse<any>>;
+    static postTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
+    static putTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
+    static deleteTool(url: string, apiKey: string): Promise<ApiResponse<any>>;
+    static patchTool(url: string, data: any, apiKey: string): Promise<ApiResponse<any>>;
+}
+/**
+ * Main API service that exports all API classes
+ */
+export declare const ApiService: {
+    Auth: typeof AuthApi;
+    Agent: typeof AgentApi;
+    Skill: typeof SkillApi;
+    Chat: typeof ChatApi;
+    Tool: typeof ToolApi;
+};

package/dist/services/api.js

@@ -0,0 +1,209 @@
+/**
+ * Centralized API service for all Lua CLI API calls
+ * This service handles all HTTP requests to various Lua endpoints
+ */
+// Base URLs for different environments
+const BASE_URLS = {
+    LOCAL: 'http://localhost:3022',
+    API: 'https://api.lua.dev',
+    AUTH: 'https://auth.lua.dev',
+    CHAT: 'http://localhost:3001'
+};
+/**
+ * Generic HTTP client with common error handling
+ */
+class HttpClient {
+    async request(url, options = {}) {
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...options.headers,
+                },
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: {
+                        message: data.message || data.error || `HTTP ${response.status}`,
+                        statusCode: response.status,
+                    },
+                };
+            }
+            return {
+                success: true,
+                data,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    message: error instanceof Error ? error.message : 'Network error',
+                    statusCode: 500,
+                },
+            };
+        }
+    }
+    async get(url, headers) {
+        return this.request(url, { method: 'GET', headers });
+    }
+    async post(url, data, headers) {
+        return this.request(url, {
+            method: 'POST',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    }
+    async put(url, data, headers) {
+        return this.request(url, {
+            method: 'PUT',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    }
+    async delete(url, headers) {
+        return this.request(url, { method: 'DELETE', headers });
+    }
+    async patch(url, data, headers) {
+        return this.request(url, {
+            method: 'PATCH',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    }
+}
+const httpClient = new HttpClient();
+/**
+ * Authentication API calls
+ */
+export class AuthApi {
+    static async checkApiKey(apiKey) {
+        return httpClient.get(`${BASE_URLS.LOCAL}/admin`, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async sendOtp(email) {
+        return httpClient.post(`${BASE_URLS.AUTH}/otp`, { email });
+    }
+    static async verifyOtp(email, otp) {
+        return httpClient.post(`${BASE_URLS.AUTH}/otp/verify`, { email, otp });
+    }
+    static async getApiKey(signInToken) {
+        return httpClient.post(`${BASE_URLS.AUTH}/profile/apiKey`, undefined, {
+            Authorization: `Bearer ${signInToken}`,
+        });
+    }
+}
+/**
+ * Agent API calls
+ */
+export class AgentApi {
+    static async getOrganizations(apiKey) {
+        return httpClient.get(`${BASE_URLS.LOCAL}/admin`, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async getAgentTypes(apiKey) {
+        return httpClient.get(`${BASE_URLS.API}/agents/self-serve/types`, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async createAgent(apiKey, agentData) {
+        return httpClient.post(`${BASE_URLS.API}/agents/self-serve/create`, agentData, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async getAgent(apiKey, agentId) {
+        return httpClient.get(`${BASE_URLS.API}/admin/agents/${agentId}`, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+}
+/**
+ * Skill API calls
+ */
+export class SkillApi {
+    static async createSkill(apiKey, agentId, skillData) {
+        return httpClient.post(`${BASE_URLS.LOCAL}/developer/skills/${agentId}`, skillData, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async pushSkill(apiKey, agentId, skillId, versionData) {
+        return httpClient.post(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/version`, versionData, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async pushDevSkill(apiKey, agentId, skillId, versionData) {
+        return httpClient.post(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/version/sandbox`, versionData, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async updateDevSkill(apiKey, agentId, skillId, sandboxVersionId, versionData) {
+        return httpClient.put(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/version/sandbox/${sandboxVersionId}`, versionData, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async getSkillVersions(apiKey, agentId, skillId) {
+        return httpClient.get(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/versions`, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async publishSkillVersion(apiKey, agentId, skillId, version) {
+        return httpClient.put(`${BASE_URLS.LOCAL}/developer/skills/${agentId}/${skillId}/${version}/publish`, undefined, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+}
+/**
+ * Chat API calls
+ */
+export class ChatApi {
+    static async sendMessage(agentId, chatData, apiKey) {
+        return httpClient.post(`${BASE_URLS.CHAT}/chat/generate/${agentId}?channel=dev`, chatData, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+}
+/**
+ * Tool API calls (for compile command)
+ */
+export class ToolApi {
+    static async getTool(url, apiKey) {
+        return httpClient.get(url, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async postTool(url, data, apiKey) {
+        return httpClient.post(url, data, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async putTool(url, data, apiKey) {
+        return httpClient.put(url, data, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async deleteTool(url, apiKey) {
+        return httpClient.delete(url, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+    static async patchTool(url, data, apiKey) {
+        return httpClient.patch(url, data, {
+            Authorization: `Bearer ${apiKey}`,
+        });
+    }
+}
+/**
+ * Main API service that exports all API classes
+ */
+export const ApiService = {
+    Auth: AuthApi,
+    Agent: AgentApi,
+    Skill: SkillApi,
+    Chat: ChatApi,
+    Tool: ToolApi,
+};

package/dist/services/auth.d.ts

@@ -6,3 +6,105 @@ export declare function checkApiKey(apiKey: string): Promise<UserData>;
 export declare function requestEmailOTP(email: string): Promise<boolean>;
 export declare function verifyOTPAndGetToken(email: string, pin: string): Promise<string | null>;
 export declare function generateApiKey(signInToken: string): Promise<string | null>;
+export interface CreateSkillResponse {
+    success: boolean;
+    data?: {
+        name: string;
+        public: boolean;
+        agentId: string;
+        active: boolean;
+        _id: string;
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        __v: number;
+    };
+    error?: {
+        message: string;
+        error: string;
+        statusCode: number;
+    };
+}
+export declare function createSkill(apiKey: string, agentId: string, skillName: string): Promise<CreateSkillResponse>;
+export interface AgentType {
+    id: string;
+    name: string;
+    features: Record<string, any>;
+    requiredSubAgentMetadata?: string[];
+}
+export interface CreateAgentRequest {
+    id: string;
+    type: string;
+    metadata: Record<string, any>;
+    persona: {
+        agentName: string;
+        businessType: string;
+        brandPersonality: string;
+        brandTraits: string;
+    };
+    features: Record<string, boolean>;
+    channels: any[];
+    org: {
+        registeredName: string;
+    };
+}
+export interface CreateAgentResponse {
+    success: boolean;
+    data?: {
+        agentId: string;
+        name: string;
+        baseAgentId: string;
+        persona: string;
+        createdAt: string;
+        welcomeMessage: string;
+        featuresOverride: Record<string, any>;
+        _id: string;
+        updatedAt: string;
+        __v: number;
+        org: {
+            registeredName: string;
+            type: string;
+            agents: string[];
+            paymentMethods: any[];
+            _id: string;
+            id: string;
+            createdAt: number;
+            __v: number;
+        };
+    };
+    error?: {
+        message: string;
+        error: string;
+        statusCode: number;
+    };
+}
+export interface AgentDetailsResponse {
+    success: boolean;
+    data?: {
+        _id: string;
+        agentId: string;
+        name: string;
+        baseAgentId: string;
+        persona: string;
+        createdAt: string;
+        welcomeMessage: string;
+        featuresOverride: Record<string, any>;
+        updatedAt: string;
+        __v: number;
+        personaConfig: {
+            agentName: string;
+            businessType: string;
+            brandPersonality: string;
+            brandTraits: string;
+        };
+        skills: any[];
+    };
+    error?: {
+        message: string;
+        error: string;
+        statusCode: number;
+    };
+}
+export declare function getAgentTypes(apiKey: string): Promise<AgentType[]>;
+export declare function createAgent(apiKey: string, agentData: CreateAgentRequest): Promise<CreateAgentResponse>;
+export declare function getAgentDetails(apiKey: string, agentId: string): Promise<AgentDetailsResponse>;