lua-cli 3.1.0-alpha.3 → 3.1.0-alpha.5

package/dist/commands/init.js

@@ -29,10 +29,13 @@ import { readSkillYaml, updateYamlAgent } from "../utils/files.js";
  * - Feature configuration
  * - Automatic project scaffolding
  * - Dependency installation
+ * - Optional example code with --with-examples flag
  *
+ * @param options - Command options including --with-examples
  * @returns Promise that resolves when initialization is complete
  */
-export async function initCommand() {
+export async function initCommand(options = {}) {
+    const withExamples = options.withExamples ?? false;
     return withErrorHandling(async () => {
         // Step 1: Authenticate
         const apiKey = await loadApiKey();
@@ -111,7 +114,6 @@ export async function initCommand() {
         let selectedAgent;
         let selectedOrg;
         let persona;
-        let welcomeMessage;
         let skipProjectInit = false;
         if (agentChoice === "existing") {
             // Step 4a: Select existing agent
@@ -119,7 +121,6 @@ export async function initCommand() {
             selectedAgent = result.agent;
             selectedOrg = result.org;
             persona = result.persona;
-            welcomeMessage = result.welcomeMessage;
         }
         else {
             // Step 4b: Create new agent
@@ -127,35 +128,41 @@ export async function initCommand() {
             selectedAgent = result.agent;
             selectedOrg = result.org;
             persona = result.persona;
-            welcomeMessage = result.welcomeMessage;
         }
         // Step 5: Initialize or update project
         if (yamlExists) {
             // Update existing YAML and LuaAgent in index.ts
             writeInfo("📝 Updating existing lua.skill.yaml with new agent...");
-            updateYamlAgent(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
+            updateYamlAgent(selectedAgent.agentId, selectedOrg.id, persona);
             // Also update LuaAgent in index.ts if it exists
             const { updateLuaAgentInIndexFile } = await import("../utils/init-helpers.js");
-            updateLuaAgentInIndexFile(process.cwd(), selectedAgent.name, persona, welcomeMessage);
+            updateLuaAgentInIndexFile(process.cwd(), selectedAgent.name, persona);
             writeSuccess("✅ lua.skill.yaml updated successfully!");
             writeSuccess("✅ LuaAgent configuration updated!");
         }
         else {
             // Full project initialization
-            const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage, selectedAgent.name);
+            const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, selectedAgent.name, withExamples);
             // Step 6: Install dependencies
             await installDependencies(currentDir);
-            writeSuccess("✅ Lua skill project initialized successfully!");
+            if (withExamples) {
+                writeSuccess("✅ Lua skill project initialized with examples!");
+                writeInfo("💡 Check the examples/ folder for sample skills, tools, jobs, and webhooks");
+            }
+            else {
+                writeSuccess("✅ Lua skill project initialized successfully!");
+                writeInfo("💡 Tip: Use `lua init --with-examples` to include example code");
+            }
         }
     }, "initialization");
 }
 /**
  * Handles the flow for selecting an existing agent.
- * Fetches the agent details from the server to get persona and welcomeMessage.
+ * Fetches the agent details from the server to get persona.
  *
  * @param userData - User's data
  * @param apiKey - User's API key
- * @returns Selected agent, organization, and optional persona/welcome message
+ * @returns Selected agent, organization, and optional persona
  */
 async function selectExistingAgent(userData, apiKey) {
     // Extract organizations
@@ -167,13 +174,12 @@ async function selectExistingAgent(userData, apiKey) {
     const selectedOrg = await promptOrganizationSelection(orgs);
     // Select agent from organization
     const selectedAgent = await promptAgentSelection(selectedOrg);
-    // Fetch agent details to get persona and welcomeMessage
+    // Fetch agent details to get persona
     const agentDetails = await fetchExistingAgentDetails(apiKey, selectedAgent.agentId);
     return {
         agent: selectedAgent,
         org: selectedOrg,
-        persona: agentDetails.persona,
-        welcomeMessage: agentDetails.welcomeMessage
+        persona: agentDetails.persona
     };
 }
 /**
@@ -181,7 +187,7 @@ async function selectExistingAgent(userData, apiKey) {
  *
  * @param apiKey - User's API key
  * @param userData - User data containing organizations
- * @returns Created agent, organization, and optional persona/welcome message
+ * @returns Created agent, organization, and optional persona
  */
 async function createNewAgentFlow(apiKey, userData) {
     // Fetch and select agent type
@@ -275,14 +281,12 @@ async function handleAgentSwitch(userData, apiKey, existingYaml) {
     let selectedAgent;
     let selectedOrg;
     let persona;
-    let welcomeMessage;
     if (agentChoice === "existing") {
         // Select existing agent
         const result = await selectExistingAgent(userData, apiKey);
         selectedAgent = result.agent;
         selectedOrg = result.org;
         persona = result.persona;
-        welcomeMessage = result.welcomeMessage;
     }
     else {
         // Create new agent
@@ -290,17 +294,15 @@ async function handleAgentSwitch(userData, apiKey, existingYaml) {
         selectedAgent = result.agent;
         selectedOrg = result.org;
         persona = result.persona;
-        welcomeMessage = result.welcomeMessage;
     }
-    // Ask about persona and welcome message
+    // Ask about persona
     const finalPersona = await promptPersonaReplacement(existingYaml, persona);
-    const finalWelcomeMessage = await promptWelcomeMessageReplacement(existingYaml, welcomeMessage);
     // Update existing YAML file with new agent
     writeInfo("\n📝 Updating lua.skill.yaml with new agent...");
-    updateYamlAgent(selectedAgent.agentId, selectedOrg.id, finalPersona, finalWelcomeMessage);
+    updateYamlAgent(selectedAgent.agentId, selectedOrg.id, finalPersona);
     // Also update LuaAgent in index.ts if it exists
     const { updateLuaAgentInIndexFile } = await import("../utils/init-helpers.js");
-    updateLuaAgentInIndexFile(process.cwd(), selectedAgent.name, finalPersona, finalWelcomeMessage);
+    updateLuaAgentInIndexFile(process.cwd(), selectedAgent.name, finalPersona);
     writeSuccess("✅ lua.skill.yaml updated successfully!");
     writeSuccess("✅ LuaAgent configuration updated!");
     writeInfo("\n💡 Your project now uses the new agent. Run 'lua compile' to update your skills.\n");
@@ -331,28 +333,3 @@ async function promptPersonaReplacement(existingYaml, newPersona) {
     ]);
     return replacePersona ? newPersona : existingPersona;
 }
-/**
- * Prompt user about replacing existing welcome message
- */
-async function promptWelcomeMessageReplacement(existingYaml, newWelcomeMessage) {
-    const existingWelcomeMessage = existingYaml?.agent?.welcomeMessage;
-    // If no existing welcome message, use new one
-    if (!existingWelcomeMessage) {
-        return newWelcomeMessage;
-    }
-    // If no new welcome message, keep existing
-    if (!newWelcomeMessage) {
-        return existingWelcomeMessage;
-    }
-    // Both exist - ask user
-    writeInfo("   Existing welcome message found in project");
-    const { replaceWelcomeMessage } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'replaceWelcomeMessage',
-            message: 'Replace existing welcome message with the new agent\'s welcome message?',
-            default: false
-        }
-    ]);
-    return replaceWelcomeMessage ? newWelcomeMessage : existingWelcomeMessage;
-}

package/dist/commands/jobs.js

@@ -203,8 +203,8 @@ async function viewJobVersions(context, config) {
         if (!response.success || !response.data) {
             throw new Error(response.error?.message || 'Failed to fetch versions');
         }
-        const versions = response.data.versions || [];
-        const activeVersionId = response.data.activeVersionId;
+        const versions = response.data;
+        const activeVersionId = selectedJob.activeVersionId;
         if (versions.length === 0) {
             console.log(`\nℹ️  No versions found for ${selectedJob.name}.\n`);
             console.log("💡 Push a version first using 'lua push job'.\n");
@@ -270,8 +270,8 @@ async function deployJobVersion(context, config) {
         if (!response.success || !response.data) {
             throw new Error(response.error?.message || 'Failed to fetch versions');
         }
-        const versions = response.data.versions || [];
-        const activeVersionId = response.data.activeVersionId;
+        const versions = response.data;
+        const activeVersionId = selectedJob.activeVersionId;
         if (versions.length === 0) {
             console.log(`\nℹ️  No versions found for ${selectedJob.name}.\n`);
             console.log("💡 Push a version first using 'lua push job'.\n");
@@ -434,7 +434,7 @@ async function triggerJob(context, config) {
     const response = await jobApi.triggerJob(jobAnswer.selectedJob.jobId);
     if (response.success && response.data) {
         writeSuccess(`✅ Job "${jobAnswer.selectedJob.name}" triggered successfully`);
-        writeInfo(`📋 Execution ID: ${response.data.executionId || 'N/A'}`);
+        writeInfo(`📋 Execution ID: ${response.data.id || 'N/A'}`);
     }
     else {
         console.error(`❌ Failed to trigger job: ${response.error?.message || 'Unknown error'}`);

package/dist/commands/mcp.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MCP Command
+ * Manages Model Context Protocol (MCP) servers for agents
+ */
+/**
+ * Main MCP command - manages MCP servers
+ *
+ * Subcommands:
+ * - lua mcp list       - List all MCP servers
+ * - lua mcp activate   - Activate an MCP server
+ * - lua mcp deactivate - Deactivate an MCP server
+ * - lua mcp delete     - Delete an MCP server
+ *
+ * @param action - Optional action ('list', 'activate', 'deactivate', 'delete')
+ * @param serverName - Optional server name for actions
+ * @returns Promise that resolves when command completes
+ */
+export declare function mcpCommand(action?: string, serverName?: string): Promise<void>;

package/dist/commands/mcp.js

@@ -0,0 +1,393 @@
+/**
+ * MCP Command
+ * Manages Model Context Protocol (MCP) servers for agents
+ */
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
+import { BASE_URLS } from '../config/constants.js';
+import { safePrompt } from '../utils/prompt-handler.js';
+import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
+import DeveloperApi from '../api/developer.api.service.js';
+/**
+ * Main MCP command - manages MCP servers
+ *
+ * Subcommands:
+ * - lua mcp list       - List all MCP servers
+ * - lua mcp activate   - Activate an MCP server
+ * - lua mcp deactivate - Deactivate an MCP server
+ * - lua mcp delete     - Delete an MCP server
+ *
+ * @param action - Optional action ('list', 'activate', 'deactivate', 'delete')
+ * @param serverName - Optional server name for actions
+ * @returns Promise that resolves when command completes
+ */
+export async function mcpCommand(action, serverName) {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration
+        const config = readSkillConfig();
+        validateConfig(config);
+        validateAgentConfig(config);
+        const agentId = config.agent.agentId;
+        // Step 2: Authenticate
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
+            process.exit(1);
+        }
+        await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        const developerApi = new DeveloperApi(BASE_URLS.API, apiKey, agentId);
+        const context = {
+            agentId,
+            apiKey,
+            developerApi,
+        };
+        // Step 3: Handle action or show interactive menu
+        if (action) {
+            const normalizedAction = action.toLowerCase();
+            switch (normalizedAction) {
+                case 'list':
+                case 'ls':
+                    await listMCPServers(context);
+                    break;
+                case 'activate':
+                case 'enable':
+                    await activateMCPServer(context, serverName);
+                    break;
+                case 'deactivate':
+                case 'disable':
+                    await deactivateMCPServer(context, serverName);
+                    break;
+                case 'delete':
+                case 'rm':
+                    await deleteMCPServer(context, serverName);
+                    break;
+                default:
+                    console.error(`❌ Unknown action: "${action}"`);
+                    showUsage();
+                    process.exit(1);
+            }
+        }
+        else {
+            // Interactive mode
+            await interactiveMCPManagement(context);
+        }
+    }, "mcp");
+}
+/**
+ * Show usage information
+ */
+function showUsage() {
+    console.log('\nUsage:');
+    console.log('  lua mcp                        - Interactive MCP server management');
+    console.log('  lua mcp list                   - List all MCP servers');
+    console.log('  lua mcp activate [name]        - Activate an MCP server');
+    console.log('  lua mcp deactivate [name]      - Deactivate an MCP server');
+    console.log('  lua mcp delete [name]          - Delete an MCP server');
+    console.log('\nAliases:');
+    console.log('  list → ls');
+    console.log('  activate → enable');
+    console.log('  deactivate → disable');
+    console.log('  delete → rm');
+}
+/**
+ * Interactive MCP management
+ */
+async function interactiveMCPManagement(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🔌 MCP Server Management");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '📋 List MCP servers', value: 'list' },
+                    { name: '✅ Activate a server', value: 'activate' },
+                    { name: '⏸️  Deactivate a server', value: 'deactivate' },
+                    { name: '🗑️  Delete a server', value: 'delete' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'list':
+                await listMCPServers(context);
+                break;
+            case 'activate':
+                await activateMCPServer(context);
+                break;
+            case 'deactivate':
+                await deactivateMCPServer(context);
+                break;
+            case 'delete':
+                await deleteMCPServer(context);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * List all MCP servers
+ */
+async function listMCPServers(context) {
+    writeProgress("🔄 Loading MCP servers...");
+    try {
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        console.log("\n" + "=".repeat(60));
+        console.log("🔌 MCP Servers");
+        console.log("=".repeat(60) + "\n");
+        if (servers.length === 0) {
+            console.log("ℹ️  No MCP servers found.");
+            console.log("💡 Define MCP servers in your LuaAgent configuration and run 'lua push all'.\n");
+            return;
+        }
+        // Separate active and inactive servers
+        const activeServers = servers.filter((s) => s.active);
+        const inactiveServers = servers.filter((s) => !s.active);
+        if (activeServers.length > 0) {
+            console.log("✅ Active Servers:\n");
+            activeServers.forEach((server) => {
+                printServerInfo(server);
+            });
+        }
+        if (inactiveServers.length > 0) {
+            if (activeServers.length > 0)
+                console.log("─".repeat(40) + "\n");
+            console.log("⏸️  Inactive Servers:\n");
+            inactiveServers.forEach((server) => {
+                printServerInfo(server);
+            });
+        }
+        console.log("=".repeat(60) + "\n");
+    }
+    catch (error) {
+        console.error('\n❌ Error loading MCP servers:', error.message);
+    }
+}
+/**
+ * Print server information
+ */
+function printServerInfo(server) {
+    const statusIcon = server.active ? '🟢' : '⚪';
+    console.log(`${statusIcon} ${server.name}`);
+    console.log(`   Transport: ${server.transport}`);
+    if (server.transport === 'stdio') {
+        console.log(`   Command: ${server.command} ${(server.args || []).join(' ')}`);
+    }
+    else {
+        console.log(`   URL: ${server.url}`);
+    }
+    console.log(`   ID: ${server.id}`);
+    console.log();
+}
+/**
+ * Activate an MCP server
+ */
+async function activateMCPServer(context, serverName) {
+    try {
+        // Get all servers
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        const inactiveServers = servers.filter((s) => !s.active);
+        if (inactiveServers.length === 0) {
+            console.log("\nℹ️  All MCP servers are already active.\n");
+            return;
+        }
+        let serverToActivate;
+        if (serverName) {
+            // Find by name
+            const server = inactiveServers.find((s) => s.name.toLowerCase() === serverName.toLowerCase());
+            if (!server) {
+                console.error(`\n❌ Inactive MCP server "${serverName}" not found.\n`);
+                console.log("Available inactive servers:");
+                inactiveServers.forEach((s) => console.log(`  - ${s.name}`));
+                return;
+            }
+            serverToActivate = server;
+        }
+        else {
+            // Prompt for selection
+            const answer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'server',
+                    message: 'Select an MCP server to activate:',
+                    choices: inactiveServers.map((s) => ({
+                        name: `${s.name} (${s.transport})`,
+                        value: s
+                    }))
+                }
+            ]);
+            if (!answer)
+                return;
+            serverToActivate = answer.server;
+        }
+        writeProgress(`🔄 Activating ${serverToActivate.name}...`);
+        const activateResult = await context.developerApi.activateMCPServer(serverToActivate.id);
+        if (activateResult.success) {
+            writeSuccess(`\n✅ MCP server "${serverToActivate.name}" activated successfully!\n`);
+            writeInfo("💡 The server's tools are now available to your agent.");
+        }
+        else {
+            console.error(`\n❌ Failed to activate: ${activateResult.error?.message}\n`);
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Error activating MCP server:', error.message);
+    }
+}
+/**
+ * Deactivate an MCP server
+ */
+async function deactivateMCPServer(context, serverName) {
+    try {
+        // Get all servers
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        const activeServers = servers.filter((s) => s.active);
+        if (activeServers.length === 0) {
+            console.log("\nℹ️  No active MCP servers to deactivate.\n");
+            return;
+        }
+        let serverToDeactivate;
+        if (serverName) {
+            // Find by name
+            const server = activeServers.find((s) => s.name.toLowerCase() === serverName.toLowerCase());
+            if (!server) {
+                console.error(`\n❌ Active MCP server "${serverName}" not found.\n`);
+                console.log("Available active servers:");
+                activeServers.forEach((s) => console.log(`  - ${s.name}`));
+                return;
+            }
+            serverToDeactivate = server;
+        }
+        else {
+            // Prompt for selection
+            const answer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'server',
+                    message: 'Select an MCP server to deactivate:',
+                    choices: activeServers.map((s) => ({
+                        name: `${s.name} (${s.transport})`,
+                        value: s
+                    }))
+                }
+            ]);
+            if (!answer)
+                return;
+            serverToDeactivate = answer.server;
+        }
+        writeProgress(`🔄 Deactivating ${serverToDeactivate.name}...`);
+        const deactivateResult = await context.developerApi.deactivateMCPServer(serverToDeactivate.id);
+        if (deactivateResult.success) {
+            writeSuccess(`\n✅ MCP server "${serverToDeactivate.name}" deactivated successfully!\n`);
+            writeInfo("💡 The server's tools are no longer available to your agent.");
+        }
+        else {
+            console.error(`\n❌ Failed to deactivate: ${deactivateResult.error?.message}\n`);
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Error deactivating MCP server:', error.message);
+    }
+}
+/**
+ * Delete an MCP server
+ */
+async function deleteMCPServer(context, serverName) {
+    try {
+        // Get all servers
+        const result = await context.developerApi.getMCPServers();
+        if (!result.success) {
+            console.error(`\n❌ Failed to load MCP servers: ${result.error?.message}\n`);
+            return;
+        }
+        const servers = result.data || [];
+        if (servers.length === 0) {
+            console.log("\nℹ️  No MCP servers to delete.\n");
+            return;
+        }
+        let serverToDelete;
+        if (serverName) {
+            // Find by name
+            const server = servers.find((s) => s.name.toLowerCase() === serverName.toLowerCase());
+            if (!server) {
+                console.error(`\n❌ MCP server "${serverName}" not found.\n`);
+                console.log("Available servers:");
+                servers.forEach((s) => console.log(`  - ${s.name}`));
+                return;
+            }
+            serverToDelete = server;
+        }
+        else {
+            // Prompt for selection
+            const answer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'server',
+                    message: 'Select an MCP server to delete:',
+                    choices: servers.map((s) => ({
+                        name: `${s.name} (${s.transport}) ${s.active ? '🟢' : '⚪'}`,
+                        value: s
+                    }))
+                }
+            ]);
+            if (!answer)
+                return;
+            serverToDelete = answer.server;
+        }
+        // Confirm deletion
+        console.log(`\n⚠️  You are about to delete MCP server: ${serverToDelete.name}`);
+        if (serverToDelete.active) {
+            console.log("⚠️  WARNING: This server is currently ACTIVE!");
+        }
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you sure you want to delete this MCP server?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deletion cancelled.\n");
+            return;
+        }
+        writeProgress(`🔄 Deleting ${serverToDelete.name}...`);
+        const deleteResult = await context.developerApi.deleteMCPServer(serverToDelete.id);
+        if (deleteResult.success) {
+            writeSuccess(`\n✅ MCP server "${serverToDelete.name}" deleted successfully!\n`);
+        }
+        else {
+            console.error(`\n❌ Failed to delete: ${deleteResult.error?.message}\n`);
+        }
+    }
+    catch (error) {
+        console.error('\n❌ Error deleting MCP server:', error.message);
+    }
+}