lua-cli 2.5.2 → 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/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/user.instance.d.ts

@@ -1,8 +1,7 @@
-import { UserData } from "../interfaces/admin.js";
 import { UserDataAPI } from "../types/index.js";
 /**
  * User data instance class providing a fluent API for managing user data
- * Automatically sanitizes sensitive fields and provides methods for updating and clearing data
+ * Provides methods for updating and clearing data
  * Supports direct property access (e.g., user.name) instead of user.data.name
  */
 export default class UserDataInstance {
@@ -12,17 +11,10 @@ export default class UserDataInstance {
     /**
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
-     * @param data - The user data from the API (will be sanitized automatically)
+     * @param data - The user data from the API
      * @returns Proxied instance that allows direct access to data properties
      */
-    constructor(api: UserDataAPI, data: UserData);
-    /**
-     * Removes sensitive fields from the data before storing
-     * @param data - The raw user data to sanitize
-     * @returns Sanitized data with sensitive fields removed
-     * @private
-     */
-    private sanitizeData;
+    constructor(api: UserDataAPI, data: any);
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized user data
@@ -31,7 +23,7 @@ export default class UserDataInstance {
     /**
      * Updates the user's data
      * @param data - The data fields to update or add to user data
-     * @returns Promise resolving to the updated sanitized user data
+     * @returns Promise resolving to the updated user data
      * @throws Error if the update fails
      */
     update(data: Record<string, any>): Promise<any>;

package/dist/common/user.instance.js

@@ -1,17 +1,17 @@
 /**
  * User data instance class providing a fluent API for managing user data
- * Automatically sanitizes sensitive fields and provides methods for updating and clearing data
+ * Provides methods for updating and clearing data
  * Supports direct property access (e.g., user.name) instead of user.data.name
  */
 export default class UserDataInstance {
     /**
      * Creates a new UserDataInstance with proxy support for direct property access
      * @param api - The UserDataAPI instance for making API calls
-     * @param data - The user data from the API (will be sanitized automatically)
+     * @param data - The user data from the API
      * @returns Proxied instance that allows direct access to data properties
      */
     constructor(api, data) {
-        this.data = this.sanitizeData(data);
+        this.data = data;
         // Make userAPI non-enumerable so it doesn't show up in console.log
         Object.defineProperty(this, 'userAPI', {
             value: api,
@@ -74,25 +74,6 @@ export default class UserDataInstance {
             }
         });
     }
-    /**
-     * Removes sensitive fields from the data before storing
-     * @param data - The raw user data to sanitize
-     * @returns Sanitized data with sensitive fields removed
-     * @private
-     */
-    sanitizeData(data) {
-        if (!data || typeof data !== 'object') {
-            return data;
-        }
-        // Create a copy of the data to avoid mutating the original
-        const sanitized = { ...data };
-        // Remove sensitive fields
-        const sensitiveFields = ['agentId', 'userId'];
-        sensitiveFields.forEach(field => {
-            delete sanitized[field];
-        });
-        return sanitized;
-    }
     /**
      * Custom toJSON method to control what gets serialized when logging
      * @returns Serialized user data
@@ -110,13 +91,13 @@ export default class UserDataInstance {
     /**
      * Updates the user's data
      * @param data - The data fields to update or add to user data
-     * @returns Promise resolving to the updated sanitized user data
+     * @returns Promise resolving to the updated user data
      * @throws Error if the update fails
      */
     async update(data) {
         try {
             const response = await this.userAPI.update(data);
-            this.data = this.sanitizeData(response.data);
+            this.data = response.data;
             return this.data;
         }
         catch (error) {

package/dist/index.js

@@ -30,6 +30,7 @@ Categories:
   ☁️  Deployment       Push and deploy to production
   💬 Testing          Chat and test your agent
   ⚙️  Configuration    Manage environment and persona
+  📖 Utilities        Quick access to admin and docs
 
 Examples:
   $ lua auth configure      🔑 Set up your API key
@@ -41,6 +42,8 @@ Examples:
   $ lua chat               💬 Start interactive chat
   $ lua env                ⚙️  Manage environment variables
   $ lua persona            🤖 Manage agent persona
+  $ lua admin              🔧 Open admin dashboard
+  $ lua docs               📖 Open documentation
 
 🌙 Documentation: https://docs.heylua.ai
 🌙 Support: https://heylua.ai/support

package/dist/interfaces/agent.d.ts

@@ -89,3 +89,221 @@ export interface AgentDetailsResponse {
     };
     skills: any[];
 }
+/**
+ * Agent channel configuration.
+ * Represents a communication channel connected to an agent.
+ */
+export interface AgentChannel {
+    type: string;
+    identifier: string;
+    createdAt: number;
+    whatsapp?: string;
+    facebook?: string;
+    instagram?: string;
+    data: Record<string, any>;
+}
+/**
+ * Channel link configuration for connecting new channels.
+ */
+export interface ChannelLink {
+    type: string;
+    method: string;
+    link: string;
+    data: string[];
+}
+/**
+ * Response from get agent channels API.
+ */
+export interface AgentChannelsResponse {
+    channels: AgentChannel[];
+    links: ChannelLink[];
+    status: string;
+    message: string;
+}
+/**
+ * Request payload for creating a WhatsApp channel.
+ */
+export interface CreateWhatsAppChannelRequest {
+    type: "whatsapp";
+    whatsapp: {
+        phoneNumberId: string;
+        wabaId: string;
+        accessToken: string;
+    };
+    isManual: boolean;
+}
+/**
+ * Response from creating a WhatsApp channel.
+ */
+export interface CreateWhatsAppChannelResponse {
+    type: string;
+    identifier: string;
+    agentId: string;
+    userId: string;
+    whatsapp: {
+        number: string;
+        global: boolean;
+        phoneId: string;
+        accessToken: string;
+        metadata: {
+            id: string;
+            display_phone_number: string;
+            verified_name: string;
+            quality_rating: string;
+            status: string;
+            code_verification_status: string;
+            search_visibility: string;
+            platform_type: string;
+        };
+    };
+    webhookUrl: string;
+}
+/**
+ * Request payload for creating a Facebook Messenger channel.
+ */
+export interface CreateFacebookChannelRequest {
+    type: "facebook";
+    facebook: {
+        accessToken: string;
+        pageId: string;
+    };
+}
+/**
+ * Response from creating a Facebook Messenger channel.
+ */
+export interface CreateFacebookChannelResponse {
+    type: string;
+    identifier: string;
+    agentId: string;
+    userId: string;
+    facebook: {
+        pageId: string;
+        id: string;
+        name: string;
+        category: string;
+    };
+    webhookUrl: string;
+}
+/**
+ * Request payload for creating a private Slack channel.
+ */
+export interface CreateSlackPrivateChannelRequest {
+    type: "slack";
+    slack: {
+        type: "private";
+        accessToken: string;
+    };
+}
+/**
+ * Request payload for creating a public Slack channel.
+ */
+export interface CreateSlackPublicChannelRequest {
+    type: "slack";
+    slack: {
+        type: "public";
+        appId: string;
+        clientId: string;
+        clientSecret: string;
+    };
+}
+/**
+ * Union type for creating any Slack channel (private or public).
+ */
+export type CreateSlackChannelRequest = CreateSlackPrivateChannelRequest | CreateSlackPublicChannelRequest;
+/**
+ * Slack app manifest configuration (shared between private and public channels).
+ */
+export interface SlackManifest {
+    display_information: {
+        name: string;
+        description: string;
+        background_color: string;
+        long_description: string;
+    };
+    features: {
+        app_home: {
+            home_tab_enabled: boolean;
+            messages_tab_enabled: boolean;
+            messages_tab_read_only_enabled: boolean;
+        };
+        bot_user: {
+            display_name: string;
+            always_online: boolean;
+        };
+    };
+    oauth_config: {
+        redirect_urls: string[];
+        scopes: {
+            bot: string[];
+        };
+    };
+    settings: {
+        event_subscriptions: {
+            request_url: string;
+            bot_events: string[];
+        };
+        interactivity: {
+            is_enabled: boolean;
+            request_url: string;
+        };
+        org_deploy_enabled: boolean;
+        socket_mode_enabled: boolean;
+        token_rotation_enabled: boolean;
+    };
+}
+/**
+ * Response from creating a private Slack channel.
+ */
+export interface CreateSlackPrivateChannelResponse {
+    type: string;
+    agentId: string;
+    userId: string;
+    slack: {
+        type: string;
+        appId: string;
+        teamId: string;
+        accessToken: string;
+        replyTo: string[];
+        botId: string;
+        url: string;
+        botUserId: string;
+        botName: string;
+        botIcon: string;
+        manifest: SlackManifest;
+    };
+    webhookUrl: string;
+}
+/**
+ * Response from creating a public Slack channel.
+ */
+export interface CreateSlackPublicChannelResponse {
+    appId: string;
+    clientId: string;
+    clientSecret: string;
+    agentId: string;
+    userId: string;
+    redirectUri: string;
+    manifest: SlackManifest;
+    webhookUrl: string;
+}
+/**
+ * Union type for Slack channel creation responses (private or public).
+ */
+export type CreateSlackChannelResponse = CreateSlackPrivateChannelResponse | CreateSlackPublicChannelResponse;
+/**
+ * Request payload for creating an Email channel.
+ */
+export interface CreateEmailChannelRequest {
+    type: "email";
+    email: {
+        name: string;
+        email: string;
+    };
+}
+/**
+ * Response from creating an Email channel.
+ */
+export interface CreateEmailChannelResponse {
+    forwardTo: string;
+    status: string;
+}