lua-cli 2.3.2 → 2.4.0

package/dist/commands/env.js

@@ -0,0 +1,434 @@
+/**
+ * Environment Variables Command
+ * Manages environment variables for sandbox and production environments
+ */
+import fs from 'fs';
+import path from 'path';
+import inquirer from 'inquirer';
+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 { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
+/**
+ * Main env command - manages environment variables
+ *
+ * Features:
+ * - Environment selection (sandbox or production)
+ * - List all environment variables
+ * - Add new variables
+ * - Update existing variables
+ * - Delete variables
+ * - Sandbox: manages .env file
+ * - Production: uses API endpoints
+ *
+ * @returns Promise that resolves when command completes
+ */
+export async function envCommand() {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration
+        const config = readSkillConfig();
+        validateConfig(config);
+        validateAgentConfig(config);
+        const agentId = config.agent.agentId;
+        // Step 2: Select environment
+        const { environment } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'environment',
+                message: 'Select environment:',
+                choices: [
+                    { name: '🔧 Sandbox (.env file)', value: 'sandbox' },
+                    { name: '🚀 Production (API)', value: 'production' }
+                ]
+            }
+        ]);
+        let context = {
+            environment,
+            agentId,
+            apiKey: '',
+        };
+        // Step 3: Authenticate (needed for production)
+        if (environment === 'production') {
+            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);
+            context.apiKey = apiKey;
+            writeProgress("✅ Authenticated");
+        }
+        // Step 4: Start management loop
+        await manageEnvironmentVariables(context);
+    }, "env");
+}
+/**
+ * Main management loop for environment variables
+ */
+async function manageEnvironmentVariables(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        // Load current variables
+        const variables = await loadEnvironmentVariables(context);
+        // Show current state
+        console.log("\n" + "=".repeat(60));
+        console.log(`🌙 Environment Variables (${context.environment === 'sandbox' ? 'Sandbox' : 'Production'})`);
+        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();
+        }
+        // Show menu
+        const { action } = await inquirer.prompt([
+            {
+                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: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        switch (action) {
+            case 'add':
+                await addVariable(context, variables);
+                break;
+            case 'update':
+                await updateVariable(context, variables);
+                break;
+            case 'delete':
+                await deleteVariable(context, variables);
+                break;
+            case 'view':
+                await viewVariable(variables);
+                break;
+            case 'refresh':
+                // Just loop again
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * Load environment variables based on context
+ */
+async function loadEnvironmentVariables(context) {
+    if (context.environment === 'sandbox') {
+        return loadSandboxEnvVariables();
+    }
+    else {
+        return loadProductionEnvVariables(context);
+    }
+}
+/**
+ * Load sandbox environment variables from .env file
+ */
+function loadSandboxEnvVariables() {
+    const envFilePath = path.join(process.cwd(), '.env');
+    if (!fs.existsSync(envFilePath)) {
+        return [];
+    }
+    try {
+        const content = fs.readFileSync(envFilePath, 'utf8');
+        return parseEnvContent(content);
+    }
+    catch (error) {
+        console.error('❌ Error reading .env file:', error);
+        return [];
+    }
+}
+/**
+ * Load production environment variables from API
+ */
+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) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        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 production env variables:', error);
+        return [];
+    }
+}
+/**
+ * Parse .env file content into variables
+ */
+function parseEnvContent(content) {
+    if (!content.trim())
+        return [];
+    return content
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'))
+        .map(line => {
+        const [key, ...valueParts] = line.split('=');
+        return {
+            key: key?.trim() || '',
+            value: valueParts.join('=') || ''
+        };
+    })
+        .filter(item => item.key);
+}
+/**
+ * Convert variables array to .env file content
+ */
+function variablesToEnvContent(variables) {
+    return variables
+        .map(v => `${v.key}=${v.value}`)
+        .join('\n');
+}
+/**
+ * Save sandbox environment variables to .env file
+ */
+function saveSandboxEnvVariables(variables) {
+    const envFilePath = path.join(process.cwd(), '.env');
+    try {
+        const content = variablesToEnvContent(variables);
+        fs.writeFileSync(envFilePath, content, 'utf8');
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Error saving .env file:', error);
+        return false;
+    }
+}
+/**
+ * Save production environment variables via API
+ */
+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 production env variables:', error);
+        return false;
+    }
+}
+/**
+ * Add a new environment variable
+ */
+async function addVariable(context, currentVariables) {
+    const answers = await inquirer.prompt([
+        {
+            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:',
+            validate: (input) => {
+                if (input === '')
+                    return true; // Allow empty values
+                return true;
+            }
+        }
+    ]);
+    const newVariable = {
+        key: answers.key.trim(),
+        value: answers.value
+    };
+    const updatedVariables = [...currentVariables, newVariable];
+    writeProgress("🔄 Saving...");
+    let success = false;
+    if (context.environment === 'sandbox') {
+        success = saveSandboxEnvVariables(updatedVariables);
+    }
+    else {
+        success = await saveProductionEnvVariables(context, updatedVariables);
+    }
+    if (success) {
+        writeSuccess(`✅ Variable "${newVariable.key}" added successfully`);
+    }
+    else {
+        console.error("❌ Failed to save variable");
+    }
+}
+/**
+ * Update an existing environment variable
+ */
+async function updateVariable(context, currentVariables) {
+    if (currentVariables.length === 0) {
+        console.log("\nℹ️  No variables to update.\n");
+        return;
+    }
+    const { selectedKey } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedKey',
+            message: 'Select variable to update:',
+            choices: currentVariables.map(v => ({
+                name: v.key,
+                value: v.key
+            }))
+        }
+    ]);
+    const currentVariable = currentVariables.find(v => v.key === selectedKey);
+    const { newValue } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'newValue',
+            message: `New value for ${selectedKey}:`,
+            default: currentVariable.value
+        }
+    ]);
+    const updatedVariables = currentVariables.map(v => v.key === selectedKey ? { ...v, value: newValue } : v);
+    writeProgress("🔄 Saving...");
+    let success = false;
+    if (context.environment === 'sandbox') {
+        success = saveSandboxEnvVariables(updatedVariables);
+    }
+    else {
+        success = await saveProductionEnvVariables(context, updatedVariables);
+    }
+    if (success) {
+        writeSuccess(`✅ Variable "${selectedKey}" updated successfully`);
+    }
+    else {
+        console.error("❌ Failed to update variable");
+    }
+}
+/**
+ * Delete an environment variable
+ */
+async function deleteVariable(context, currentVariables) {
+    if (currentVariables.length === 0) {
+        console.log("\nℹ️  No variables to delete.\n");
+        return;
+    }
+    const { selectedKey } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedKey',
+            message: 'Select variable to delete:',
+            choices: currentVariables.map(v => ({
+                name: v.key,
+                value: v.key
+            }))
+        }
+    ]);
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to delete "${selectedKey}"?`,
+            default: false
+        }
+    ]);
+    if (!confirm) {
+        console.log("\nℹ️  Deletion cancelled.\n");
+        return;
+    }
+    const updatedVariables = currentVariables.filter(v => v.key !== selectedKey);
+    writeProgress("🔄 Saving...");
+    let success = false;
+    if (context.environment === 'sandbox') {
+        success = saveSandboxEnvVariables(updatedVariables);
+    }
+    else {
+        success = await saveProductionEnvVariables(context, updatedVariables);
+    }
+    if (success) {
+        writeSuccess(`✅ Variable "${selectedKey}" deleted successfully`);
+    }
+    else {
+        console.error("❌ Failed to delete variable");
+    }
+}
+/**
+ * View a variable's full value (unmasked)
+ */
+async function viewVariable(currentVariables) {
+    if (currentVariables.length === 0) {
+        console.log("\nℹ️  No variables to view.\n");
+        return;
+    }
+    const { selectedKey } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedKey',
+            message: 'Select variable to view:',
+            choices: currentVariables.map(v => ({
+                name: v.key,
+                value: v.key
+            }))
+        }
+    ]);
+    const variable = currentVariables.find(v => v.key === 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 inquirer.prompt([
+        {
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+        }
+    ]);
+}

package/dist/commands/index.d.ts

@@ -7,3 +7,9 @@ export { testCommand } from "./test.js";
 export { pushCommand } from "./push.js";
 export { deployCommand } from "./deploy.js";
 export { devCommand } from "./dev.js";
+export { chatCommand } from "./chat.js";
+export { chatClearCommand } from "./chatClear.js";
+export { envCommand } from "./env.js";
+export { personaCommand } from "./persona.js";
+export { productionCommand } from "./production.js";
+export { resourcesCommand } from "./resources.js";

package/dist/commands/index.js

@@ -7,3 +7,9 @@ export { testCommand } from "./test.js";
 export { pushCommand } from "./push.js";
 export { deployCommand } from "./deploy.js";
 export { devCommand } from "./dev.js";
+export { chatCommand } from "./chat.js";
+export { chatClearCommand } from "./chatClear.js";
+export { envCommand } from "./env.js";
+export { personaCommand } from "./persona.js";
+export { productionCommand } from "./production.js";
+export { resourcesCommand } from "./resources.js";

package/dist/commands/persona.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Persona Command
+ * Manages agent persona for sandbox and production environments
+ */
+/**
+ * Main persona command - manages agent persona
+ *
+ * Features:
+ * - Environment selection (sandbox or production)
+ * - Sandbox: view, edit, save persona + create versions
+ * - Production: list versions, view details, deploy versions
+ *
+ * @returns Promise that resolves when command completes
+ */
+export declare function personaCommand(): Promise<void>;