lua-cli 2.5.6 → 2.5.8

package/dist/commands/skills.js

@@ -0,0 +1,438 @@
+/**
+ * Skills Command
+ * Manages agent skills for sandbox and production environments
+ */
+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';
+/**
+ * Main skills command - manages agent skills
+ *
+ * Features:
+ * - Environment selection (sandbox/staging or production)
+ * - Sandbox: view local skills from configuration
+ * - Production: view deployed skills, versions, and deploy new versions
+ *
+ * @param env - Optional environment argument ('sandbox', 'staging', or 'production')
+ * @returns Promise that resolves when command completes
+ */
+export async function skillsCommand(env) {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration first (to get agentId)
+        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");
+        let selectedEnvironment;
+        // Step 3: Check if environment was provided as argument
+        if (env) {
+            // Normalize the environment (staging is an alias for sandbox)
+            const normalizedEnv = env.toLowerCase();
+            if (normalizedEnv === 'sandbox' || normalizedEnv === 'staging') {
+                selectedEnvironment = 'sandbox';
+            }
+            else if (normalizedEnv === 'production') {
+                selectedEnvironment = 'production';
+            }
+            else {
+                console.error(`❌ Invalid environment: "${env}". Must be "sandbox", "staging", or "production".`);
+                console.log('\nUsage:');
+                console.log('  lua skills                   - Interactive selection');
+                console.log('  lua skills sandbox           - View sandbox skills directly');
+                console.log('  lua skills staging           - View staging skills (alias for sandbox)');
+                console.log('  lua skills production        - Manage production skills directly');
+                process.exit(1);
+            }
+        }
+        else {
+            // Step 4: Prompt for environment selection
+            const envAnswer = await safePrompt([
+                {
+                    type: 'list',
+                    name: 'environment',
+                    message: 'Select environment:',
+                    choices: [
+                        { name: '🔧 Sandbox (local skills)', value: 'sandbox' },
+                        { name: '🚀 Production (deployed skills)', value: 'production' }
+                    ]
+                }
+            ]);
+            if (!envAnswer)
+                return;
+            selectedEnvironment = envAnswer.environment;
+        }
+        const context = {
+            environment: selectedEnvironment,
+            agentId,
+            apiKey,
+        };
+        // Step 5: Start management based on environment
+        if (selectedEnvironment === 'sandbox') {
+            await manageSandboxSkills(context, config);
+        }
+        else {
+            await manageProductionSkills(context, config);
+        }
+    }, "skills");
+}
+/**
+ * Manage sandbox skills - view local configuration
+ */
+async function manageSandboxSkills(context, config) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🔧 Sandbox Skills");
+        console.log("=".repeat(60) + "\n");
+        const skills = config.skills || [];
+        if (skills.length === 0) {
+            console.log("ℹ️  No skills found in configuration.");
+            console.log("💡 Run 'lua compile' to add skills to your configuration.\n");
+        }
+        else {
+            console.log("Local skills in lua.skill.yaml:\n");
+            skills.forEach((skill, index) => {
+                console.log(`${index + 1}. 📦 ${skill.name}`);
+                console.log(`   Version: ${skill.version}`);
+                console.log(`   Skill ID: ${skill.skillId}`);
+                console.log();
+            });
+        }
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '🔄 Refresh list', value: 'refresh' },
+                    { name: '📦 Compile skills', value: 'compile' },
+                    { name: '☁️  Push a skill', value: 'push' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'refresh':
+                // Reload config
+                const newConfig = readSkillConfig();
+                config.skills = newConfig.skills;
+                break;
+            case 'compile':
+                console.log("\n💡 Run 'lua compile' in your terminal to compile your skills.\n");
+                await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+                break;
+            case 'push':
+                console.log("\n💡 Run 'lua push skill' in your terminal to push a skill.\n");
+                await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * Manage production skills - view and deploy versions
+ */
+async function manageProductionSkills(context, config) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🚀 Production Skills");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View deployed skills', value: 'view' },
+                    { name: '📜 View skill versions', value: 'versions' },
+                    { name: '🚀 Deploy a version', value: 'deploy' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await viewDeployedSkills(context, config);
+                break;
+            case 'versions':
+                await viewSkillVersions(context, config);
+                break;
+            case 'deploy':
+                await deploySkillVersion(context, config);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * View deployed skills in production
+ */
+async function viewDeployedSkills(context, config) {
+    writeProgress("🔄 Loading skill information...");
+    try {
+        const skills = config.skills || [];
+        if (skills.length === 0) {
+            console.log("\nℹ️  No skills found in configuration.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            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);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * View versions for a specific skill
+ */
+async function viewSkillVersions(context, config) {
+    const skills = config.skills || [];
+    if (skills.length === 0) {
+        console.log("\nℹ️  No skills found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a skill
+    const skillAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedSkill',
+            message: 'Select a skill to view versions:',
+            choices: skills.map((skill) => ({
+                name: `${skill.name} (${skill.skillId})`,
+                value: skill
+            }))
+        }
+    ]);
+    if (!skillAnswer)
+        return;
+    const selectedSkill = skillAnswer.selectedSkill;
+    writeProgress(`🔄 Loading versions for ${selectedSkill.name}...`);
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/skills/${context.agentId}/${selectedSkill.skillId}/versions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        const versions = data.data?.versions || data.versions || [];
+        const activeVersionId = data.data?.activeVersionId || data.activeVersionId;
+        if (versions.length === 0) {
+            console.log(`\nℹ️  No versions found for ${selectedSkill.name}.\n`);
+            console.log("💡 Push a version first using 'lua push skill'.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        console.log("\n" + "=".repeat(60));
+        console.log(`📜 Versions for ${selectedSkill.name}`);
+        console.log("=".repeat(60) + "\n");
+        // Sort versions by date (newest first)
+        const sortedVersions = versions.sort((a, b) => {
+            const dateA = new Date(a.createdAt).getTime();
+            const dateB = new Date(b.createdAt).getTime();
+            return dateB - dateA;
+        });
+        sortedVersions.forEach((version, index) => {
+            const isActive = version.skillId === activeVersionId;
+            const date = new Date(version.createdAt);
+            console.log(`${index + 1}. Version ${version.version}${isActive ? ' ⭐ DEPLOYED' : ''}`);
+            console.log(`   Created: ${date.toLocaleString()}`);
+            console.log(`   Version ID: ${version.skillId}`);
+            console.log();
+        });
+        console.log("=".repeat(60) + "\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('❌ Error loading versions:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * Deploy a skill version to production
+ */
+async function deploySkillVersion(context, config) {
+    const skills = config.skills || [];
+    if (skills.length === 0) {
+        console.log("\nℹ️  No skills found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a skill
+    const skillAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedSkill',
+            message: 'Select a skill to deploy:',
+            choices: skills.map((skill) => ({
+                name: `${skill.name} (${skill.skillId})`,
+                value: skill
+            }))
+        }
+    ]);
+    if (!skillAnswer)
+        return;
+    const selectedSkill = skillAnswer.selectedSkill;
+    writeProgress(`🔄 Loading versions for ${selectedSkill.name}...`);
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/skills/${context.agentId}/${selectedSkill.skillId}/versions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        const versions = data.data?.versions || data.versions || [];
+        const activeVersionId = data.data?.activeVersionId || data.activeVersionId;
+        if (versions.length === 0) {
+            console.log(`\nℹ️  No versions found for ${selectedSkill.name}.\n`);
+            console.log("💡 Push a version first using 'lua push skill'.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        // Sort versions by date (newest first)
+        const sortedVersions = versions.sort((a, b) => {
+            const dateA = new Date(a.createdAt).getTime();
+            const dateB = new Date(b.createdAt).getTime();
+            return dateB - dateA;
+        });
+        // Prompt to select a version
+        const versionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'selectedVersion',
+                message: 'Select a version to deploy:',
+                choices: sortedVersions.map((version) => {
+                    const isActive = version.skillId === activeVersionId;
+                    const date = new Date(version.createdAt);
+                    return {
+                        name: `Version ${version.version} (${date.toLocaleDateString()})${isActive ? ' ⭐ CURRENT' : ''}`,
+                        value: version
+                    };
+                })
+            }
+        ]);
+        if (!versionAnswer)
+            return;
+        const selectedVersion = versionAnswer.selectedVersion;
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        console.log(`Skill: ${selectedSkill.name}`);
+        console.log(`Version: ${selectedVersion.version}\n`);
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy this version?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled.\n");
+            return;
+        }
+        writeProgress("🔄 Deploying version...");
+        const deployResponse = await fetch(`${BASE_URLS.API}/developer/skills/${context.agentId}/${selectedSkill.skillId}/${selectedVersion.version}/publish`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+        if (!deployResponse.ok) {
+            const errorText = await deployResponse.text();
+            console.error(`\n❌ Deploy Error: ${deployResponse.status} - ${errorText}\n`);
+            throw new Error(`HTTP error! status: ${deployResponse.status}`);
+        }
+        writeSuccess(`\n✅ Version ${selectedVersion.version} of "${selectedSkill.name}" deployed successfully to production\n`);
+        writeInfo("💡 The new version is now active for all users.");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('\n❌ Error deploying version:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}

package/dist/common/basket.instance.js

@@ -12,15 +12,16 @@ export default class BasketInstance {
      * @returns Proxied instance that allows direct access to data and common properties
      */
     constructor(api, basket) {
-        this.data = basket.data;
-        this.common = basket.common;
+        // Ensure data and common are always objects, never null or undefined
+        this.data = basket.data && typeof basket.data === 'object' ? basket.data : {};
+        this.common = basket.common && typeof basket.common === 'object' ? basket.common : {};
         this.id = basket.id;
         this.userId = basket.userId;
         this.agentId = basket.agentId;
-        this.metadata = basket.data.metadata;
-        this.totalAmount = basket.common.totalAmount;
-        this.itemCount = basket.common.itemCount;
-        this.status = basket.common.status;
+        this.metadata = basket.data?.metadata || {};
+        this.totalAmount = basket.common?.totalAmount || 0;
+        this.itemCount = basket.common?.itemCount || 0;
+        this.status = basket.common?.status || BasketStatus.ACTIVE;
         // Make basketAPI non-enumerable so it doesn't show up in console.log
         Object.defineProperty(this, 'basketAPI', {
             value: api,
@@ -35,12 +36,12 @@ export default class BasketInstance {
                 if (prop in target) {
                     return Reflect.get(target, prop, receiver);
                 }
-                // Check data object
-                if (typeof prop === 'string' && prop in target.data) {
+                // Check data object (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return target.data[prop];
                 }
-                // Check common object
-                if (typeof prop === 'string' && prop in target.common) {
+                // Check common object (with null check)
+                if (typeof prop === 'string' && target.common && typeof target.common === 'object' && prop in target.common) {
                     return target.common[prop];
                 }
                 return undefined;
@@ -53,6 +54,13 @@ export default class BasketInstance {
                 }
                 // Check if property exists in data or common, otherwise default to data
                 if (typeof prop === 'string') {
+                    // Initialize objects if they don't exist
+                    if (!target.data || typeof target.data !== 'object') {
+                        target.data = {};
+                    }
+                    if (!target.common || typeof target.common !== 'object') {
+                        target.common = {};
+                    }
                     if (prop in target.common) {
                         target.common[prop] = value;
                     }
@@ -64,14 +72,25 @@ export default class BasketInstance {
                 return false;
             },
             has(target, prop) {
-                // Check if property exists on instance, in data, or in common
-                return prop in target || (typeof prop === 'string' && (prop in target.data || prop in target.common));
+                // Check if property exists on instance, in data, or in common (with null checks)
+                if (prop in target) {
+                    return true;
+                }
+                if (typeof prop === 'string') {
+                    if (target.data && typeof target.data === 'object' && prop in target.data) {
+                        return true;
+                    }
+                    if (target.common && typeof target.common === 'object' && prop in target.common) {
+                        return true;
+                    }
+                }
+                return false;
             },
             ownKeys(target) {
-                // Return instance keys, data keys, and common keys
+                // Return instance keys, data keys, and common keys (with null checks)
                 const instanceKeys = Reflect.ownKeys(target);
-                const dataKeys = Object.keys(target.data);
-                const commonKeys = Object.keys(target.common);
+                const dataKeys = target.data && typeof target.data === 'object' ? Object.keys(target.data) : [];
+                const commonKeys = target.common && typeof target.common === 'object' ? Object.keys(target.common) : [];
                 return [...new Set([...instanceKeys, ...dataKeys, ...commonKeys])];
             },
             getOwnPropertyDescriptor(target, prop) {
@@ -80,8 +99,8 @@ export default class BasketInstance {
                 if (instanceDesc) {
                     return instanceDesc;
                 }
-                // Then check data properties
-                if (typeof prop === 'string' && prop in target.data) {
+                // Then check data properties (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return {
                         configurable: true,
                         enumerable: true,
@@ -89,8 +108,8 @@ export default class BasketInstance {
                         value: target.data[prop]
                     };
                 }
-                // Then check common properties
-                if (typeof prop === 'string' && prop in target.common) {
+                // Then check common properties (with null check)
+                if (typeof prop === 'string' && target.common && typeof target.common === 'object' && prop in target.common) {
                     return {
                         configurable: true,
                         enumerable: true,

package/dist/common/data.entry.instance.d.ts

@@ -39,4 +39,11 @@ export default class DataEntryInstance {
      * @throws Error if the deletion fails
      */
     delete(): Promise<boolean>;
+    /**
+     * Saves the data entry
+     * @param searchText - Optional search text for vector search indexing
+     * @returns Promise resolving to true if saving was successful
+     * @throws Error if the save operation fails
+     */
+    save(searchText?: string): Promise<boolean>;
 }

package/dist/common/data.entry.instance.js

@@ -12,7 +12,8 @@ export default class DataEntryInstance {
      * @returns Proxied instance that allows direct access to data properties
      */
     constructor(api, entry, collectionName) {
-        this.data = entry.data;
+        // Ensure data is always an object, never null or undefined
+        this.data = entry.data && typeof entry.data === 'object' ? entry.data : {};
         this.id = entry.id;
         this.collectionName = collectionName;
         this.score = entry.score;
@@ -30,8 +31,8 @@ export default class DataEntryInstance {
                 if (prop in target) {
                     return Reflect.get(target, prop, receiver);
                 }
-                // Otherwise, try to get it from the data object
-                if (typeof prop === 'string' && prop in target.data) {
+                // Otherwise, try to get it from the data object (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return target.data[prop];
                 }
                 return undefined;
@@ -44,19 +45,29 @@ export default class DataEntryInstance {
                 }
                 // All other properties get set on the data object
                 if (typeof prop === 'string') {
+                    // Initialize data object if it doesn't exist
+                    if (!target.data || typeof target.data !== 'object') {
+                        target.data = {};
+                    }
                     target.data[prop] = value;
                     return true;
                 }
                 return false;
             },
             has(target, prop) {
-                // Check if property exists on instance or in data
-                return prop in target || (typeof prop === 'string' && prop in target.data);
+                // Check if property exists on instance or in data (with null check)
+                if (prop in target) {
+                    return true;
+                }
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object') {
+                    return prop in target.data;
+                }
+                return false;
             },
             ownKeys(target) {
-                // Return both instance keys and data keys
+                // Return both instance keys and data keys (with null check)
                 const instanceKeys = Reflect.ownKeys(target);
-                const dataKeys = Object.keys(target.data);
+                const dataKeys = target.data && typeof target.data === 'object' ? Object.keys(target.data) : [];
                 return [...new Set([...instanceKeys, ...dataKeys])];
             },
             getOwnPropertyDescriptor(target, prop) {
@@ -65,8 +76,8 @@ export default class DataEntryInstance {
                 if (instanceDesc) {
                     return instanceDesc;
                 }
-                // Then check if it's a data property
-                if (typeof prop === 'string' && prop in target.data) {
+                // Then check if it's a data property (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return {
                         configurable: true,
                         enumerable: true,
@@ -133,4 +144,19 @@ export default class DataEntryInstance {
             throw new Error('Failed to clear user data');
         }
     }
+    /**
+     * Saves the data entry
+     * @param searchText - Optional search text for vector search indexing
+     * @returns Promise resolving to true if saving was successful
+     * @throws Error if the save operation fails
+     */
+    async save(searchText) {
+        try {
+            await this.customDataAPI.update(this.collectionName, this.id, { data: this.data, searchText: searchText });
+            return true;
+        }
+        catch (error) {
+            throw new Error('Failed to save data entry');
+        }
+    }
 }

package/dist/common/order.instance.d.ts

@@ -40,4 +40,10 @@ export default class OrderInstance {
      * @throws Error if the data update fails
      */
     update(data: Record<string, any>): Promise<any>;
+    /**
+     * Saves the order's data
+     * @returns Promise resolving to true if saving was successful
+     * @throws Error if the save operation fails
+     */
+    save(): Promise<boolean>;
 }