lua-cli 1.3.0-alpha.1 → 1.3.0

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

@@ -26,3 +26,85 @@ export interface CreateSkillResponse {
     };
 }
 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>;

package/dist/services/auth.js

@@ -1,5 +1,5 @@
 import keytar from "keytar";
-import fetch from "node-fetch";
+import { ApiService } from "./api.js";
 const SERVICE = "lua-cli";
 const ACCOUNT = "api-key";
 export async function saveApiKey(apiKey) {
@@ -12,31 +12,17 @@ export async function deleteApiKey() {
     return keytar.deletePassword(SERVICE, ACCOUNT);
 }
 export async function checkApiKey(apiKey) {
-    const response = await fetch("https://api.lua.dev/admin", {
-        headers: {
-            Authorization: `Bearer ${apiKey}`,
-        },
-    });
-    if (!response.ok) {
+    const result = await ApiService.Auth.checkApiKey(apiKey);
+    if (!result.success) {
         console.error(`❌ Invalid API key`);
         process.exit(1);
     }
-    return await response.json();
+    return result.data;
 }
 export async function requestEmailOTP(email) {
     try {
-        const response = await fetch("https://auth.lua.dev/otp", {
-            method: "POST",
-            headers: {
-                "accept": "application/json",
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-                type: "email",
-                email: email
-            })
-        });
-        return response.ok;
+        const result = await ApiService.Auth.sendOtp(email);
+        return result.success;
     }
     catch (error) {
         console.error("❌ Error requesting OTP:", error);
@@ -45,23 +31,8 @@ export async function requestEmailOTP(email) {
 }
 export async function verifyOTPAndGetToken(email, pin) {
     try {
-        const response = await fetch("https://auth.lua.dev/otp/verify", {
-            method: "POST",
-            headers: {
-                "accept": "application/json",
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-                pin: pin,
-                type: "email",
-                email: email
-            })
-        });
-        if (!response.ok) {
-            return null;
-        }
-        const data = await response.json();
-        return data.signInToken;
+        const result = await ApiService.Auth.verifyOtp(email, pin);
+        return result.success ? result.data.signInToken : null;
     }
     catch (error) {
         console.error("❌ Error verifying OTP:", error);
@@ -70,19 +41,8 @@ export async function verifyOTPAndGetToken(email, pin) {
 }
 export async function generateApiKey(signInToken) {
     try {
-        const response = await fetch("https://auth.lua.dev/profile/apiKey", {
-            method: "POST",
-            headers: {
-                "Authorization": `Bearer ${signInToken}`,
-                "Content-Type": "application/json"
-            },
-            body: ""
-        });
-        if (!response.ok) {
-            return null;
-        }
-        const data = await response.json();
-        return data.apiKey;
+        const result = await ApiService.Auth.getApiKey(signInToken);
+        return result.success ? result.data.apiKey : null;
     }
     catch (error) {
         console.error("❌ Error generating API key:", error);
@@ -91,7 +51,7 @@ export async function generateApiKey(signInToken) {
 }
 export async function createSkill(apiKey, agentId, skillName) {
     try {
-        const response = await fetch(`https://api.lua.dev/developer/skills/${agentId}`, {
+        const response = await fetch(`http://localhost:3022/developer/skills/${agentId}`, {
             method: "POST",
             headers: {
                 "accept": "application/json",
@@ -128,3 +88,93 @@ export async function createSkill(apiKey, agentId, skillName) {
         };
     }
 }
+export async function getAgentTypes(apiKey) {
+    try {
+        const response = await fetch('https://api.lua.dev/agents/self-serve/types', {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error('❌ Error fetching agent types:', error);
+        throw error;
+    }
+}
+export async function createAgent(apiKey, agentData) {
+    try {
+        const response = await fetch('https://api.lua.dev/agents/self-serve/create', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(agentData)
+        });
+        const data = await response.json();
+        if (response.ok) {
+            return {
+                success: true,
+                data: data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: data
+            };
+        }
+    }
+    catch (error) {
+        console.error('❌ Error creating agent:', error);
+        return {
+            success: false,
+            error: {
+                message: 'Network error',
+                error: 'Failed to connect to server',
+                statusCode: 500
+            }
+        };
+    }
+}
+export async function getAgentDetails(apiKey, agentId) {
+    try {
+        const response = await fetch(`https://api.lua.dev/admin/agents/${agentId}`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        const data = await response.json();
+        if (response.ok) {
+            return {
+                success: true,
+                data: data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: data
+            };
+        }
+    }
+    catch (error) {
+        console.error('❌ Error fetching agent details:', error);
+        return {
+            success: false,
+            error: {
+                message: 'Network error',
+                error: 'Failed to connect to server',
+                statusCode: 500
+            }
+        };
+    }
+}

package/dist/user-data-api.d.ts

@@ -0,0 +1,52 @@
+/**
+ * User Data API for Lua CLI projects
+ * Provides methods to interact with user data stored in the Lua system
+ */
+export declare class UserDataAPI {
+    private apiKey;
+    private agentId;
+    constructor(apiKey?: string, agentId?: string);
+    /**
+     * Initialize the API with credentials
+     * If not provided, will attempt to load from stored configuration
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get user data for the current agent
+     * @returns Promise<UserDataResponse>
+     */
+    get(): Promise<any>;
+    /**
+     * Create or update user data for the current agent
+     * @param data - The user data to store
+     * @returns Promise<UserDataResponse>
+     */
+    create(data: Record<string, any>): Promise<any>;
+    /**
+     * Update existing user data for the current agent
+     * @param data - The user data to update
+     * @returns Promise<UserDataResponse>
+     */
+    update(data: Record<string, any>): Promise<any>;
+    /**
+     * Clear all user data for the current agent
+     * @returns Promise<{success: boolean}>
+     */
+    clear(): Promise<{
+        success: boolean;
+    }>;
+}
+/**
+ * Convenience object for user data operations
+ * Usage: user.data.get(), user.data.create(data), user.data.update(data), user.data.clear()
+ */
+export declare const user: {
+    data: UserDataAPI;
+};
+/**
+ * Create a new UserDataAPI instance with custom credentials
+ * @param apiKey - Optional API key
+ * @param agentId - Optional agent ID
+ * @returns UserDataAPI instance
+ */
+export declare function createUserDataAPI(apiKey?: string, agentId?: string): UserDataAPI;

package/dist/user-data-api.js

@@ -0,0 +1,151 @@
+import { readSkillConfig } from './utils/files.js';
+import { loadApiKey } from './services/auth.js';
+/**
+ * User Data API for Lua CLI projects
+ * Provides methods to interact with user data stored in the Lua system
+ */
+export class UserDataAPI {
+    constructor(apiKey, agentId) {
+        this.apiKey = apiKey || '';
+        this.agentId = agentId || '';
+    }
+    /**
+     * Initialize the API with credentials
+     * If not provided, will attempt to load from stored configuration
+     */
+    async initialize() {
+        if (!this.apiKey) {
+            this.apiKey = await loadApiKey() || '';
+        }
+        if (!this.agentId) {
+            const config = await readSkillConfig();
+            this.agentId = config.agent.agentId;
+        }
+        if (!this.apiKey || !this.agentId) {
+            throw new Error('API key and agent ID are required. Please run "lua auth configure" first.');
+        }
+    }
+    /**
+     * Get user data for the current agent
+     * @returns Promise<UserDataResponse>
+     */
+    async get() {
+        await this.initialize();
+        const response = await fetch(`http://localhost:3022/developer/user/data/agent/${this.agentId}`, {
+            method: 'GET',
+            headers: {
+                'accept': '*/*',
+                'Authorization': `Bearer ${this.apiKey}`
+            }
+        });
+        if (!response.ok) {
+            // Try alternative authentication method if Bearer fails
+            if (response.status === 401) {
+                const altResponse = await fetch(`http://localhost:3022/developer/user/data/agent/${this.agentId}`, {
+                    method: 'GET',
+                    headers: {
+                        'accept': '*/*',
+                        'Authorization': this.apiKey
+                    }
+                });
+                if (altResponse.ok) {
+                    return await altResponse.json();
+                }
+            }
+            throw new Error(`Failed to get user data: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Create or update user data for the current agent
+     * @param data - The user data to store
+     * @returns Promise<UserDataResponse>
+     */
+    async create(data) {
+        await this.initialize();
+        const response = await fetch(`http://localhost:3022/developer/user/data/agent/${this.agentId}`, {
+            method: 'PUT',
+            headers: {
+                'accept': '*/*',
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(data)
+        });
+        if (!response.ok) {
+            // Try alternative authentication method if Bearer fails
+            if (response.status === 401) {
+                const altResponse = await fetch(`http://localhost:3022/developer/user/data/agent/${this.agentId}`, {
+                    method: 'PUT',
+                    headers: {
+                        'accept': '*/*',
+                        'Authorization': this.apiKey,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(data)
+                });
+                if (altResponse.ok) {
+                    return await altResponse.json();
+                }
+            }
+            throw new Error(`Failed to create user data: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Update existing user data for the current agent
+     * @param data - The user data to update
+     * @returns Promise<UserDataResponse>
+     */
+    async update(data) {
+        // Update is the same as create for this API
+        return this.create(data);
+    }
+    /**
+     * Clear all user data for the current agent
+     * @returns Promise<{success: boolean}>
+     */
+    async clear() {
+        await this.initialize();
+        const response = await fetch(`http://localhost:3022/developer/user/data/agent/${this.agentId}`, {
+            method: 'DELETE',
+            headers: {
+                'accept': '*/*',
+                'Authorization': `Bearer ${this.apiKey}`
+            }
+        });
+        if (!response.ok) {
+            // Try alternative authentication method if Bearer fails
+            if (response.status === 401) {
+                const altResponse = await fetch(`http://localhost:3022/developer/user/data/agent/${this.agentId}`, {
+                    method: 'DELETE',
+                    headers: {
+                        'accept': '*/*',
+                        'Authorization': this.apiKey
+                    }
+                });
+                if (altResponse.ok) {
+                    return await altResponse.json();
+                }
+            }
+            throw new Error(`Failed to clear user data: ${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+}
+/**
+ * Convenience object for user data operations
+ * Usage: user.data.get(), user.data.create(data), user.data.update(data), user.data.clear()
+ */
+export const user = {
+    data: new UserDataAPI()
+};
+/**
+ * Create a new UserDataAPI instance with custom credentials
+ * @param apiKey - Optional API key
+ * @param agentId - Optional agent ID
+ * @returns UserDataAPI instance
+ */
+export function createUserDataAPI(apiKey, agentId) {
+    return new UserDataAPI(apiKey, agentId);
+}

package/dist/utils/files.d.ts

@@ -1,2 +1,5 @@
 export declare function copyTemplateFiles(templateDir: string, targetDir: string): void;
-export declare function createSkillToml(agentId: string, orgId: string, skillName: string, skillId?: string): void;
+export declare function createSkillYaml(agentId: string, orgId: string, skillName: string, skillId?: string, persona?: string, welcomeMessage?: string): void;
+export declare function readSkillYaml(): any;
+export declare function readSkillConfig(): any;
+export declare function updateSkillYamlPersona(persona: string, welcomeMessage?: string): void;