lua-cli 1.2.1 → 1.3.0

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.heylua.ai/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.heylua.ai/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,47 +31,150 @@ export async function requestEmailOTP(email) {
 }
 export async function verifyOTPAndGetToken(email, pin) {
     try {
-        const response = await fetch("https://auth.heylua.ai/otp/verify", {
+        const result = await ApiService.Auth.verifyOtp(email, pin);
+        return result.success ? result.data.signInToken : null;
+    }
+    catch (error) {
+        console.error("❌ Error verifying OTP:", error);
+        return null;
+    }
+}
+export async function generateApiKey(signInToken) {
+    try {
+        const result = await ApiService.Auth.getApiKey(signInToken);
+        return result.success ? result.data.apiKey : null;
+    }
+    catch (error) {
+        console.error("❌ Error generating API key:", error);
+        return null;
+    }
+}
+export async function createSkill(apiKey, agentId, skillName) {
+    try {
+        const response = await fetch(`http://localhost:3022/developer/skills/${agentId}`, {
             method: "POST",
             headers: {
                 "accept": "application/json",
+                "Authorization": `Bearer ${apiKey}`,
                 "Content-Type": "application/json"
             },
             body: JSON.stringify({
-                pin: pin,
-                type: "email",
-                email: email
+                name: skillName
             })
         });
+        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 skill:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+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) {
-            return null;
+            throw new Error(`HTTP error! status: ${response.status}`);
         }
-        const data = await response.json();
-        return data.signInToken;
+        return await response.json();
     }
     catch (error) {
-        console.error("❌ Error verifying OTP:", error);
-        return null;
+        console.error('❌ Error fetching agent types:', error);
+        throw error;
     }
 }
-export async function generateApiKey(signInToken) {
+export async function createAgent(apiKey, agentData) {
     try {
-        const response = await fetch("https://auth.heylua.ai/profile/apiKey", {
-            method: "POST",
+        const response = await fetch('https://api.lua.dev/agents/self-serve/create', {
+            method: 'POST',
             headers: {
-                "Authorization": `Bearer ${signInToken}`,
-                "Content-Type": "application/json"
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
             },
-            body: ""
+            body: JSON.stringify(agentData)
         });
-        if (!response.ok) {
-            return null;
+        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();
-        return data.apiKey;
+        if (response.ok) {
+            return {
+                success: true,
+                data: data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: data
+            };
+        }
     }
     catch (error) {
-        console.error("❌ Error generating API key:", error);
-        return null;
+        console.error('❌ Error fetching agent details:', error);
+        return {
+            success: false,
+            error: {
+                message: 'Network error',
+                error: 'Failed to connect to server',
+                statusCode: 500
+            }
+        };
     }
 }

package/dist/skill.d.ts

@@ -1,9 +1,30 @@
 import { ZodType } from "zod";
 import { LuaTool } from "./types/index.js";
 export { LuaTool };
+export interface LuaSkillConfig {
+    description: string;
+    context: string;
+}
 export declare class LuaSkill {
     private readonly tools;
-    constructor();
+    private readonly description;
+    private readonly context;
+    /**
+     * Creates a new LuaSkill instance
+     *
+     * @param config - Configuration object containing skill metadata
+     * @param config.description - Short description of what the skill does (1-2 sentences)
+     * @param config.context - Detailed explanation of how the agent should use the tools
+     *
+     * @example
+     * ```typescript
+     * const skill = new LuaSkill({
+     *   description: "Weather and calculator utilities",
+     *   context: "This skill provides weather information for any city and basic mathematical operations. Use get_weather for current conditions and calculator for arithmetic operations."
+     * });
+     * ```
+     */
+    constructor(config: LuaSkillConfig);
     addTool<TInput extends ZodType, TOutput extends ZodType>(tool: LuaTool<TInput, TOutput>): void;
     run(input: Record<string, any>): Promise<any>;
 }

package/dist/skill.js

@@ -1,8 +1,28 @@
+import { assertValidToolName } from "./types/index.js";
 export class LuaSkill {
-    constructor() {
+    /**
+     * Creates a new LuaSkill instance
+     *
+     * @param config - Configuration object containing skill metadata
+     * @param config.description - Short description of what the skill does (1-2 sentences)
+     * @param config.context - Detailed explanation of how the agent should use the tools
+     *
+     * @example
+     * ```typescript
+     * const skill = new LuaSkill({
+     *   description: "Weather and calculator utilities",
+     *   context: "This skill provides weather information for any city and basic mathematical operations. Use get_weather for current conditions and calculator for arithmetic operations."
+     * });
+     * ```
+     */
+    constructor(config) {
         this.tools = [];
+        this.description = config.description;
+        this.context = config.context;
     }
     addTool(tool) {
+        // Validate the tool name before adding it
+        assertValidToolName(tool.name);
         this.tools.push(tool);
     }
     async run(input) {

package/dist/types/index.d.ts

@@ -53,6 +53,15 @@ export interface ApiKeyResponse {
     apiId: string;
 }
 import { ZodType } from "zod";
+/**
+ * Validates that a tool name contains only alphanumeric characters, hyphens, and underscores.
+ * No spaces or other special characters are allowed.
+ */
+export declare function validateToolName(name: string): boolean;
+/**
+ * Throws an error if the tool name is invalid
+ */
+export declare function assertValidToolName(name: string): void;
 export interface LuaTool<TInput extends ZodType = ZodType, TOutput extends ZodType = ZodType> {
     name: string;
     description: string;
@@ -60,10 +69,15 @@ export interface LuaTool<TInput extends ZodType = ZodType, TOutput extends ZodTy
     outputSchema: TOutput;
     execute: (input: any) => Promise<any>;
 }
+export interface LuaSkillConfig {
+    description: string;
+    context: string;
+}
 export declare class LuaSkill {
-    private readonly apiKey;
     private readonly tools;
-    constructor(apiKey: string);
+    private readonly description;
+    private readonly context;
+    constructor(config: LuaSkillConfig);
     addTool<TInput extends ZodType, TOutput extends ZodType>(tool: LuaTool<TInput, TOutput>): void;
     run(input: Record<string, any>): Promise<any>;
 }

package/dist/types/index.js

@@ -1 +1,16 @@
-export {};
+/**
+ * Validates that a tool name contains only alphanumeric characters, hyphens, and underscores.
+ * No spaces or other special characters are allowed.
+ */
+export function validateToolName(name) {
+    const validNameRegex = /^[a-zA-Z0-9_-]+$/;
+    return validNameRegex.test(name);
+}
+/**
+ * Throws an error if the tool name is invalid
+ */
+export function assertValidToolName(name) {
+    if (!validateToolName(name)) {
+        throw new Error(`Invalid tool name "${name}". Tool names can only contain alphanumeric characters, hyphens (-), and underscores (_). No spaces or other special characters are allowed.`);
+    }
+}

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/cli.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Centralized CLI utilities for consistent error handling and output management
+ */
+/**
+ * Wraps a command function with standardized error handling
+ * Handles SIGINT (Ctrl+C) gracefully and provides consistent error messages
+ */
+export declare function withErrorHandling<T>(commandFn: () => Promise<T>, commandName: string): Promise<T>;
+/**
+ * Clears the specified number of lines from the terminal
+ * Used to clean up inquirer prompt output ONLY
+ * Should NOT be used to clear user input commands
+ */
+export declare function clearPromptLines(count?: number): void;
+/**
+ * Writes a progress message that will be replaced by the next message
+ * Uses carriage return to overwrite the current line
+ */
+export declare function writeProgress(message: string): void;
+/**
+ * Writes a final success message that will remain visible
+ * Uses console.log to ensure it stays in the output
+ */
+export declare function writeSuccess(message: string): void;
+/**
+ * Writes an error message
+ * Uses console.error for proper error output
+ */
+export declare function writeError(message: string): void;
+/**
+ * Writes an info message
+ * Uses console.log for informational output
+ */
+export declare function writeInfo(message: string): void;

package/dist/utils/cli.js

@@ -0,0 +1,58 @@
+/**
+ * Centralized CLI utilities for consistent error handling and output management
+ */
+/**
+ * Wraps a command function with standardized error handling
+ * Handles SIGINT (Ctrl+C) gracefully and provides consistent error messages
+ */
+export async function withErrorHandling(commandFn, commandName) {
+    try {
+        return await commandFn();
+    }
+    catch (error) {
+        if (error.name === 'ExitPromptError') {
+            console.log("\n❌ Operation cancelled.");
+            process.exit(0);
+        }
+        console.error(`❌ Error during ${commandName}:`, error.message);
+        process.exit(1);
+    }
+}
+/**
+ * Clears the specified number of lines from the terminal
+ * Used to clean up inquirer prompt output ONLY
+ * Should NOT be used to clear user input commands
+ */
+export function clearPromptLines(count = 1) {
+    for (let i = 0; i < count; i++) {
+        process.stdout.write('\x1b[1A\x1b[2K'); // Move up 1 line and clear it
+    }
+}
+/**
+ * Writes a progress message that will be replaced by the next message
+ * Uses carriage return to overwrite the current line
+ */
+export function writeProgress(message) {
+    process.stdout.write(`${message}\r`);
+}
+/**
+ * Writes a final success message that will remain visible
+ * Uses console.log to ensure it stays in the output
+ */
+export function writeSuccess(message) {
+    console.log(message);
+}
+/**
+ * Writes an error message
+ * Uses console.error for proper error output
+ */
+export function writeError(message) {
+    console.error(message);
+}
+/**
+ * Writes an info message
+ * Uses console.log for informational output
+ */
+export function writeInfo(message) {
+    console.log(message);
+}

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, skillDescription: 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;