lua-cli 2.5.1 → 2.5.3

package/dist/commands/channels.js

@@ -0,0 +1,676 @@
+/**
+ * Channels Command
+ * Manages agent communication channels (list, create)
+ */
+import inquirer from "inquirer";
+import open from 'open';
+import { loadApiKey } from "../services/auth.js";
+import { readSkillConfig } from "../utils/files.js";
+import { withErrorHandling, writeSuccess, writeInfo, clearPromptLines, writeProgress } from "../utils/cli.js";
+import AgentApi from '../api/agent.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+/**
+ * Main channels command - manages agent communication channels.
+ *
+ * This command provides:
+ * 1. List all channels for an agent
+ * 2. Create new channels (WhatsApp, Facebook, Slack)
+ *
+ * The agent ID is automatically loaded from lua.skill.yaml
+ *
+ * @returns Promise that resolves when the operation is complete
+ * @throws Error if API key is not found or API call fails
+ */
+export async function channelsCommand() {
+    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.");
+        }
+        writeProgress(`✅ Using agent: ${agentId}`);
+        const agentApi = new AgentApi(BASE_URLS.API, apiKey);
+        // Step 1: Ask what operation they want to perform
+        const { operation } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "operation",
+                message: "What would you like to do?",
+                choices: [
+                    { name: "📋 List channels", value: "list" },
+                    { name: "🔗 Link new channel", value: "create" },
+                    { name: "🌐 Link on admin dashboard", value: "admin" }
+                ]
+            }
+        ]);
+        clearPromptLines(2);
+        if (operation === "list") {
+            await listChannels(agentApi, agentId, config);
+        }
+        else if (operation === "create") {
+            await createChannel(agentApi, agentId);
+        }
+        else if (operation === "admin") {
+            await openAdminDashboard(apiKey, config);
+        }
+    }, "channels management");
+}
+/**
+ * Opens the admin dashboard for channel management
+ */
+async function openAdminDashboard(apiKey, config) {
+    writeProgress('🌐 Opening Lua Admin Dashboard...');
+    // Extract agentId and orgId from config
+    const agentId = config?.agent?.agentId;
+    const orgId = config?.agent?.orgId;
+    if (!agentId) {
+        throw new Error('No agentId found in lua.skill.yaml. Please ensure your configuration is valid.');
+    }
+    if (!orgId) {
+        throw new Error('No orgId found in lua.skill.yaml. Please ensure your configuration is valid.');
+    }
+    // Construct the admin dashboard URL
+    const adminUrl = `https://admin.heylua.ai/validate-token/${apiKey}?redirect=/admin/usage?&agentId=${agentId}&orgId=${orgId}&hideToolBar=true`;
+    // Open the URL in the default browser
+    await open(adminUrl);
+    writeSuccess('✅ Lua Admin Dashboard opened in your browser');
+    console.log(`\n  Dashboard URL: https://admin.heylua.ai`);
+    console.log(`  Agent ID: ${agentId}`);
+    console.log(`  Organization ID: ${orgId}\n`);
+}
+/**
+ * Lists all channels for a specific agent
+ */
+async function listChannels(agentApi, agentId, config) {
+    writeInfo(`📡 Fetching channels for agent: ${agentId}...`);
+    const response = await agentApi.getAgentChannels(agentId);
+    if (!response.success) {
+        console.error(`❌ Error: ${response.error?.message || 'Unknown error'}`);
+        process.exit(1);
+    }
+    const data = response.data;
+    writeSuccess(`✅ Found ${data.channels.length} channel(s)\n`);
+    if (data.channels.length === 0) {
+        writeInfo("No channels configured for this agent.");
+        writeInfo("\n💡 Use the 'Create new channel' option to add channels.\n");
+        return;
+    }
+    // Create channel choices with icons and labels
+    const channelChoices = data.channels.map((channel, index) => {
+        const icon = getChannelIcon(channel.type);
+        const label = getChannelLabel(channel);
+        return {
+            name: `${icon} ${channel.type.toUpperCase()} - ${label}`,
+            value: index
+        };
+    });
+    channelChoices.push({
+        name: '← Back to main menu',
+        value: -1
+    });
+    const { selectedIndex } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "selectedIndex",
+            message: "Select a channel to view details:",
+            choices: channelChoices
+        }
+    ]);
+    if (selectedIndex === -1) {
+        return;
+    }
+    clearPromptLines(2);
+    // Display selected channel details
+    const selectedChannel = data.channels[selectedIndex];
+    displayChannelDetails(selectedChannel);
+}
+/**
+ * Gets the emoji icon for a channel type
+ */
+function getChannelIcon(type) {
+    const icons = {
+        'whatsapp': '📱',
+        'facebook': '💬',
+        'instagram': '📸',
+        'slack': '💼',
+        'email': '📧',
+        'webchat': '💻'
+    };
+    return icons[type] || '📡';
+}
+/**
+ * Gets a human-readable label for a channel
+ */
+function getChannelLabel(channel) {
+    switch (channel.type) {
+        case 'whatsapp':
+            return channel.whatsapp || channel.identifier;
+        case 'facebook':
+            return channel.facebook || channel.identifier;
+        case 'instagram':
+            return channel.instagram || channel.identifier;
+        case 'slack':
+            return channel.data?.botName || channel.data?.url || channel.identifier;
+        case 'email':
+            return channel.identifier;
+        default:
+            return channel.identifier;
+    }
+}
+/**
+ * Displays detailed information about a channel
+ */
+function displayChannelDetails(channel) {
+    const icon = getChannelIcon(channel.type);
+    writeSuccess(`\n${icon} ${channel.type.toUpperCase()} Channel Details\n`);
+    writeInfo(`${'─'.repeat(50)}`);
+    writeInfo(`Type:           ${channel.type}`);
+    writeInfo(`Identifier:     ${channel.identifier}`);
+    writeInfo(`Created:        ${new Date(channel.createdAt).toLocaleString()}`);
+    // Type-specific details
+    switch (channel.type) {
+        case 'whatsapp':
+            displayWhatsAppDetails(channel);
+            break;
+        case 'facebook':
+            displayFacebookDetails(channel);
+            break;
+        case 'instagram':
+            displayInstagramDetails(channel);
+            break;
+        case 'slack':
+            displaySlackDetails(channel);
+            break;
+        case 'email':
+            displayEmailDetails(channel);
+            break;
+        default:
+            writeInfo(`\nRaw data:`);
+            console.log(JSON.stringify(channel, null, 2));
+    }
+    writeInfo(`${'─'.repeat(50)}\n`);
+}
+/**
+ * Displays WhatsApp-specific details
+ */
+function displayWhatsAppDetails(channel) {
+    if (channel.whatsapp) {
+        writeInfo(`Phone Number:   ${channel.whatsapp}`);
+    }
+    if (channel.data) {
+        if (channel.data.number) {
+            writeInfo(`Number:         ${channel.data.number}`);
+        }
+        if (channel.data.phoneId) {
+            writeInfo(`Phone ID:       ${channel.data.phoneId}`);
+        }
+        if (channel.data.global !== undefined) {
+            writeInfo(`Global:         ${channel.data.global ? 'Yes' : 'No'}`);
+        }
+        if (channel.data.country) {
+            writeInfo(`Country:        ${channel.data.country}`);
+        }
+        if (channel.data.metadata) {
+            const meta = channel.data.metadata;
+            writeInfo(`\nMetadata:`);
+            if (meta.verified_name) {
+                writeInfo(`  Verified Name:  ${meta.verified_name}`);
+            }
+            if (meta.status) {
+                writeInfo(`  Status:         ${meta.status}`);
+            }
+            if (meta.quality_rating) {
+                writeInfo(`  Quality:        ${meta.quality_rating}`);
+            }
+            if (meta.wabaId) {
+                writeInfo(`  WABA ID:        ${meta.wabaId}`);
+            }
+        }
+    }
+}
+/**
+ * Displays Facebook-specific details
+ */
+function displayFacebookDetails(channel) {
+    if (channel.facebook) {
+        writeInfo(`Page Name:      ${channel.facebook}`);
+    }
+    if (channel.data) {
+        if (channel.data.name) {
+            writeInfo(`Name:           ${channel.data.name}`);
+        }
+        if (channel.data.pageId) {
+            writeInfo(`Page ID:        ${channel.data.pageId}`);
+        }
+        if (channel.data.category) {
+            writeInfo(`Category:       ${channel.data.category}`);
+        }
+    }
+}
+/**
+ * Displays Instagram-specific details
+ */
+function displayInstagramDetails(channel) {
+    if (channel.instagram) {
+        writeInfo(`Username:       ${channel.instagram}`);
+    }
+    if (channel.data) {
+        if (channel.data.username) {
+            writeInfo(`Username:       ${channel.data.username}`);
+        }
+        if (channel.data.account_type) {
+            writeInfo(`Account Type:   ${channel.data.account_type}`);
+        }
+        if (channel.data.account_id) {
+            writeInfo(`Account ID:     ${channel.data.account_id}`);
+        }
+    }
+}
+/**
+ * Displays Slack-specific details
+ */
+function displaySlackDetails(channel) {
+    if (channel.data) {
+        if (channel.data.type) {
+            writeInfo(`Type:           ${channel.data.type}`);
+        }
+        if (channel.data.botName) {
+            writeInfo(`Bot Name:       ${channel.data.botName}`);
+        }
+        if (channel.data.url) {
+            writeInfo(`Workspace:      ${channel.data.url}`);
+        }
+        if (channel.data.teamId) {
+            writeInfo(`Team ID:        ${channel.data.teamId}`);
+        }
+        if (channel.data.appId) {
+            writeInfo(`App ID:         ${channel.data.appId}`);
+        }
+        if (channel.data.botId) {
+            writeInfo(`Bot ID:         ${channel.data.botId}`);
+        }
+    }
+}
+/**
+ * Displays Email-specific details
+ */
+function displayEmailDetails(channel) {
+    if (channel.data) {
+        if (channel.data.from) {
+            writeInfo(`From Address:   ${channel.data.from}`);
+        }
+        if (channel.data.name) {
+            writeInfo(`Name:           ${channel.data.name}`);
+        }
+        if (channel.data.templateId) {
+            writeInfo(`Template ID:    ${channel.data.templateId}`);
+        }
+        if (channel.data.active !== undefined) {
+            writeInfo(`Active:         ${channel.data.active ? 'Yes' : 'No'}`);
+        }
+    }
+}
+/**
+ * Creates a new channel for a specific agent
+ */
+async function createChannel(agentApi, agentId) {
+    // Ask for channel type
+    const { channelType } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "channelType",
+            message: "Select channel type:",
+            choices: [
+                { name: "📱 WhatsApp", value: "whatsapp" },
+                { name: "💬 Facebook Messenger", value: "facebook" },
+                { name: "📧 Email", value: "email" },
+                { name: "🔒 Slack (Private)", value: "slack-private" },
+                { name: "🌐 Slack (Public)", value: "slack-public" }
+            ]
+        }
+    ]);
+    clearPromptLines(2);
+    // Create channel based on type
+    switch (channelType) {
+        case "whatsapp":
+            await createWhatsAppChannel(agentApi, agentId);
+            break;
+        case "facebook":
+            await createFacebookChannel(agentApi, agentId);
+            break;
+        case "email":
+            await createEmailChannel(agentApi, agentId);
+            break;
+        case "slack-private":
+            await createSlackPrivateChannel(agentApi, agentId);
+            break;
+        case "slack-public":
+            await createSlackPublicChannel(agentApi, agentId);
+            break;
+    }
+}
+/**
+ * Creates a WhatsApp channel
+ */
+async function createWhatsAppChannel(agentApi, agentId) {
+    writeInfo("📱 Creating WhatsApp Channel\n");
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "phoneNumberId",
+            message: "Enter phone number ID:",
+            validate: (input) => {
+                return input.trim().length > 0 || "Phone number ID is required";
+            }
+        },
+        {
+            type: "input",
+            name: "wabaId",
+            message: "Enter WhatsApp Business Account ID (WABA ID):",
+            validate: (input) => {
+                return input.trim().length > 0 || "WABA ID is required";
+            }
+        },
+        {
+            type: "password",
+            name: "accessToken",
+            message: "Enter access token:",
+            mask: "*",
+            validate: (input) => {
+                return input.trim().length > 0 || "Access token is required";
+            }
+        }
+    ]);
+    const channelData = {
+        type: "whatsapp",
+        whatsapp: {
+            phoneNumberId: answers.phoneNumberId.trim(),
+            wabaId: answers.wabaId.trim(),
+            accessToken: answers.accessToken.trim()
+        },
+        isManual: true
+    };
+    writeInfo("\n📡 Creating WhatsApp channel...");
+    const response = await agentApi.createWhatsAppChannel(agentId, channelData);
+    if (!response.success) {
+        const error = response.error;
+        if (error?.statusCode === 400 && error?.message?.includes('already exists')) {
+            console.error(`\n❌ Channel already exists`);
+            console.error(`💡 This WhatsApp number is already connected to this agent.`);
+            console.error(`   Use 'lua channels' to list existing channels.\n`);
+        }
+        else {
+            console.error(`\n❌ Error: ${error?.message || 'Unknown error'}`);
+            if (error?.error) {
+                console.error(`   ${error.error}\n`);
+            }
+        }
+        process.exit(1);
+    }
+    const data = response.data;
+    writeSuccess("\n✅ WhatsApp channel created successfully!\n");
+    writeInfo(`📞 Phone Number: ${data.whatsapp.number}`);
+    writeInfo(`🆔 Identifier: ${data.identifier}`);
+    writeInfo(`✅ Status: ${data.whatsapp.metadata.status}`);
+    writeInfo(`🔗 Webhook URL: ${data.webhookUrl}\n`);
+}
+/**
+ * Creates a Facebook Messenger channel
+ */
+async function createFacebookChannel(agentApi, agentId) {
+    writeInfo("💬 Creating Facebook Messenger Channel\n");
+    const answers = await inquirer.prompt([
+        {
+            type: "password",
+            name: "accessToken",
+            message: "Enter Facebook page access token:",
+            mask: "*",
+            validate: (input) => {
+                return input.trim().length > 0 || "Access token is required";
+            }
+        },
+        {
+            type: "input",
+            name: "pageId",
+            message: "Enter Facebook page ID:",
+            validate: (input) => {
+                return input.trim().length > 0 || "Page ID is required";
+            }
+        }
+    ]);
+    const channelData = {
+        type: "facebook",
+        facebook: {
+            accessToken: answers.accessToken.trim(),
+            pageId: answers.pageId.trim()
+        }
+    };
+    writeInfo("\n📡 Creating Facebook channel...");
+    const response = await agentApi.createFacebookChannel(agentId, channelData);
+    if (!response.success) {
+        const error = response.error;
+        if (error?.statusCode === 400 && error?.message?.includes('already exists')) {
+            console.error(`\n❌ Channel already exists`);
+            console.error(`💡 This Facebook page is already connected to this agent.`);
+            console.error(`   Use 'lua channels' to list existing channels.\n`);
+        }
+        else {
+            console.error(`\n❌ Error: ${error?.message || 'Unknown error'}`);
+            if (error?.error) {
+                console.error(`   ${error.error}\n`);
+            }
+        }
+        process.exit(1);
+    }
+    const data = response.data;
+    writeSuccess("\n✅ Facebook channel created successfully!\n");
+    writeInfo(`📄 Page Name: ${data.facebook.name}`);
+    writeInfo(`🆔 Identifier: ${data.identifier}`);
+    writeInfo(`📋 Category: ${data.facebook.category}`);
+    writeInfo(`🔗 Webhook URL: ${data.webhookUrl}\n`);
+}
+/**
+ * Creates an Email channel
+ */
+async function createEmailChannel(agentApi, agentId) {
+    writeInfo("📧 Creating Email Channel\n");
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "name",
+            message: "Enter sender name (shown in email header):",
+            validate: (input) => {
+                return input.trim().length > 0 || "Sender name is required";
+            }
+        },
+        {
+            type: "input",
+            name: "email",
+            message: "Enter sender email address:",
+            validate: (input) => {
+                if (input.trim().length === 0) {
+                    return "Email address is required";
+                }
+                const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailRegex.test(input.trim())) {
+                    return "Please enter a valid email address";
+                }
+                return true;
+            }
+        }
+    ]);
+    const channelData = {
+        type: "email",
+        email: {
+            name: answers.name.trim(),
+            email: answers.email.trim()
+        }
+    };
+    writeInfo("\n📡 Creating Email channel...");
+    const response = await agentApi.createEmailChannel(agentId, channelData);
+    if (!response.success) {
+        const error = response.error;
+        if (error?.statusCode === 400 && error?.message?.includes('already exists')) {
+            console.error(`\n❌ Channel already exists`);
+            console.error(`💡 This email address is already connected to this agent.`);
+            console.error(`   Use 'lua channels' to list existing channels.\n`);
+        }
+        else {
+            console.error(`\n❌ Error: ${error?.message || 'Unknown error'}`);
+            if (error?.error) {
+                console.error(`   ${error.error}\n`);
+            }
+        }
+        process.exit(1);
+    }
+    const data = response.data;
+    writeSuccess("\n✅ Email channel created successfully!\n");
+    writeInfo(`📧 Sender Name:     ${answers.name}`);
+    writeInfo(`📧 Sender Email:    ${answers.email}`);
+    writeInfo(`📬 Forward To:      ${data.forwardTo}\n`);
+    writeInfo(`${'─'.repeat(60)}`);
+    writeInfo(`⚠️  IMPORTANT: Email Forwarding Setup Required`);
+    writeInfo(`${'─'.repeat(60)}`);
+    writeInfo(`\nTo complete the email channel setup, configure email forwarding:`);
+    writeInfo(`\n1. Log into your email provider's settings`);
+    writeInfo(`2. Set up email forwarding or filtering`);
+    writeInfo(`3. Forward all emails from ${answers.email} to:`);
+    writeInfo(`   ${data.forwardTo}`);
+    writeInfo(`\n4. Test by sending an email to ${answers.email}`);
+    writeInfo(`   Your agent will respond automatically!\n`);
+    writeInfo(`${'─'.repeat(60)}\n`);
+}
+/**
+ * Creates a private Slack channel
+ */
+async function createSlackPrivateChannel(agentApi, agentId) {
+    writeInfo("🔒 Creating Private Slack Channel\n");
+    const answers = await inquirer.prompt([
+        {
+            type: "password",
+            name: "accessToken",
+            message: "Enter Slack bot access token (xoxb-...):",
+            mask: "*",
+            validate: (input) => {
+                if (input.trim().length === 0) {
+                    return "Access token is required";
+                }
+                if (!input.trim().startsWith("xoxb-")) {
+                    return "Bot token should start with 'xoxb-'";
+                }
+                return true;
+            }
+        }
+    ]);
+    const channelData = {
+        type: "slack",
+        slack: {
+            type: "private",
+            accessToken: answers.accessToken.trim()
+        }
+    };
+    writeInfo("\n📡 Creating Slack private channel...");
+    const response = await agentApi.createSlackChannel(agentId, channelData);
+    if (!response.success) {
+        const error = response.error;
+        if (error?.statusCode === 400 && error?.message?.includes('already exists')) {
+            console.error(`\n❌ Channel already exists`);
+            console.error(`💡 This Slack workspace is already connected to this agent.`);
+            console.error(`   Use 'lua channels' to list existing channels.\n`);
+        }
+        else {
+            console.error(`\n❌ Error: ${error?.message || 'Unknown error'}`);
+            if (error?.error) {
+                console.error(`   ${error.error}\n`);
+            }
+        }
+        process.exit(1);
+    }
+    const data = response.data;
+    // Type guard to check if it's a private channel response
+    if ('slack' in data && 'botName' in data.slack) {
+        writeSuccess("\n✅ Slack private channel created successfully!\n");
+        writeInfo(`🤖 Bot Name: ${data.slack.botName}`);
+        writeInfo(`🏢 Workspace: ${data.slack.url}`);
+        writeInfo(`🆔 Bot ID: ${data.slack.botId}`);
+        writeInfo(`Ensure your app Manifest is configured correctly. Below is an example:\n`);
+        writeInfo(JSON.stringify(data.slack.manifest, null, 2));
+    }
+}
+/**
+ * Creates a public Slack channel
+ */
+async function createSlackPublicChannel(agentApi, agentId) {
+    writeInfo("🌐 Creating Public Slack Channel\n");
+    const answers = await inquirer.prompt([
+        {
+            type: "input",
+            name: "appId",
+            message: "Enter Slack app ID:",
+            validate: (input) => {
+                return input.trim().length > 0 || "App ID is required";
+            }
+        },
+        {
+            type: "input",
+            name: "clientId",
+            message: "Enter Slack client ID:",
+            validate: (input) => {
+                return input.trim().length > 0 || "Client ID is required";
+            }
+        },
+        {
+            type: "password",
+            name: "clientSecret",
+            message: "Enter Slack client secret:",
+            mask: "*",
+            validate: (input) => {
+                return input.trim().length > 0 || "Client secret is required";
+            }
+        }
+    ]);
+    const channelData = {
+        type: "slack",
+        slack: {
+            type: "public",
+            appId: answers.appId.trim(),
+            clientId: answers.clientId.trim(),
+            clientSecret: answers.clientSecret.trim()
+        }
+    };
+    writeInfo("\n📡 Creating Slack public channel...");
+    const response = await agentApi.createSlackChannel(agentId, channelData);
+    if (!response.success) {
+        const error = response.error;
+        if (error?.statusCode === 400 && error?.message?.includes('already exists')) {
+            console.error(`\n❌ Channel already exists`);
+            console.error(`💡 This Slack app is already connected to this agent.`);
+            console.error(`   Use 'lua channels' to list existing channels.\n`);
+        }
+        else {
+            console.error(`\n❌ Error: ${error?.message || 'Unknown error'}`);
+            if (error?.error) {
+                console.error(`   ${error.error}\n`);
+            }
+        }
+        process.exit(1);
+    }
+    const data = response.data;
+    // Type guard to check if it's a public channel response
+    if ('redirectUri' in data) {
+        writeSuccess("\n✅ Slack public channel created successfully!\n");
+        writeInfo(`🆔 App ID: ${data.appId}`);
+        writeInfo(`🔗 Redirect URI: ${data.redirectUri}`);
+        writeInfo(`🔗 Webhook URL: ${data.webhookUrl}\n`);
+        writeInfo(`🔗 Install URL: https://auth.heylua.ai/slack/install/${data.appId}`);
+        writeInfo(`Ensure your app Manifest is configured correctly. Below is an example:\n`);
+        writeInfo(JSON.stringify(data.manifest, null, 2));
+    }
+}

package/dist/commands/docs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Docs Command
+ * Opens the Lua documentation website in the user's default browser
+ */
+/**
+ * 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 declare function docsCommand(): Promise<void>;