lua-cli 2.5.8 → 3.0.0-alpha.4

package/dist/commands/webhooks.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Webhooks Command
+ * Manages agent webhooks for sandbox and production environments
+ */
+/**
+ * Main webhooks command - manages agent webhooks
+ *
+ * Features:
+ * - View deployed webhooks
+ * - View webhook versions
+ * - Deploy webhook versions to production
+ * - Activate/deactivate webhooks
+ *
+ * Note: For local testing, use `lua test webhook`
+ *
+ * @returns Promise that resolves when command completes
+ */
+export declare function webhooksCommand(): Promise<void>;

package/dist/commands/webhooks.js

@@ -0,0 +1,424 @@
+/**
+ * Webhooks Command
+ * Manages agent webhooks for sandbox and production environments
+ */
+import { loadApiKey, checkApiKey } from '../services/auth.js';
+import { readSkillConfig } from '../utils/files.js';
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
+import { BASE_URLS } from '../config/constants.js';
+import { safePrompt } from '../utils/prompt-handler.js';
+import { validateConfig, validateAgentConfig, } from '../utils/dev-helpers.js';
+import WebhookApi from '../api/webhook.api.service.js';
+/**
+ * Main webhooks command - manages agent webhooks
+ *
+ * Features:
+ * - View deployed webhooks
+ * - View webhook versions
+ * - Deploy webhook versions to production
+ * - Activate/deactivate webhooks
+ *
+ * Note: For local testing, use `lua test webhook`
+ *
+ * @returns Promise that resolves when command completes
+ */
+export async function webhooksCommand() {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration first (to get agentId)
+        const config = readSkillConfig();
+        validateConfig(config);
+        validateAgentConfig(config);
+        const agentId = config.agent.agentId;
+        // Step 2: Authenticate
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
+            process.exit(1);
+        }
+        await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        const context = {
+            environment: 'production',
+            agentId,
+            apiKey,
+        };
+        // Start webhook management
+        await manageProductionWebhooks(context, config);
+    }, "webhooks");
+}
+/**
+ * Manage production webhooks - view and deploy versions
+ */
+async function manageProductionWebhooks(context, config) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🚀 Production Webhooks");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View deployed webhooks', value: 'view' },
+                    { name: '📜 View webhook versions', value: 'versions' },
+                    { name: '🚀 Deploy a version', value: 'deploy' },
+                    { name: '✅ Activate a webhook', value: 'activate' },
+                    { name: '🚫 Deactivate a webhook', value: 'deactivate' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await viewDeployedWebhooks(context, config);
+                break;
+            case 'versions':
+                await viewWebhookVersions(context, config);
+                break;
+            case 'deploy':
+                await deployWebhookVersion(context, config);
+                break;
+            case 'activate':
+                await activateWebhook(context, config);
+                break;
+            case 'deactivate':
+                await deactivateWebhook(context, config);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * View deployed webhooks in production
+ */
+async function viewDeployedWebhooks(context, config) {
+    writeProgress("🔄 Loading webhook information...");
+    try {
+        const webhooks = config.webhooks || [];
+        if (webhooks.length === 0) {
+            console.log("\nℹ️  No webhooks found in configuration.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        console.log("\n" + "=".repeat(60));
+        console.log("⚙️  Production Webhooks");
+        console.log("=".repeat(60) + "\n");
+        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+        // Fetch version info for each webhook
+        for (const webhook of webhooks) {
+            try {
+                const response = await webhookApi.getWebhookVersions(webhook.webhookId);
+                if (response.success && response.data) {
+                    const versions = response.data.versions || [];
+                    const activeVersionId = response.data.activeVersionId;
+                    // Find active version
+                    const activeVersion = versions.find((v) => v.webhookId === activeVersionId);
+                    console.log(`🪝 ${webhook.name}`);
+                    console.log(`   Webhook ID: ${webhook.webhookId}`);
+                    if (activeVersion) {
+                        console.log(`   Deployed Version: ${activeVersion.version} ⭐`);
+                        const date = new Date(activeVersion.createdAt);
+                        console.log(`   Deployed: ${date.toLocaleString()}`);
+                    }
+                    else {
+                        console.log(`   Deployed Version: Not deployed`);
+                    }
+                    console.log(`   Total Versions: ${versions.length}`);
+                    console.log();
+                }
+                else {
+                    console.log(`🪝 ${webhook.name}`);
+                    console.log(`   Webhook ID: ${webhook.webhookId}`);
+                    console.log(`   Status: Unable to fetch version info`);
+                    console.log();
+                }
+            }
+            catch (error) {
+                console.log(`🪝 ${webhook.name}`);
+                console.log(`   Webhook ID: ${webhook.webhookId}`);
+                console.log(`   Status: Error loading versions`);
+                console.log();
+            }
+        }
+        console.log("=".repeat(60) + "\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('❌ Error loading webhook information:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * View versions for a specific webhook
+ */
+async function viewWebhookVersions(context, config) {
+    const webhooks = config.webhooks || [];
+    if (webhooks.length === 0) {
+        console.log("\nℹ️  No webhooks found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a webhook
+    const webhookAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedWebhook',
+            message: 'Select a webhook to view versions:',
+            choices: webhooks.map((webhook) => ({
+                name: `${webhook.name} (${webhook.webhookId})`,
+                value: webhook
+            }))
+        }
+    ]);
+    if (!webhookAnswer)
+        return;
+    const selectedWebhook = webhookAnswer.selectedWebhook;
+    writeProgress(`🔄 Loading versions for ${selectedWebhook.name}...`);
+    try {
+        const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${context.agentId}/${selectedWebhook.webhookId}/versions`, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${context.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const data = await response.json();
+        const versions = data.data?.versions || data.versions || [];
+        const activeVersionId = data.data?.activeVersionId || data.activeVersionId;
+        if (versions.length === 0) {
+            console.log(`\nℹ️  No versions found for ${selectedWebhook.name}.\n`);
+            console.log("💡 Push a version first using 'lua push webhook'.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        console.log("\n" + "=".repeat(60));
+        console.log(`📜 Versions for ${selectedWebhook.name}`);
+        console.log("=".repeat(60) + "\n");
+        // Sort versions by date (newest first)
+        const sortedVersions = versions.sort((a, b) => {
+            const dateA = new Date(a.createdAt).getTime();
+            const dateB = new Date(b.createdAt).getTime();
+            return dateB - dateA;
+        });
+        sortedVersions.forEach((version, index) => {
+            const isActive = version.webhookId === activeVersionId;
+            const date = new Date(version.createdAt);
+            console.log(`${index + 1}. Version ${version.version}${isActive ? ' ⭐ DEPLOYED' : ''}`);
+            console.log(`   Created: ${date.toLocaleString()}`);
+            console.log(`   Version ID: ${version.webhookId}`);
+            console.log();
+        });
+        console.log("=".repeat(60) + "\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('❌ Error loading versions:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * Deploy a webhook version to production
+ */
+async function deployWebhookVersion(context, config) {
+    const webhooks = config.webhooks || [];
+    if (webhooks.length === 0) {
+        console.log("\nℹ️  No webhooks found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a webhook
+    const webhookAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedWebhook',
+            message: 'Select a webhook to deploy:',
+            choices: webhooks.map((webhook) => ({
+                name: `${webhook.name} (${webhook.webhookId})`,
+                value: webhook
+            }))
+        }
+    ]);
+    if (!webhookAnswer)
+        return;
+    const selectedWebhook = webhookAnswer.selectedWebhook;
+    writeProgress(`🔄 Loading versions for ${selectedWebhook.name}...`);
+    try {
+        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await webhookApi.getWebhookVersions(selectedWebhook.webhookId);
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to fetch versions');
+        }
+        const versions = response.data.versions || [];
+        const activeVersionId = response.data.activeVersionId;
+        if (versions.length === 0) {
+            console.log(`\nℹ️  No versions found for ${selectedWebhook.name}.\n`);
+            console.log("💡 Push a version first using 'lua push webhook'.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        // Sort versions by date (newest first)
+        const sortedVersions = versions.sort((a, b) => {
+            const dateA = new Date(a.createdAt).getTime();
+            const dateB = new Date(b.createdAt).getTime();
+            return dateB - dateA;
+        });
+        // Prompt to select a version
+        const versionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'selectedVersion',
+                message: 'Select a version to deploy:',
+                choices: sortedVersions.map((version) => {
+                    const isActive = version.webhookId === activeVersionId;
+                    const date = new Date(version.createdAt);
+                    return {
+                        name: `Version ${version.version} (${date.toLocaleDateString()})${isActive ? ' ⭐ CURRENT' : ''}`,
+                        value: version
+                    };
+                })
+            }
+        ]);
+        if (!versionAnswer)
+            return;
+        const selectedVersion = versionAnswer.selectedVersion;
+        // Show warning
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        console.log(`Webhook: ${selectedWebhook.name}`);
+        console.log(`Version: ${selectedVersion.version}\n`);
+        const confirmAnswer = await safePrompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Are you absolutely sure you want to deploy this version?',
+                default: false
+            }
+        ]);
+        if (!confirmAnswer || !confirmAnswer.confirm) {
+            console.log("\n❌ Deployment cancelled.\n");
+            return;
+        }
+        writeProgress("🔄 Deploying version...");
+        // Reuse the same webhookApi instance
+        const deployResponse = await webhookApi.publishWebhookVersion(selectedWebhook.webhookId, selectedVersion.version);
+        if (!deployResponse.success) {
+            console.error(`\n❌ Deploy Error: ${deployResponse.error?.message || 'Unknown error'}\n`);
+            throw new Error(deployResponse.error?.message || 'Failed to publish webhook version');
+        }
+        writeSuccess(`\n✅ Version ${selectedVersion.version} of "${selectedWebhook.name}" deployed successfully to production\n`);
+        writeInfo("💡 The new version is now active for all users.");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('\n❌ Error deploying version:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * Activate a webhook
+ */
+async function activateWebhook(context, config) {
+    const webhooks = config.webhooks || [];
+    if (webhooks.length === 0) {
+        console.log("\nℹ️  No webhooks found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a webhook
+    const webhookAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedWebhook',
+            message: 'Select a webhook to activate:',
+            choices: webhooks.map((webhook) => ({
+                name: `${webhook.name} (${webhook.webhookId})`,
+                value: webhook
+            }))
+        }
+    ]);
+    if (!webhookAnswer)
+        return;
+    const selectedWebhook = webhookAnswer.selectedWebhook;
+    writeProgress(`🔄 Activating webhook "${selectedWebhook.name}"...`);
+    try {
+        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await webhookApi.activateWebhook(selectedWebhook.webhookId);
+        if (!response.success) {
+            console.error(`\n❌ Error: ${response.error?.message || 'Unknown error'}\n`);
+            throw new Error(response.error?.message || 'Failed to activate webhook');
+        }
+        writeSuccess(`\n✅ Webhook "${selectedWebhook.name}" activated successfully\n`);
+        writeInfo("💡 The webhook is now enabled and can receive requests.");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('\n❌ Error activating webhook:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * Deactivate a webhook
+ */
+async function deactivateWebhook(context, config) {
+    const webhooks = config.webhooks || [];
+    if (webhooks.length === 0) {
+        console.log("\nℹ️  No webhooks found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a webhook
+    const webhookAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedWebhook',
+            message: 'Select a webhook to deactivate:',
+            choices: webhooks.map((webhook) => ({
+                name: `${webhook.name} (${webhook.webhookId})`,
+                value: webhook
+            }))
+        }
+    ]);
+    if (!webhookAnswer)
+        return;
+    const selectedWebhook = webhookAnswer.selectedWebhook;
+    // Confirm deactivation
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to deactivate "${selectedWebhook.name}"? It will stop receiving requests.`,
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Deactivation cancelled.\n");
+        return;
+    }
+    writeProgress(`🔄 Deactivating webhook "${selectedWebhook.name}"...`);
+    try {
+        const webhookApi = new WebhookApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await webhookApi.deactivateWebhook(selectedWebhook.webhookId);
+        if (!response.success) {
+            console.error(`\n❌ Error: ${response.error?.message || 'Unknown error'}\n`);
+            throw new Error(response.error?.message || 'Failed to deactivate webhook');
+        }
+        writeSuccess(`\n✅ Webhook "${selectedWebhook.name}" deactivated successfully\n`);
+        writeInfo("💡 The webhook is now disabled and will not receive requests.");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('\n❌ Error deactivating webhook:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Job Instance
+ * Provides a convenient interface for interacting with a job
+ */
+import JobApi from '../api/job.api.service.js';
+import UserDataInstance from './user.instance.js';
+/**
+ * Job Instance class.
+ * Represents a single job with helper methods for common operations.
+ *
+ * This class provides:
+ * - Direct property access to job data via Proxy
+ * - Helper methods for job operations (delete, updateMetadata)
+ * - Metadata access and modification
+ *
+ * @example
+ * ```typescript
+ * const job = await Jobs.create({
+ *   name: 'my-job',
+ *   schedule: { type: 'once', executeAt: new Date() },
+ *   execute: async (job) => {
+ *     // Access metadata
+ *     console.log(job.metadata);
+ *
+ *     // Update metadata
+ *     await job.updateMetadata({ processed: true });
+ *
+ *     // Delete job when done
+ *     await job.delete();
+ *   }
+ * });
+ * ```
+ */
+export declare class JobInstance {
+    private jobApi;
+    private _data;
+    readonly id: string;
+    readonly name: string;
+    readonly jobId: string;
+    readonly schedule: any;
+    metadata: Record<string, any>;
+    private userApi;
+    constructor(jobApi: JobApi, jobData: any);
+    /**
+     * Gets the full job data.
+     */
+    get data(): any;
+    /**
+     * Updates the job's metadata.
+     *
+     * @param metadata - The new metadata to set
+     * @returns Promise resolving when update is complete
+     *
+     * @example
+     * ```typescript
+     * await job.updateMetadata({
+     *   lastProcessed: new Date().toISOString(),
+     *   status: 'completed'
+     * });
+     * ```
+     */
+    updateMetadata(metadata: Record<string, any>): Promise<void>;
+    /**
+     * Deletes the job from the backend.
+     *
+     * @returns Promise resolving when deletion is complete
+     *
+     * @example
+     * ```typescript
+     * // Delete a one-time job after it completes
+     * await job.delete();
+     * ```
+     */
+    delete(): Promise<void>;
+    user(): Promise<UserDataInstance>;
+    /**
+     * Converts the job instance to JSON.
+     */
+    toJSON(): any;
+}

package/dist/common/job.instance.js

@@ -0,0 +1,116 @@
+/**
+ * Job Instance
+ * Provides a convenient interface for interacting with a job
+ */
+import UserDataInstance from './user.instance.js';
+import UserDataApi from '../api/user.data.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+/**
+ * Job Instance class.
+ * Represents a single job with helper methods for common operations.
+ *
+ * This class provides:
+ * - Direct property access to job data via Proxy
+ * - Helper methods for job operations (delete, updateMetadata)
+ * - Metadata access and modification
+ *
+ * @example
+ * ```typescript
+ * const job = await Jobs.create({
+ *   name: 'my-job',
+ *   schedule: { type: 'once', executeAt: new Date() },
+ *   execute: async (job) => {
+ *     // Access metadata
+ *     console.log(job.metadata);
+ *
+ *     // Update metadata
+ *     await job.updateMetadata({ processed: true });
+ *
+ *     // Delete job when done
+ *     await job.delete();
+ *   }
+ * });
+ * ```
+ */
+export class JobInstance {
+    constructor(jobApi, jobData) {
+        this.jobApi = jobApi;
+        this._data = jobData;
+        this.id = jobData.id || jobData.jobId;
+        this.jobId = jobData.id || jobData.jobId;
+        this.name = jobData.name;
+        this.schedule = jobData.schedule;
+        this.metadata = jobData.metadata || {};
+        this.userApi = new UserDataApi(BASE_URLS.API, jobApi.apiKey, jobApi.agentId);
+    }
+    /**
+     * Gets the full job data.
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * Updates the job's metadata.
+     *
+     * @param metadata - The new metadata to set
+     * @returns Promise resolving when update is complete
+     *
+     * @example
+     * ```typescript
+     * await job.updateMetadata({
+     *   lastProcessed: new Date().toISOString(),
+     *   status: 'completed'
+     * });
+     * ```
+     */
+    async updateMetadata(metadata) {
+        this.metadata = { ...this.metadata, ...metadata };
+        const result = await this.jobApi.updateMetadata(this.jobId, this.metadata);
+        if (!result.success) {
+            throw new Error(result.error?.message || 'Failed to update job metadata');
+        }
+        return result.data;
+        // Update metadata on the server if the job has versions
+        // Note: Metadata updates may require updating the active version
+        // For now, we just update the local instance
+        // In the future, this could call an API endpoint to update job metadata
+        console.warn('Note: Job metadata updates are stored locally. Deploy a new version to persist changes.');
+    }
+    /**
+     * Deletes the job from the backend.
+     *
+     * @returns Promise resolving when deletion is complete
+     *
+     * @example
+     * ```typescript
+     * // Delete a one-time job after it completes
+     * await job.delete();
+     * ```
+     */
+    async delete() {
+        const result = await this.jobApi.deleteJob(this.jobId);
+        if (!result.success) {
+            throw new Error(result.error?.message || 'Failed to delete job');
+        }
+        if (result.data?.deactivated) {
+            console.warn(`Job "${this.name}" has versions and was deactivated instead of deleted.`);
+        }
+    }
+    async user() {
+        const result = await this.userApi.get();
+        return new UserDataInstance(this.userApi, result);
+    }
+    /**
+     * Converts the job instance to JSON.
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            jobId: this.jobId,
+            name: this.name,
+            schedule: this.schedule,
+            metadata: this.metadata,
+            ...this._data
+        };
+    }
+}

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

@@ -47,4 +47,5 @@ export default class UserDataInstance {
      * @throws Error if the message sending fails or the request is unsuccessful
      */
     send(messages: Message[]): Promise<any>;
+    getChatHistory(): Promise<any>;
 }

package/dist/common/user.instance.js

@@ -158,4 +158,13 @@ export default class UserDataInstance {
             throw new Error('Failed to send message');
         }
     }
+    //get chat history
+    async getChatHistory() {
+        try {
+            return await this.userAPI.getChatHistory();
+        }
+        catch (error) {
+            throw new Error('Failed to get chat history');
+        }
+    }
 }

package/dist/config/constants.d.ts

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