lua-cli 2.3.2 → 2.4.1

package/dist/commands/production.js

@@ -0,0 +1,532 @@
+/**
+ * Production Command
+ * Overview and management of production environment
+ */
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess } 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';
+/**
+ * Main production command - overview of production environment
+ *
+ * Features:
+ * - View current persona and versions
+ * - View deployed skills and versions
+ * - Manage environment variables
+ *
+ * @returns Promise that resolves when command completes
+ */
+export async function productionCommand() {
+    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 context = {
+            agentId,
+            apiKey,
+        };
+        // Step 3: Start management loop
+        await manageProduction(context, config);
+    }, "production");
+}
+/**
+ * Main production management loop
+ */
+async function manageProduction(context, config) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🌙 Production Environment");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to view?',
+                choices: [
+                    { name: '🤖 Persona - View current persona and versions', value: 'persona' },
+                    { name: '⚙️  Skills - View deployed skills and versions', value: 'skills' },
+                    { name: '🔐 Environment Variables - Manage production env', value: 'env' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'persona':
+                await viewProductionPersona(context);
+                break;
+            case 'skills':
+                await viewProductionSkills(context, config);
+                break;
+            case 'env':
+                await manageProductionEnv(context);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * View production persona and versions
+ */
+async function viewProductionPersona(context) {
+    writeProgress("🔄 Loading persona information...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/persona/versions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`\n❌ API Error: ${response.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        let versions = [];
+        if (Array.isArray(data)) {
+            versions = data;
+        }
+        else if (data.data && Array.isArray(data.data)) {
+            versions = data.data;
+        }
+        else if (data.versions && Array.isArray(data.versions)) {
+            versions = data.versions;
+        }
+        if (versions.length === 0) {
+            console.log("\nℹ️  No persona versions found.");
+            console.log("💡 Create a persona version first using: lua persona\n");
+            await safePrompt([
+                {
+                    type: 'input',
+                    name: 'continue',
+                    message: 'Press Enter to continue...'
+                }
+            ]);
+            return;
+        }
+        // Find current deployed version
+        const currentVersion = versions.find(v => v.isCurrent);
+        console.log("\n" + "=".repeat(60));
+        console.log("🤖 Current Production Persona");
+        console.log("=".repeat(60) + "\n");
+        if (currentVersion) {
+            const date = new Date(currentVersion.createdDate);
+            console.log(`Version: ${currentVersion.version} ⭐`);
+            console.log(`Deployed: ${date.toLocaleString()}`);
+            if (currentVersion.createdBy) {
+                console.log(`Created by: ${currentVersion.createdBy}`);
+            }
+            console.log("\n" + "-".repeat(60) + "\n");
+            console.log(currentVersion.persona);
+            console.log("\n" + "=".repeat(60) + "\n");
+        }
+        else {
+            console.log("⚠️  No persona currently deployed.");
+            console.log("💡 Deploy a version using: lua persona → Production → Deploy\n");
+            console.log("Available versions:\n");
+            versions.forEach((v, i) => {
+                const date = new Date(v.createdDate);
+                console.log(`  ${i + 1}. Version ${v.version} - ${date.toLocaleDateString()}`);
+            });
+            console.log();
+        }
+        // Show available versions
+        console.log(`Total versions available: ${versions.length}\n`);
+        await safePrompt([
+            {
+                type: 'input',
+                name: 'continue',
+                message: 'Press Enter to continue...'
+            }
+        ]);
+    }
+    catch (error) {
+        console.error('❌ Error loading persona information:', error);
+        if (error instanceof Error) {
+            console.error(`   ${error.message}\n`);
+        }
+        await safePrompt([
+            {
+                type: 'input',
+                name: 'continue',
+                message: 'Press Enter to continue...'
+            }
+        ]);
+    }
+}
+/**
+ * View production skills and their versions
+ */
+async function viewProductionSkills(context, config) {
+    writeProgress("🔄 Loading skill information...");
+    try {
+        const skills = config.skills || [];
+        if (skills.length === 0) {
+            console.log("\nℹ️  No skills found in configuration.\n");
+            return;
+        }
+        console.log("\n" + "=".repeat(60));
+        console.log("⚙️  Production Skills");
+        console.log("=".repeat(60) + "\n");
+        // Fetch version info for each skill
+        for (const skill of skills) {
+            try {
+                const response = await fetch(`${BASE_URLS.API}/developer/skills/${context.agentId}/${skill.skillId}/versions`, {
+                    method: 'GET',
+                    headers: {
+                        'Authorization': `Bearer ${context.apiKey}`,
+                        'Content-Type': 'application/json'
+                    }
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    const versions = data.data?.versions || data.versions || [];
+                    const activeVersionId = data.data?.activeVersionId || data.activeVersionId;
+                    // Find active version
+                    const activeVersion = versions.find((v) => v.skillId === activeVersionId);
+                    console.log(`📦 ${skill.name}`);
+                    console.log(`   Skill ID: ${skill.skillId}`);
+                    if (activeVersion) {
+                        console.log(`   Deployed Version: ${activeVersion.version} ⭐`);
+                        const date = new Date(activeVersion.createdAt);
+                        console.log(`   Deployed: ${date.toLocaleString()}`);
+                    }
+                    else {
+                        console.log(`   Deployed Version: Not deployed`);
+                    }
+                    console.log(`   Total Versions: ${versions.length}`);
+                    console.log();
+                }
+                else {
+                    console.log(`📦 ${skill.name}`);
+                    console.log(`   Skill ID: ${skill.skillId}`);
+                    console.log(`   Status: Unable to fetch version info`);
+                    console.log();
+                }
+            }
+            catch (error) {
+                console.log(`📦 ${skill.name}`);
+                console.log(`   Skill ID: ${skill.skillId}`);
+                console.log(`   Status: Error loading versions`);
+                console.log();
+            }
+        }
+        console.log("=".repeat(60) + "\n");
+        await safePrompt([
+            {
+                type: 'input',
+                name: 'continue',
+                message: 'Press Enter to continue...'
+            }
+        ]);
+    }
+    catch (error) {
+        console.error('❌ Error loading skill information:', error);
+    }
+}
+/**
+ * Manage production environment variables
+ */
+async function manageProductionEnv(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        // Load current variables
+        const variables = await loadProductionEnvVariables(context);
+        console.log("\n" + "=".repeat(60));
+        console.log("🔐 Production Environment Variables");
+        console.log("=".repeat(60) + "\n");
+        if (variables.length === 0) {
+            console.log("ℹ️  No environment variables configured.\n");
+        }
+        else {
+            variables.forEach((v, index) => {
+                // Mask values partially for security
+                const maskedValue = v.value.length > 4
+                    ? v.value.substring(0, 4) + '*'.repeat(Math.min(v.value.length - 4, 20))
+                    : '*'.repeat(v.value.length);
+                console.log(`${index + 1}. ${v.key} = ${maskedValue}`);
+            });
+            console.log();
+        }
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '➕ Add new variable', value: 'add' },
+                    { name: '✏️  Update existing variable', value: 'update' },
+                    { name: '🗑️  Delete variable', value: 'delete' },
+                    { name: '👁️  View variable value', value: 'view' },
+                    { name: '🔄 Refresh list', value: 'refresh' },
+                    { name: '⬅️  Back to main menu', value: 'back' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'add':
+                await addProductionVariable(context, variables);
+                break;
+            case 'update':
+                await updateProductionVariable(context, variables);
+                break;
+            case 'delete':
+                await deleteProductionVariable(context, variables);
+                break;
+            case 'view':
+                await viewProductionVariable(variables);
+                break;
+            case 'refresh':
+                // Just loop again
+                break;
+            case 'back':
+                continueManaging = false;
+                break;
+        }
+    }
+}
+/**
+ * Load production environment variables
+ */
+async function loadProductionEnvVariables(context) {
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/env`, {
+            method: 'GET',
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${context.apiKey}`
+            }
+        });
+        if (!response.ok) {
+            return [];
+        }
+        const data = await response.json();
+        if (data.data && typeof data.data === 'object') {
+            return Object.entries(data.data).map(([key, value]) => ({
+                key,
+                value: String(value)
+            }));
+        }
+        return [];
+    }
+    catch (error) {
+        console.error('⚠️  Error loading environment variables');
+        return [];
+    }
+}
+/**
+ * Save production environment variables
+ */
+async function saveProductionEnvVariables(context, variables) {
+    try {
+        const envData = {};
+        variables.forEach(v => {
+            if (v.key.trim()) {
+                envData[v.key.trim()] = v.value;
+            }
+        });
+        const response = await fetch(`${BASE_URLS.API}/developer/agents/${context.agentId}/env`, {
+            method: 'POST',
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(envData)
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Error saving environment variables:', error);
+        return false;
+    }
+}
+/**
+ * Add a new production environment variable
+ */
+async function addProductionVariable(context, currentVariables) {
+    const answers = await safePrompt([
+        {
+            type: 'input',
+            name: 'key',
+            message: 'Variable name:',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Variable name is required';
+                if (!/^[A-Z_][A-Z0-9_]*$/i.test(input.trim())) {
+                    return 'Variable name must start with a letter or underscore and contain only letters, numbers, and underscores';
+                }
+                if (currentVariables.some(v => v.key === input.trim())) {
+                    return 'Variable already exists. Use update to modify it.';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'input',
+            name: 'value',
+            message: 'Variable value:',
+        }
+    ]);
+    if (!answers)
+        return;
+    const newVariable = {
+        key: answers.key.trim(),
+        value: answers.value
+    };
+    const updatedVariables = [...currentVariables, newVariable];
+    writeProgress("🔄 Saving...");
+    const success = await saveProductionEnvVariables(context, updatedVariables);
+    if (success) {
+        writeSuccess(`✅ Variable "${newVariable.key}" added successfully`);
+    }
+    else {
+        console.error("❌ Failed to save variable");
+    }
+}
+/**
+ * Update an existing production environment variable
+ */
+async function updateProductionVariable(context, currentVariables) {
+    if (currentVariables.length === 0) {
+        console.log("\nℹ️  No variables to update.\n");
+        return;
+    }
+    const selectAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedKey',
+            message: 'Select variable to update:',
+            choices: currentVariables.map(v => ({
+                name: v.key,
+                value: v.key
+            }))
+        }
+    ]);
+    if (!selectAnswer)
+        return;
+    const currentVariable = currentVariables.find(v => v.key === selectAnswer.selectedKey);
+    const valueAnswer = await safePrompt([
+        {
+            type: 'input',
+            name: 'newValue',
+            message: `New value for ${selectAnswer.selectedKey}:`,
+            default: currentVariable.value
+        }
+    ]);
+    if (!valueAnswer)
+        return;
+    const updatedVariables = currentVariables.map(v => v.key === selectAnswer.selectedKey ? { ...v, value: valueAnswer.newValue } : v);
+    writeProgress("🔄 Saving...");
+    const success = await saveProductionEnvVariables(context, updatedVariables);
+    if (success) {
+        writeSuccess(`✅ Variable "${selectAnswer.selectedKey}" updated successfully`);
+    }
+    else {
+        console.error("❌ Failed to update variable");
+    }
+}
+/**
+ * Delete a production environment variable
+ */
+async function deleteProductionVariable(context, currentVariables) {
+    if (currentVariables.length === 0) {
+        console.log("\nℹ️  No variables to delete.\n");
+        return;
+    }
+    const selectAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedKey',
+            message: 'Select variable to delete:',
+            choices: currentVariables.map(v => ({
+                name: v.key,
+                value: v.key
+            }))
+        }
+    ]);
+    if (!selectAnswer)
+        return;
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to delete "${selectAnswer.selectedKey}" from production?`,
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\nℹ️  Deletion cancelled.\n");
+        return;
+    }
+    const updatedVariables = currentVariables.filter(v => v.key !== selectAnswer.selectedKey);
+    writeProgress("🔄 Saving...");
+    const success = await saveProductionEnvVariables(context, updatedVariables);
+    if (success) {
+        writeSuccess(`✅ Variable "${selectAnswer.selectedKey}" deleted successfully`);
+    }
+    else {
+        console.error("❌ Failed to delete variable");
+    }
+}
+/**
+ * View a variable's full value (unmasked)
+ */
+async function viewProductionVariable(currentVariables) {
+    if (currentVariables.length === 0) {
+        console.log("\nℹ️  No variables to view.\n");
+        return;
+    }
+    const selectAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedKey',
+            message: 'Select variable to view:',
+            choices: currentVariables.map(v => ({
+                name: v.key,
+                value: v.key
+            }))
+        }
+    ]);
+    if (!selectAnswer)
+        return;
+    const variable = currentVariables.find(v => v.key === selectAnswer.selectedKey);
+    console.log("\n" + "=".repeat(60));
+    console.log(`Variable: ${variable.key}`);
+    console.log("=".repeat(60));
+    console.log(variable.value);
+    console.log("=".repeat(60) + "\n");
+    await safePrompt([
+        {
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+        }
+    ]);
+}

package/dist/commands/push.js

@@ -6,8 +6,10 @@ import { compileCommand } from './compile.js';
 import { checkApiKey, loadApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
+import { safePrompt } from '../utils/prompt-handler.js';
 import { readDeployJson, validatePushConfig, validateDeployData, promptSkillSelection, promptVersionConfirmOrUpdate, getAvailableSkills, updateSkillVersionInYaml, getSkillDeployData, } from '../utils/push-helpers.js';
 import { pushVersion } from '../utils/push-api.js';
+import { fetchVersions, publishVersion, } from '../utils/deploy-api.js';
 /**
  * Main push command - pushes a skill version to the server.
  *
@@ -84,6 +86,18 @@ export async function pushCommand() {
         const result = await pushVersion(apiKey, agentId, skillId, skillDeployData);
         if (result.success && result.data) {
             writeSuccess(`✅ Version ${result.data.version} of "${selectedSkill.name}" pushed successfully`);
+            // Ask if user wants to deploy now
+            const deployAnswer = await safePrompt([
+                {
+                    type: 'confirm',
+                    name: 'deployNow',
+                    message: 'Would you like to deploy this version to production now?',
+                    default: false
+                }
+            ]);
+            if (deployAnswer && deployAnswer.deployNow) {
+                await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, result.data.version);
+            }
         }
         else if (result.error) {
             console.error(`❌ ${result.error.message}`);
@@ -95,3 +109,45 @@ export async function pushCommand() {
         }
     }, "push");
 }
+/**
+ * Deploy a version immediately after pushing
+ */
+async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVersion) {
+    try {
+        writeProgress("\n🔄 Fetching available versions...");
+        // Fetch versions to verify the pushed version exists
+        const versionsResponse = await fetchVersions(apiKey, agentId, selectedSkill.skillId);
+        if (!versionsResponse.versions || versionsResponse.versions.length === 0) {
+            console.error("❌ No versions available. The push may have failed.");
+            return;
+        }
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled. Version pushed but not deployed.\n");
+            return;
+        }
+        // Find the pushed version in the list
+        const versionToDeploy = versionsResponse.versions.find((v) => v.version === pushedVersion);
+        if (!versionToDeploy) {
+            console.error(`\n❌ Version ${pushedVersion} not found in available versions.\n`);
+            return;
+        }
+        writeProgress("🔄 Publishing version...");
+        const publishResponse = await publishVersion(apiKey, agentId, selectedSkill.skillId, pushedVersion);
+        writeSuccess(`\n✅ Version ${pushedVersion} of "${selectedSkill.name}" deployed successfully to production\n`);
+    }
+    catch (error) {
+        console.error('\n❌ Error deploying version:', error);
+        console.log('💡 You can deploy later using: lua deploy\n');
+    }
+}

package/dist/commands/resources.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resources Command
+ * Manages agent resources (knowledge base documents)
+ */
+/**
+ * Main resources command - manages agent resources
+ *
+ * Features:
+ * - List all resources
+ * - Create new resources
+ * - Update existing resources
+ * - Delete resources
+ * - View resource content
+ *
+ * @returns Promise that resolves when command completes
+ */
+export declare function resourcesCommand(): Promise<void>;