lua-cli 2.2.8-alpha.1 → 2.3.0-alpha.1

package/dist/utils/dev-api.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Dev API Utilities
+ * Handles all API calls for dev mode (chat, push, update)
+ */
+import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../interfaces/dev.js';
+/**
+ * Sends a chat message to the API with skill override for sandbox testing.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxId - Sandbox skill ID
+ * @param message - Message to send
+ * @param persona - Optional persona override
+ * @param deployData - Deploy data containing all skills
+ * @returns The chat response text or null if failed
+ */
+export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any): Promise<string | null>;
+/**
+ * Updates an existing sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxVersionId - Existing sandbox version ID
+ * @param versionData - Version data to update
+ * @returns Update response
+ */
+export declare function updateDevVersion(apiKey: string, agentId: string, skillId: string, sandboxVersionId: string, versionData: any): Promise<UpdateDevVersionResponse>;
+/**
+ * Creates a new sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param versionData - Version data to create
+ * @returns Dev version response
+ */
+export declare function pushDevVersion(apiKey: string, agentId: string, skillId: string, versionData: any): Promise<DevVersionResponse>;
+/**
+ * Pushes a single skill to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param skillData - Skill data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSingleSkillToSandbox(apiKey: string, agentId: string, skillId: string, skillData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes multiple skills to the sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param deployData - Deploy data containing all skills
+ * @param isInitial - Whether this is the initial push
+ * @returns Map of skill names to their sandbox IDs
+ */
+export declare function pushSkillsToSandbox(apiKey: string, agentId: string, deployData: any, isInitial?: boolean): Promise<SandboxIdsMap>;

package/dist/utils/dev-api.js

@@ -0,0 +1,262 @@
+/**
+ * Dev API Utilities
+ * Handles all API calls for dev mode (chat, push, update)
+ */
+import ChatApi from '../api/chat.api.service.js';
+import SkillApi from '../api/skills.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { writeProgress, writeSuccess } from './cli.js';
+import { loadEnvironmentVariables } from './sandbox.js';
+import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './sandbox-storage.js';
+/**
+ * Sends a chat message to the API with skill override for sandbox testing.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxId - Sandbox skill ID
+ * @param message - Message to send
+ * @param persona - Optional persona override
+ * @param deployData - Deploy data containing all skills
+ * @returns The chat response text or null if failed
+ */
+export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData) {
+    try {
+        // Get all sandbox skill IDs for skill override
+        const allSkillOverrides = await getAllSandboxSkillIds(deployData);
+        // If no skills found, fallback to the provided skillId and sandboxId
+        const skillOverride = allSkillOverrides.length > 0 ? allSkillOverrides : [
+            {
+                skillId: skillId,
+                sandboxId: sandboxId
+            }
+        ];
+        const chatRequest = {
+            messages: [
+                {
+                    type: "text",
+                    text: message
+                }
+            ],
+            navigate: true,
+            skillOverride: skillOverride
+        };
+        // Add persona override if provided
+        if (persona) {
+            chatRequest.personaOverride = persona;
+        }
+        const chatApi = new ChatApi(BASE_URLS.CHAT, apiKey);
+        const response = await chatApi.sendMessage(agentId, chatRequest);
+        if (!response.success) {
+            console.error(`❌ Chat API error: ${response.error?.message || 'Unknown error'}`);
+            return null;
+        }
+        return response.data?.text || null;
+    }
+    catch (error) {
+        console.error("❌ Error sending chat message:", error);
+        return null;
+    }
+}
+/**
+ * Updates an existing sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxVersionId - Existing sandbox version ID
+ * @param versionData - Version data to update
+ * @returns Update response
+ */
+export async function updateDevVersion(apiKey, agentId, skillId, sandboxVersionId, versionData) {
+    try {
+        const skillsApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillsApi.updateDevSkill(skillId, sandboxVersionId, versionData);
+        if (response.success) {
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
+            };
+        }
+    }
+    catch (error) {
+        console.error("Network error updating dev version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: error instanceof Error ? error.message : "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+/**
+ * Creates a new sandbox version.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param versionData - Version data to create
+ * @returns Dev version response
+ */
+export async function pushDevVersion(apiKey, agentId, skillId, versionData) {
+    try {
+        const skillsApi = new SkillApi(BASE_URLS.API, apiKey, agentId);
+        const response = await skillsApi.pushDevSkill(skillId, versionData);
+        if (response.success) {
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: {
+                    message: response.error?.message || 'Unknown error',
+                    error: response.error?.message || 'Unknown error',
+                    statusCode: response.error?.statusCode || 500
+                }
+            };
+        }
+    }
+    catch (error) {
+        console.error("❌ Network error pushing dev version:", error);
+        return {
+            success: false,
+            error: {
+                message: "Network error",
+                error: error instanceof Error ? error.message : "Failed to connect to server",
+                statusCode: 500
+            }
+        };
+    }
+}
+/**
+ * Pushes a single skill to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param skillData - Skill data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSingleSkillToSandbox(apiKey, agentId, skillId, skillData, isInitial = false) {
+    const skillName = skillData.name || 'Unknown Skill';
+    const sandboxSkillId = await getSandboxSkillId(skillName);
+    // Load environment variables
+    const envVars = loadEnvironmentVariables();
+    const payloadWithNameAndEnv = {
+        ...skillData,
+        name: skillName,
+        env: envVars
+    };
+    if (sandboxSkillId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress("🔄 Updating existing sandbox version...");
+        }
+        const updateResult = await updateDevVersion(apiKey, agentId, skillId, sandboxSkillId, payloadWithNameAndEnv);
+        if (updateResult.success && updateResult.data) {
+            if (!isInitial) {
+                // writeSuccess(`✅ Version ${updateResult.data.version} updated in sandbox successfully`);
+                // writeSuccess(`🔑 Sandbox Skill ID: ${updateResult.data.skillId}`);
+            }
+            return true;
+        }
+        else if (updateResult.error) {
+            writeProgress("⚠️  Failed to update existing sandbox, creating new one...");
+            console.error(`❌ Sandbox update failed: ${updateResult.error.message}`);
+            if (updateResult.error.error) {
+                console.error(`   Details: ${updateResult.error.error}`);
+            }
+            // If skill not found during update, give helpful guidance before trying to create
+            if (updateResult.error.message.includes('Skill not found') || updateResult.error.statusCode === 400 || updateResult.error.statusCode === 404) {
+                console.error('\n💡 The skill doesn\'t exist on the server.');
+                console.error('   Please run "lua push" first to deploy your skill, then try "lua dev" again.\n');
+            }
+            // Fall through to create new sandbox
+        }
+    }
+    // Create new sandbox version (either no existing ID or update failed)
+    if (!isInitial) {
+        writeProgress("🔄 Creating new sandbox version...");
+    }
+    const result = await pushDevVersion(apiKey, agentId, skillId, payloadWithNameAndEnv);
+    if (result.success && result.data) {
+        // Store the new sandbox skill ID
+        await setSandboxSkillId(result.data.skillId, skillName);
+        if (!isInitial) {
+            writeSuccess(`✅ Version ${result.data.version} pushed to sandbox successfully`);
+            writeSuccess(`🔑 Sandbox Skill ID: ${result.data.skillId}`);
+        }
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ Sandbox creation failed: ${result.error.message}`);
+        if (result.error.error) {
+            console.error(`   Details: ${result.error.error}`);
+        }
+        if (result.error.statusCode) {
+            console.error(`   Status Code: ${result.error.statusCode}`);
+        }
+        // If skill not found, give helpful guidance
+        if (result.error.message.includes('Skill not found') || result.error.statusCode === 400 || result.error.statusCode === 404) {
+            console.error('\n💡 The skill hasn\'t been deployed to the server yet.');
+            console.error('   Please run "lua push" first to deploy your skill, then try "lua dev" again.');
+        }
+        return false;
+    }
+    else {
+        console.error("❌ Failed to push version to sandbox. Please try again.");
+        return false;
+    }
+}
+/**
+ * Pushes multiple skills to the sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param deployData - Deploy data containing all skills
+ * @param isInitial - Whether this is the initial push
+ * @returns Map of skill names to their sandbox IDs
+ */
+export async function pushSkillsToSandbox(apiKey, agentId, deployData, isInitial = false) {
+    const sandboxIds = {};
+    if (!deployData.skills || !Array.isArray(deployData.skills)) {
+        throw new Error("No skills found in deploy data");
+    }
+    for (const skill of deployData.skills) {
+        if (!skill.skillId) {
+            console.warn(`⚠️  Skipping skill ${skill.name} - no skillId found`);
+            continue;
+        }
+        try {
+            const success = await pushSingleSkillToSandbox(apiKey, agentId, skill.skillId, skill, isInitial);
+            if (success) {
+                // Get the sandbox ID for this skill
+                const sandboxId = await getSandboxSkillId(skill.name);
+                if (sandboxId) {
+                    sandboxIds[skill.name] = sandboxId;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`❌ Failed to push skill ${skill.name}:`, error);
+        }
+    }
+    return sandboxIds;
+}

package/dist/utils/dev-helpers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Dev Helper Utilities
+ * Small helper functions for dev mode
+ */
+/**
+ * Reads the version from config (handles both old and new formats).
+ *
+ * @param config - The skill configuration
+ * @returns The version string
+ */
+export declare function readConfigVersion(config: any): string;
+/**
+ * Reads the deploy.json file from .lua directory.
+ *
+ * @returns Parsed deploy data or null if not found
+ */
+export declare function readDeployJson(): any | null;
+/**
+ * Extracts skill ID from config (handles both old and new formats).
+ * For multi-skill projects, returns the first skill's ID.
+ *
+ * @param config - The skill configuration
+ * @returns The skill ID or null if not found
+ */
+export declare function extractSkillId(config: any): string | null;
+/**
+ * Validates that the configuration has required fields.
+ *
+ * @param config - The skill configuration to validate
+ * @throws Error if configuration is invalid
+ */
+export declare function validateConfig(config: any): void;
+/**
+ * Validates that deploy data has skills.
+ *
+ * @param deployData - The deploy data to validate
+ * @throws Error if deploy data is invalid
+ */
+export declare function validateDeployData(deployData: any): void;
+/**
+ * Validates that config has required agent information.
+ *
+ * @param config - The skill configuration
+ * @throws Error if agent info is missing
+ */
+export declare function validateAgentConfig(config: any): void;

package/dist/utils/dev-helpers.js

@@ -0,0 +1,83 @@
+/**
+ * Dev Helper Utilities
+ * Small helper functions for dev mode
+ */
+import fs from 'fs';
+import path from 'path';
+import { DEV_DEFAULTS } from '../config/dev.constants.js';
+/**
+ * Reads the version from config (handles both old and new formats).
+ *
+ * @param config - The skill configuration
+ * @returns The version string
+ */
+export function readConfigVersion(config) {
+    let version = config?.skill?.version; // Legacy format
+    if (!version && config?.skills && config.skills.length > 0) {
+        version = config.skills[0].version; // New format - use first skill's version
+    }
+    return version || DEV_DEFAULTS.VERSION;
+}
+/**
+ * Reads the deploy.json file from .lua directory.
+ *
+ * @returns Parsed deploy data or null if not found
+ */
+export function readDeployJson() {
+    const deployPath = path.join(process.cwd(), '.lua', 'deploy.json');
+    if (!fs.existsSync(deployPath)) {
+        return null;
+    }
+    const deployContent = fs.readFileSync(deployPath, 'utf8');
+    return JSON.parse(deployContent);
+}
+/**
+ * Extracts skill ID from config (handles both old and new formats).
+ * For multi-skill projects, returns the first skill's ID.
+ *
+ * @param config - The skill configuration
+ * @returns The skill ID or null if not found
+ */
+export function extractSkillId(config) {
+    let skillId = config?.skill?.skillId; // Legacy format
+    if (!skillId && config?.skills && config.skills.length > 0) {
+        skillId = config.skills[0].skillId; // New format - use first skill
+    }
+    return skillId || null;
+}
+/**
+ * Validates that the configuration has required fields.
+ *
+ * @param config - The skill configuration to validate
+ * @throws Error if configuration is invalid
+ */
+export function validateConfig(config) {
+    if (!config) {
+        throw new Error("❌ No lua.skill.yaml found. Please run this command from a skill directory.");
+    }
+}
+/**
+ * Validates that deploy data has skills.
+ *
+ * @param deployData - The deploy data to validate
+ * @throws Error if deploy data is invalid
+ */
+export function validateDeployData(deployData) {
+    if (!deployData) {
+        throw new Error("❌ No deploy.json found. Compilation may have failed.");
+    }
+    if (!deployData.skills || !Array.isArray(deployData.skills) || deployData.skills.length === 0) {
+        throw new Error("❌ No skills found in deploy.json. Compilation may have failed.");
+    }
+}
+/**
+ * Validates that config has required agent information.
+ *
+ * @param config - The skill configuration
+ * @throws Error if agent info is missing
+ */
+export function validateAgentConfig(config) {
+    if (!config.agent?.agentId) {
+        throw new Error("❌ Missing agentId in skill configuration");
+    }
+}

package/dist/utils/dev-server.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dev Server Utilities
+ * Handles HTTP server, WebSocket connections, and all HTTP endpoints for dev mode
+ */
+import { WebSocketServer } from 'ws';
+/**
+ * Server instance with WebSocket and broadcast capabilities
+ */
+export interface DevServer {
+    server: any;
+    wss: WebSocketServer;
+    broadcastLog: (message: string, subType?: 'info' | 'warn' | 'error' | 'debug') => void;
+}
+/**
+ * Creates and starts the dev web server with chat interface and tool testing.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param skillId - Skill ID
+ * @param sandboxId - Sandbox skill ID
+ * @param port - Port to run server on
+ * @returns Server instance with WebSocket and broadcast function
+ */
+export declare function createChatServer(apiKey: string, agentId: string, skillId: string, sandboxId: string, port: number): DevServer;