lua-cli 2.3.0 → 2.4.0

package/dist/commands/push.js

@@ -5,19 +5,23 @@
 import { compileCommand } from './compile.js';
 import { checkApiKey, loadApiKey } from '../services/auth.js';
 import { readSkillConfig } from '../utils/files.js';
-import { withErrorHandling, writeProgress, writeSuccess } from '../utils/cli.js';
-import { readDeployJson, confirmVersionPush, validatePushConfig, validateDeployData, } from '../utils/push-helpers.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.
  *
  * This command performs the following steps:
  * 1. Validates configuration has required fields
- * 2. Prompts for user confirmation
- * 3. Authenticates the user
- * 4. Compiles the skill
- * 5. Validates deploy.json matches configuration
- * 6. Pushes version to server
+ * 2. Prompts user to select a skill (if multiple skills exist)
+ * 3. Prompts to confirm or update version
+ * 4. Authenticates the user
+ * 5. Compiles the skill (always, to ensure deploy.json is current)
+ * 6. Validates deploy.json matches configuration for selected skill
+ * 7. Extracts the specific skill's deploy data
+ * 8. Pushes version to server
  *
  * Use this command to:
  * - Upload a new version of your skill
@@ -33,14 +37,33 @@ export async function pushCommand() {
         // Step 1: Validate configuration
         const config = readSkillConfig();
         validatePushConfig(config);
-        const version = config.skill.version;
-        // Step 2: Confirm with user
-        const confirmed = await confirmVersionPush(version);
-        if (!confirmed) {
-            console.log("❌ Push cancelled.");
-            process.exit(0);
+        // Step 2: Get available skills and prompt for selection
+        const availableSkills = getAvailableSkills(config);
+        if (availableSkills.length === 0) {
+            console.error("❌ No skills found in configuration. Please compile your skill first using 'lua compile'.");
+            process.exit(1);
+        }
+        let selectedSkill;
+        if (availableSkills.length === 1) {
+            // Only one skill, use it automatically
+            selectedSkill = availableSkills[0];
+            writeInfo(`📦 Pushing skill: ${selectedSkill.name}`);
+        }
+        else {
+            // Multiple skills, prompt for selection
+            selectedSkill = await promptSkillSelection(availableSkills);
+            writeInfo(`📦 Selected skill: ${selectedSkill.name}`);
+        }
+        // Step 3: Confirm or update version
+        const confirmedVersion = await promptVersionConfirmOrUpdate(selectedSkill.version);
+        let versionUpdated = false;
+        if (confirmedVersion !== selectedSkill.version) {
+            writeInfo(`📝 Updating version from ${selectedSkill.version} to ${confirmedVersion}`);
+            updateSkillVersionInYaml(selectedSkill.name, confirmedVersion);
+            selectedSkill.version = confirmedVersion;
+            versionUpdated = true;
         }
-        // Step 3: Authenticate
+        // Step 4: Authenticate
         const apiKey = await loadApiKey();
         if (!apiKey) {
             console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
@@ -48,19 +71,33 @@ export async function pushCommand() {
         }
         const userData = await checkApiKey(apiKey);
         writeProgress("✅ Authenticated");
-        // Step 4: Compile the skill
+        // Step 5: Compile the skill (always compile to ensure up-to-date, or if version was updated)
         writeProgress("🔄 Compiling skill...");
         await compileCommand();
-        // Step 5: Validate deploy data
+        // Step 6: Validate deploy data for the selected skill
         const deployData = readDeployJson();
-        validateDeployData(deployData, version);
-        // Step 6: Push version to server
+        validateDeployData(deployData, selectedSkill);
+        // Step 7: Extract the specific skill's deploy data
+        const skillDeployData = getSkillDeployData(deployData, selectedSkill.name);
+        // Step 8: Push version to server
         const agentId = config.agent.agentId;
-        const skillId = config.skill.skillId;
+        const skillId = selectedSkill.skillId;
         writeProgress("🔄 Pushing version to server...");
-        const result = await pushVersion(apiKey, agentId, skillId, deployData);
+        const result = await pushVersion(apiKey, agentId, skillId, skillDeployData);
         if (result.success && result.data) {
-            writeSuccess(`✅ Version ${result.data.version} pushed successfully`);
+            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}`);
@@ -72,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>;

package/dist/commands/resources.js

@@ -0,0 +1,361 @@
+/**
+ * Resources Command
+ * Manages agent resources (knowledge base documents)
+ */
+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 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 async function resourcesCommand() {
+    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 manageResources(context);
+    }, "resources");
+}
+/**
+ * Main resources management loop
+ */
+async function manageResources(context) {
+    let continueManaging = true;
+    while (continueManaging) {
+        // Load current resources
+        const resources = await loadResources(context);
+        console.log("\n" + "=".repeat(60));
+        console.log("📚 Agent Resources");
+        console.log("=".repeat(60) + "\n");
+        if (resources.length === 0) {
+            console.log("ℹ️  No resources configured.\n");
+            console.log("💡 Resources are knowledge base documents your agent can reference.\n");
+        }
+        else {
+            resources.forEach((resource, index) => {
+                const preview = resource.content.length > 60
+                    ? resource.content.substring(0, 60) + '...'
+                    : resource.content;
+                console.log(`${index + 1}. ${resource.name}`);
+                console.log(`   Preview: ${preview}`);
+                console.log();
+            });
+        }
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '➕ Create new resource', value: 'create' },
+                    { name: '✏️  Update existing resource', value: 'update' },
+                    { name: '🗑️  Delete resource', value: 'delete' },
+                    { name: '👁️  View resource content', value: 'view' },
+                    { name: '🔄 Refresh list', value: 'refresh' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'create':
+                await createResource(context);
+                break;
+            case 'update':
+                await updateResource(context, resources);
+                break;
+            case 'delete':
+                await deleteResource(context, resources);
+                break;
+            case 'view':
+                await viewResource(resources);
+                break;
+            case 'refresh':
+                // Just loop again
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * Load resources from API
+ */
+async function loadResources(context) {
+    try {
+        const response = await fetch(`${BASE_URLS.API}/admin/agents/${context.agentId}/resources`, {
+            method: 'GET',
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${context.apiKey}`
+            }
+        });
+        if (!response.ok) {
+            return [];
+        }
+        const data = await response.json();
+        if (Array.isArray(data)) {
+            return data;
+        }
+        else if (data.data && Array.isArray(data.data)) {
+            return data.data;
+        }
+        return [];
+    }
+    catch (error) {
+        console.error('⚠️  Error loading resources');
+        return [];
+    }
+}
+/**
+ * Create a new resource
+ */
+async function createResource(context) {
+    const answers = await safePrompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Resource name:',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Resource name is required';
+                return true;
+            }
+        },
+        {
+            type: 'editor',
+            name: 'content',
+            message: 'Resource content (will open in your default editor):',
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Resource content cannot be empty';
+                return true;
+            }
+        }
+    ]);
+    if (!answers)
+        return;
+    writeProgress("🔄 Creating resource...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/admin/agents/${context.agentId}/resources`, {
+            method: 'POST',
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: answers.name.trim(),
+                content: answers.content.trim()
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP error! status: ${response.status} - ${errorText}`);
+        }
+        writeSuccess(`✅ Resource "${answers.name}" created successfully`);
+    }
+    catch (error) {
+        console.error('❌ Error creating resource:', error);
+    }
+}
+/**
+ * Update an existing resource
+ */
+async function updateResource(context, resources) {
+    if (resources.length === 0) {
+        console.log("\nℹ️  No resources to update.\n");
+        return;
+    }
+    const selectAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedId',
+            message: 'Select resource to update:',
+            choices: resources.map(r => ({
+                name: r.name,
+                value: r.id
+            }))
+        }
+    ]);
+    if (!selectAnswer)
+        return;
+    const selectedResource = resources.find(r => r.id === selectAnswer.selectedId);
+    const updateAnswers = await safePrompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Resource name:',
+            default: selectedResource.name,
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Resource name is required';
+                return true;
+            }
+        },
+        {
+            type: 'editor',
+            name: 'content',
+            message: 'Resource content (will open in your default editor):',
+            default: selectedResource.content,
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Resource content cannot be empty';
+                return true;
+            }
+        }
+    ]);
+    if (!updateAnswers)
+        return;
+    writeProgress("🔄 Updating resource...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/admin/agents/${context.agentId}/resources/${selectAnswer.selectedId}`, {
+            method: 'PUT',
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: updateAnswers.name.trim(),
+                content: updateAnswers.content.trim()
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP error! status: ${response.status} - ${errorText}`);
+        }
+        writeSuccess(`✅ Resource "${updateAnswers.name}" updated successfully`);
+    }
+    catch (error) {
+        console.error('❌ Error updating resource:', error);
+    }
+}
+/**
+ * Delete a resource
+ */
+async function deleteResource(context, resources) {
+    if (resources.length === 0) {
+        console.log("\nℹ️  No resources to delete.\n");
+        return;
+    }
+    const selectAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedId',
+            message: 'Select resource to delete:',
+            choices: resources.map(r => ({
+                name: r.name,
+                value: r.id
+            }))
+        }
+    ]);
+    if (!selectAnswer)
+        return;
+    const selectedResource = resources.find(r => r.id === selectAnswer.selectedId);
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to delete "${selectedResource.name}"?`,
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\nℹ️  Deletion cancelled.\n");
+        return;
+    }
+    writeProgress("🔄 Deleting resource...");
+    try {
+        const response = await fetch(`${BASE_URLS.API}/admin/agents/${context.agentId}/resources/${selectAnswer.selectedId}`, {
+            method: 'DELETE',
+            headers: {
+                'accept': '*/*',
+                'Authorization': `Bearer ${context.apiKey}`
+            }
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`HTTP error! status: ${response.status} - ${errorText}`);
+        }
+        writeSuccess(`✅ Resource "${selectedResource.name}" deleted successfully`);
+    }
+    catch (error) {
+        console.error('❌ Error deleting resource:', error);
+    }
+}
+/**
+ * View a resource's full content
+ */
+async function viewResource(resources) {
+    if (resources.length === 0) {
+        console.log("\nℹ️  No resources to view.\n");
+        return;
+    }
+    const selectAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedId',
+            message: 'Select resource to view:',
+            choices: resources.map(r => ({
+                name: r.name,
+                value: r.id
+            }))
+        }
+    ]);
+    if (!selectAnswer)
+        return;
+    const resource = resources.find(r => r.id === selectAnswer.selectedId);
+    console.log("\n" + "=".repeat(60));
+    console.log(`📄 Resource: ${resource.name}`);
+    console.log("=".repeat(60));
+    if (resource.createdAt) {
+        const date = new Date(resource.createdAt);
+        console.log(`Created: ${date.toLocaleString()}`);
+    }
+    if (resource.updatedAt) {
+        const date = new Date(resource.updatedAt);
+        console.log(`Updated: ${date.toLocaleString()}`);
+    }
+    console.log("=".repeat(60) + "\n");
+    console.log(resource.content);
+    console.log("\n" + "=".repeat(60) + "\n");
+    await safePrompt([
+        {
+            type: 'input',
+            name: 'continue',
+            message: 'Press Enter to continue...'
+        }
+    ]);
+}

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

@@ -29,7 +29,9 @@ export default class DataEntryInstance {
     toJSON() {
         return {
             ...this.data,
-            score: this.score
+            score: this.score,
+            id: this.id,
+            collectionName: this.collectionName
         };
     }
     /**
@@ -39,7 +41,9 @@ export default class DataEntryInstance {
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return {
             ...this.data,
-            score: this.score
+            score: this.score,
+            id: this.id,
+            collectionName: this.collectionName
         };
     }
     /**

package/dist/common/http.client.js

@@ -1,3 +1,4 @@
+import { AuthenticationError } from "../errors/auth.error.js";
 /**
  * Generic HTTP client with common error handling
  * Provides a base class for all API service classes with standardized HTTP methods
@@ -28,6 +29,9 @@ export class HttpClient {
             });
             // Check if response is ok (status 200-299)
             if (!response.ok) {
+                if (response.status === 401) {
+                    throw new AuthenticationError("Invalid API key");
+                }
                 return {
                     success: false,
                     error: {
@@ -55,6 +59,9 @@ export class HttpClient {
             };
         }
         catch (error) {
+            if (AuthenticationError.isAuthenticationError(error)) {
+                throw error;
+            }
             // Handle network errors, timeouts, etc.
             return {
                 success: false,

package/dist/config/compile.constants.d.ts

@@ -33,10 +33,11 @@ export declare const SKILL_DEFAULTS: {
 };
 /**
  * External packages that should not be bundled with tools
- * These are either lua-cli modules, native modules, or modules
- * that should be provided by the runtime environment
+ * These are native modules, or modules that should be provided by the runtime environment
+ * Note: lua-cli is NOT in this list because it's handled by the sandboxGlobalsPlugin
+ * which transforms imports to use sandbox globals instead
  */
-export declare const EXTERNAL_PACKAGES: readonly ["lua-cli/skill", "lua-cli", "lua-cli/user-data-api", "lua-cli/product-api", "lua-cli/custom-data-api", "zod", "keytar", "esbuild", "commander", "inquirer", "node-fetch", "ws", "socket.io-client", "ts-morph"];
+export declare const EXTERNAL_PACKAGES: readonly ["zod", "keytar", "esbuild", "commander", "inquirer", "node-fetch", "ws", "socket.io-client", "ts-morph"];
 /**
  * Common esbuild configuration for tool bundling
  */

package/dist/config/compile.constants.js

@@ -32,15 +32,11 @@ export const SKILL_DEFAULTS = {
 };
 /**
  * External packages that should not be bundled with tools
- * These are either lua-cli modules, native modules, or modules
- * that should be provided by the runtime environment
+ * These are native modules, or modules that should be provided by the runtime environment
+ * Note: lua-cli is NOT in this list because it's handled by the sandboxGlobalsPlugin
+ * which transforms imports to use sandbox globals instead
  */
 export const EXTERNAL_PACKAGES = [
-    'lua-cli/skill',
-    'lua-cli',
-    'lua-cli/user-data-api',
-    'lua-cli/product-api',
-    'lua-cli/custom-data-api',
     'zod',
     'keytar',
     'esbuild',

package/dist/config/constants.d.ts

@@ -1,5 +1,11 @@
+/**
+ * Base URLs for the API, Auth, and Chat - Production
+ */
 export declare const BASE_URLS: {
     readonly API: "https://api.heylua.ai";
     readonly AUTH: "https://auth.heylua.ai";
     readonly CHAT: "https://api.heylua.ai";
 };
+/**
+ * Base URLs for the API, Auth, and Chat - Development
+ */

package/dist/config/constants.js

@@ -1,5 +1,16 @@
+/**
+ * Base URLs for the API, Auth, and Chat - Production
+ */
 export const BASE_URLS = {
     API: 'https://api.heylua.ai',
     AUTH: 'https://auth.heylua.ai',
     CHAT: 'https://api.heylua.ai',
 };
+/**
+ * Base URLs for the API, Auth, and Chat - Development
+ */
+// export const BASE_URLS = {
+//   API: 'http://localhost:3022',
+//   AUTH: 'https://auth.heylua.ai',
+//   CHAT: 'http://localhost:3001',
+// } as const;

package/dist/errors/auth.error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Authentication Error
+ * Thrown when API requests fail with 401 Unauthorized status
+ */
+export declare class AuthenticationError extends Error {
+    readonly statusCode: number;
+    readonly isAuthenticationError: boolean;
+    constructor(message?: string);
+    /**
+     * Checks if an error is an AuthenticationError
+     * @param error - The error to check
+     * @returns True if the error is an AuthenticationError
+     */
+    static isAuthenticationError(error: unknown): error is AuthenticationError;
+}