lua-cli 2.5.1 → 2.5.3

package/dist/commands/docs.js

@@ -0,0 +1,30 @@
+/**
+ * Docs Command
+ * Opens the Lua documentation website in the user's default browser
+ */
+import open from 'open';
+import { withErrorHandling, writeSuccess, writeProgress } from '../utils/cli.js';
+/**
+ * Docs command - opens the Lua documentation in the browser.
+ *
+ * This command opens https://docs.heylua.ai in the user's default browser,
+ * providing quick access to:
+ * - Platform overview and concepts
+ * - CLI command reference
+ * - API documentation
+ * - Tool examples and guides
+ * - Integration tutorials
+ * - Best practices
+ *
+ * @returns Promise that resolves when browser is launched
+ */
+export async function docsCommand() {
+    return withErrorHandling(async () => {
+        writeProgress('Opening Lua Documentation...');
+        // Open the documentation website
+        const docsUrl = 'https://docs.heylua.ai';
+        await open(docsUrl);
+        writeSuccess('Lua Documentation opened in your browser');
+        console.log(`\n  Documentation: ${docsUrl}\n`);
+    }, 'docs');
+}

package/dist/commands/index.d.ts

@@ -13,3 +13,7 @@ export { envCommand } from "./env.js";
 export { personaCommand } from "./persona.js";
 export { productionCommand } from "./production.js";
 export { resourcesCommand } from "./resources.js";
+export { adminCommand } from "./admin.js";
+export { docsCommand } from "./docs.js";
+export { channelsCommand } from "./channels.js";
+export { logsCommand } from "./logs.js";

package/dist/commands/index.js

@@ -13,3 +13,7 @@ export { envCommand } from "./env.js";
 export { personaCommand } from "./persona.js";
 export { productionCommand } from "./production.js";
 export { resourcesCommand } from "./resources.js";
+export { adminCommand } from "./admin.js";
+export { docsCommand } from "./docs.js";
+export { channelsCommand } from "./channels.js";
+export { logsCommand } from "./logs.js";

package/dist/commands/logs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Logs Command
+ * View and navigate agent/skill logs with pagination
+ */
+/**
+ * Main logs command - displays agent/skill logs with navigation
+ *
+ * Features:
+ * - View all agent logs or filter by specific skill
+ * - Interactive pagination
+ * - Color-coded log types
+ * - Real-time navigation
+ *
+ * @returns Promise that resolves when the command completes
+ * @throws Error if API key or configuration is not found
+ */
+export declare function logsCommand(): Promise<void>;

package/dist/commands/logs.js

@@ -0,0 +1,271 @@
+/**
+ * Logs Command
+ * View and navigate agent/skill logs with pagination
+ */
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { loadApiKey } from "../services/auth.js";
+import { readSkillConfig } from "../utils/files.js";
+import { withErrorHandling, writeSuccess, writeInfo, writeError, clearPromptLines } from "../utils/cli.js";
+import LogsApi from '../api/logs.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+/**
+ * Main logs command - displays agent/skill logs with navigation
+ *
+ * Features:
+ * - View all agent logs or filter by specific skill
+ * - Interactive pagination
+ * - Color-coded log types
+ * - Real-time navigation
+ *
+ * @returns Promise that resolves when the command completes
+ * @throws Error if API key or configuration is not found
+ */
+export async function logsCommand() {
+    return withErrorHandling(async () => {
+        // Load API key
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Run `lua auth configure` first.");
+            process.exit(1);
+        }
+        // Load agent ID from configuration
+        const config = readSkillConfig();
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            throw new Error("No agent ID found in lua.skill.yaml. Please ensure you are in a Lua skill directory, or run 'lua init' to create a new skill.");
+        }
+        writeInfo(`📊 Viewing logs for agent: ${agentId}\n`);
+        const logsApi = new LogsApi(BASE_URLS.API, apiKey);
+        // Ask if user wants all logs or specific skill
+        const { viewType } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "viewType",
+                message: "What logs do you want to view?",
+                choices: [
+                    { name: "📋 All agent logs", value: "all" },
+                    { name: "🎯 Specific skill logs", value: "skill" }
+                ]
+            }
+        ]);
+        clearPromptLines(2);
+        if (viewType === "all") {
+            await viewAgentLogs(logsApi, agentId);
+        }
+        else {
+            await viewSkillLogs(logsApi, agentId, config);
+        }
+    }, "logs viewing");
+}
+/**
+ * View all logs for an agent with pagination
+ */
+async function viewAgentLogs(logsApi, agentId) {
+    let currentPage = 1;
+    const limit = 20;
+    let keepViewing = true;
+    while (keepViewing) {
+        const response = await logsApi.getAgentLogs(agentId, limit, currentPage);
+        if (!response.success) {
+            writeError(`❌ Error: ${response.error?.message || 'Unknown error'}`);
+            process.exit(1);
+        }
+        const data = response.data;
+        displayLogs(data.logs, data.pagination, "All Agent Logs");
+        // Navigation menu
+        const { action } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "action",
+                message: "Navigation:",
+                choices: getNavigationChoices(data.pagination)
+            }
+        ]);
+        clearPromptLines(2);
+        keepViewing = await handleNavigation(action, data.pagination, (page) => {
+            currentPage = page;
+        });
+    }
+}
+/**
+ * View logs for a specific skill with pagination
+ */
+async function viewSkillLogs(logsApi, agentId, config) {
+    // Get skills from config
+    const skills = config?.skills || [];
+    if (skills.length === 0) {
+        writeError("❌ No skills found in lua.skill.yaml");
+        writeInfo("💡 Run 'lua push' to deploy skills first.\n");
+        return;
+    }
+    // Let user select a skill
+    const skillChoices = skills.map((skill) => ({
+        name: `${skill.name} (${skill.skillId || 'No ID'})`,
+        value: skill.skillId
+    }));
+    skillChoices.push({
+        name: '← Back to main menu',
+        value: null
+    });
+    const { skillId } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "skillId",
+            message: "Select a skill:",
+            choices: skillChoices
+        }
+    ]);
+    if (!skillId) {
+        return;
+    }
+    clearPromptLines(2);
+    let currentPage = 1;
+    const limit = 20;
+    let keepViewing = true;
+    const selectedSkill = skills.find((s) => s.skillId === skillId);
+    const skillName = selectedSkill?.name || skillId;
+    while (keepViewing) {
+        const response = await logsApi.getSkillLogs(agentId, skillId, limit, currentPage);
+        if (!response.success) {
+            writeError(`❌ Error: ${response.error?.message || 'Unknown error'}`);
+            process.exit(1);
+        }
+        const data = response.data;
+        displayLogs(data.logs, data.pagination, `Logs for ${skillName}`);
+        // Navigation menu
+        const { action } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "action",
+                message: "Navigation:",
+                choices: getNavigationChoices(data.pagination)
+            }
+        ]);
+        clearPromptLines(2);
+        keepViewing = await handleNavigation(action, data.pagination, (page) => {
+            currentPage = page;
+        });
+    }
+}
+/**
+ * Display logs with color coding
+ */
+function displayLogs(logs, pagination, title) {
+    console.clear();
+    writeSuccess(`\n${title}\n`);
+    writeInfo(`${'─'.repeat(80)}`);
+    writeInfo(`Page ${pagination.currentPage} of ${pagination.totalPages} (${pagination.totalCount} total logs)\n`);
+    if (logs.length === 0) {
+        writeInfo("No logs found.");
+        return;
+    }
+    logs.forEach((log, index) => {
+        const timestamp = new Date(log.timestamp).toLocaleString();
+        const icon = getLogIcon(log.subType);
+        const color = getLogColor(log.subType);
+        console.log(color(`${icon} [${timestamp}] ${log.subType.toUpperCase()}`));
+        if (log.metadata.skillName) {
+            console.log(chalk.gray(`   Skill: ${log.metadata.skillName}`));
+        }
+        if (log.metadata.toolId) {
+            console.log(chalk.gray(`   Tool: ${log.metadata.toolId}`));
+        }
+        if (log.duration !== undefined) {
+            console.log(chalk.gray(`   Duration: ${log.duration}ms`));
+        }
+        // Display message (truncate if too long)
+        const message = log.message.length > 200
+            ? log.message.substring(0, 200) + '...'
+            : log.message;
+        console.log(`   ${message}`);
+        if (index < logs.length - 1) {
+            console.log(chalk.gray(`   ${'-'.repeat(78)}`));
+        }
+    });
+    writeInfo(`\n${'─'.repeat(80)}\n`);
+}
+/**
+ * Get navigation choices based on pagination state
+ */
+function getNavigationChoices(pagination) {
+    const choices = [];
+    if (pagination.hasPrevPage) {
+        choices.push({ name: '← Previous Page', value: 'prev' });
+    }
+    if (pagination.hasNextPage) {
+        choices.push({ name: 'Next Page →', value: 'next' });
+    }
+    if (pagination.totalPages > 1) {
+        choices.push({ name: '🔢 Go to specific page', value: 'goto' });
+    }
+    choices.push({ name: '🔄 Refresh', value: 'refresh' });
+    choices.push({ name: '❌ Exit', value: 'exit' });
+    return choices;
+}
+/**
+ * Handle navigation actions
+ */
+async function handleNavigation(action, pagination, setPage) {
+    switch (action) {
+        case 'prev':
+            if (pagination.hasPrevPage) {
+                setPage(pagination.prevPage);
+            }
+            return true;
+        case 'next':
+            if (pagination.hasNextPage) {
+                setPage(pagination.nextPage);
+            }
+            return true;
+        case 'goto':
+            const { page } = await inquirer.prompt({
+                type: "number",
+                name: "page",
+                message: `Enter page number (1-${pagination.totalPages}):`,
+                validate: (input) => {
+                    if (input === undefined || input < 1 || input > pagination.totalPages) {
+                        return `Please enter a number between 1 and ${pagination.totalPages}`;
+                    }
+                    return true;
+                }
+            });
+            setPage(page);
+            return true;
+        case 'refresh':
+            return true;
+        case 'exit':
+            writeInfo("👋 Exiting logs viewer\n");
+            return false;
+        default:
+            return false;
+    }
+}
+/**
+ * Get icon for log type
+ */
+function getLogIcon(subType) {
+    const icons = {
+        'error': '❌',
+        'warn': '⚠️',
+        'debug': '🔍',
+        'info': 'ℹ️',
+        'start': '▶️',
+        'complete': '✅'
+    };
+    return icons[subType] || '📝';
+}
+/**
+ * Get color function for log type
+ */
+function getLogColor(subType) {
+    const colors = {
+        'error': chalk.red,
+        'warn': chalk.yellow,
+        'debug': chalk.blue,
+        'info': chalk.cyan,
+        'start': chalk.green,
+        'complete': chalk.green
+    };
+    return colors[subType] || chalk.white;
+}

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

@@ -4,6 +4,7 @@ import OrderInstance from "./order.instance.js";
 /**
  * Basket instance class providing a fluent API for managing user baskets
  * Provides methods for adding/removing items, updating metadata, and placing orders
+ * Supports direct property access (e.g., basket.items) for accessing data and common properties
  */
 export default class BasketInstance {
     private id;
@@ -16,10 +17,12 @@ export default class BasketInstance {
     itemCount: number;
     status: BasketStatus;
     private basketAPI;
+    [key: string]: any;
     /**
-     * Creates a new BasketInstance
+     * Creates a new BasketInstance with proxy support for direct property access
      * @param api - The BasketAPI instance for making API calls
      * @param basket - The basket data from the API
+     * @returns Proxied instance that allows direct access to data and common properties
      */
     constructor(api: BasketAPI, basket: Basket);
     /**

package/dist/common/basket.instance.js

@@ -2,12 +2,14 @@ import { BasketStatus } from "../interfaces/baskets.js";
 /**
  * Basket instance class providing a fluent API for managing user baskets
  * Provides methods for adding/removing items, updating metadata, and placing orders
+ * Supports direct property access (e.g., basket.items) for accessing data and common properties
  */
 export default class BasketInstance {
     /**
-     * Creates a new BasketInstance
+     * Creates a new BasketInstance with proxy support for direct property access
      * @param api - The BasketAPI instance for making API calls
      * @param basket - The basket data from the API
+     * @returns Proxied instance that allows direct access to data and common properties
      */
     constructor(api, basket) {
         this.data = basket.data;
@@ -26,6 +28,79 @@ export default class BasketInstance {
             enumerable: false,
             configurable: true
         });
+        // Return a proxy that allows direct property access
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                // If the property exists on the instance itself, return it
+                if (prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                // Check data object
+                if (typeof prop === 'string' && prop in target.data) {
+                    return target.data[prop];
+                }
+                // Check common object
+                if (typeof prop === 'string' && prop in target.common) {
+                    return target.common[prop];
+                }
+                return undefined;
+            },
+            set(target, prop, value, receiver) {
+                // Reserved properties that should be set on the instance itself
+                const reservedProps = ['id', 'userId', 'agentId', 'data', 'common', 'metadata', 'totalAmount', 'itemCount', 'status', 'basketAPI', 'updateMetadata', 'updateStatus', 'addItem', 'removeItem', 'clear', 'placeOrder', 'toJSON'];
+                if (typeof prop === 'string' && reservedProps.includes(prop)) {
+                    return Reflect.set(target, prop, value, receiver);
+                }
+                // Check if property exists in data or common, otherwise default to data
+                if (typeof prop === 'string') {
+                    if (prop in target.common) {
+                        target.common[prop] = value;
+                    }
+                    else {
+                        target.data[prop] = value;
+                    }
+                    return true;
+                }
+                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));
+            },
+            ownKeys(target) {
+                // Return instance keys, data keys, and common keys
+                const instanceKeys = Reflect.ownKeys(target);
+                const dataKeys = Object.keys(target.data);
+                const commonKeys = Object.keys(target.common);
+                return [...new Set([...instanceKeys, ...dataKeys, ...commonKeys])];
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                // First check if it's an instance property
+                const instanceDesc = Reflect.getOwnPropertyDescriptor(target, prop);
+                if (instanceDesc) {
+                    return instanceDesc;
+                }
+                // Then check data properties
+                if (typeof prop === 'string' && prop in target.data) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: target.data[prop]
+                    };
+                }
+                // Then check common properties
+                if (typeof prop === 'string' && prop in target.common) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: target.common[prop]
+                    };
+                }
+                return undefined;
+            }
+        });
     }
     /**
      * Custom toJSON method to control what gets serialized when logging

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

@@ -3,6 +3,7 @@ import { CreateCustomDataResponse } from "../interfaces/custom.data.js";
 /**
  * Data entry instance class providing a fluent API for managing custom data entries
  * Provides methods for updating and deleting individual data entries
+ * Supports direct property access (e.g., entry.fieldName) for accessing data properties
  */
 export default class DataEntryInstance {
     data: Record<string, any>;
@@ -10,11 +11,13 @@ export default class DataEntryInstance {
     collectionName: string;
     score?: number;
     private customDataAPI;
+    [key: string]: any;
     /**
-     * Creates a new DataEntryInstance
+     * Creates a new DataEntryInstance with proxy support for direct property access
      * @param api - The CustomDataAPI instance for making API calls
      * @param entry - The custom data entry response from the API
      * @param collectionName - The name of the collection this entry belongs to
+     * @returns Proxied instance that allows direct access to data properties
      */
     constructor(api: CustomDataAPI, entry: CreateCustomDataResponse, collectionName: string);
     /**

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

@@ -1,13 +1,15 @@
 /**
  * Data entry instance class providing a fluent API for managing custom data entries
  * Provides methods for updating and deleting individual data entries
+ * Supports direct property access (e.g., entry.fieldName) for accessing data properties
  */
 export default class DataEntryInstance {
     /**
-     * Creates a new DataEntryInstance
+     * Creates a new DataEntryInstance with proxy support for direct property access
      * @param api - The CustomDataAPI instance for making API calls
      * @param entry - The custom data entry response from the API
      * @param collectionName - The name of the collection this entry belongs to
+     * @returns Proxied instance that allows direct access to data properties
      */
     constructor(api, entry, collectionName) {
         this.data = entry.data;
@@ -21,6 +23,60 @@ export default class DataEntryInstance {
             enumerable: false,
             configurable: true
         });
+        // Return a proxy that allows direct property access
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                // If the property exists on the instance itself, return it
+                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) {
+                    return target.data[prop];
+                }
+                return undefined;
+            },
+            set(target, prop, value, receiver) {
+                // Reserved properties that should be set on the instance itself
+                const reservedProps = ['data', 'id', 'collectionName', 'score', 'customDataAPI', 'update', 'delete', 'toJSON'];
+                if (typeof prop === 'string' && reservedProps.includes(prop)) {
+                    return Reflect.set(target, prop, value, receiver);
+                }
+                // All other properties get set on the data object
+                if (typeof prop === 'string') {
+                    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);
+            },
+            ownKeys(target) {
+                // Return both instance keys and data keys
+                const instanceKeys = Reflect.ownKeys(target);
+                const dataKeys = Object.keys(target.data);
+                return [...new Set([...instanceKeys, ...dataKeys])];
+            },
+            getOwnPropertyDescriptor(target, prop) {
+                // First check if it's an instance property
+                const instanceDesc = Reflect.getOwnPropertyDescriptor(target, prop);
+                if (instanceDesc) {
+                    return instanceDesc;
+                }
+                // Then check if it's a data property
+                if (typeof prop === 'string' && prop in target.data) {
+                    return {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: target.data[prop]
+                    };
+                }
+                return undefined;
+            }
+        });
     }
     /**
      * Custom toJSON method to control what gets serialized when logging

package/dist/common/http.client.js

@@ -32,11 +32,21 @@ export class HttpClient {
                 if (response.status === 401) {
                     throw new AuthenticationError("Invalid API key");
                 }
+                // Try to parse error body as JSON
+                let errorData;
+                try {
+                    errorData = await response.json();
+                }
+                catch (jsonError) {
+                    errorData = {};
+                }
                 return {
                     success: false,
                     error: {
-                        message: `HTTP ${response.status}: ${response.statusText}`,
+                        message: errorData.message || `HTTP ${response.status}: ${response.statusText}`,
                         statusCode: response.status,
+                        error: errorData.error,
+                        ...errorData
                     },
                 };
             }

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

@@ -3,6 +3,7 @@ import { OrderResponse, OrderStatus } from "../interfaces/orders.js";
 /**
  * Order instance class providing a fluent API for managing orders
  * Provides methods for updating order status and order data
+ * Supports direct property access (e.g., order.shippingAddress) for accessing data and common properties
  */
 export default class OrderInstance {
     private data;
@@ -12,10 +13,12 @@ export default class OrderInstance {
     private agentId;
     private orderId;
     private orderAPI;
+    [key: string]: any;
     /**
-     * Creates a new OrderInstance
+     * Creates a new OrderInstance with proxy support for direct property access
      * @param api - The OrderApi instance for making API calls
      * @param order - The order response data from the API
+     * @returns Proxied instance that allows direct access to data and common properties
      */
     constructor(api: OrderApi, order: OrderResponse);
     /**