lua-cli 2.5.8 → 3.0.0-alpha.1

package/dist/commands/jobs.js

@@ -0,0 +1,533 @@
+/**
+ * Jobs Command
+ * Manages agent scheduled jobs 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 JobApi from '../api/job.api.service.js';
+/**
+ * Main jobs command - manages agent jobs
+ *
+ * Features:
+ * - View deployed jobs
+ * - View job versions
+ * - Deploy job versions to production
+ * - Activate/deactivate, pause/resume jobs
+ * - Trigger jobs manually
+ * - View execution history
+ *
+ * Note: For local testing, use `lua test job`
+ *
+ * @returns Promise that resolves when command completes
+ */
+export async function jobsCommand() {
+    return withErrorHandling(async () => {
+        // Step 1: Load configuration
+        const config = readSkillConfig();
+        validateConfig(config);
+        validateAgentConfig(config);
+        const agentId = config.agent.agentId;
+        // Step 2: Authenticate
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.error("❌ No API key found. Please run 'lua auth configure' to set up your API key.");
+            process.exit(1);
+        }
+        await checkApiKey(apiKey);
+        writeProgress("✅ Authenticated");
+        const context = {
+            environment: 'production',
+            agentId,
+            apiKey,
+        };
+        // Start job management
+        await manageProductionJobs(context, config);
+    }, "jobs");
+}
+/**
+ * Manage production jobs - view, deploy, pause/resume, trigger
+ */
+async function manageProductionJobs(context, config) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🚀 Production Jobs");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View deployed jobs', value: 'view' },
+                    { name: '📜 View job versions', value: 'versions' },
+                    { name: '🚀 Deploy a version', value: 'deploy' },
+                    { name: '✅ Activate a job', value: 'activate' },
+                    { name: '🚫 Deactivate a job', value: 'deactivate' },
+                    { name: '⚡ Trigger job now', value: 'trigger' },
+                    { name: '📊 View execution history', value: 'history' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await viewDeployedJobs(context, config);
+                break;
+            case 'versions':
+                await viewJobVersions(context, config);
+                break;
+            case 'deploy':
+                await deployJobVersion(context, config);
+                break;
+            case 'activate':
+                await activateJob(context, config);
+                break;
+            case 'deactivate':
+                await deactivateJob(context, config);
+                break;
+            case 'trigger':
+                await triggerJob(context, config);
+                break;
+            case 'history':
+                await viewExecutionHistory(context, config);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * View deployed jobs in production
+ */
+async function viewDeployedJobs(context, config) {
+    writeProgress("🔄 Loading job information...");
+    try {
+        const jobs = config.jobs || [];
+        if (jobs.length === 0) {
+            console.log("\nℹ️  No jobs found in configuration.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        console.log("\n" + "=".repeat(60));
+        console.log("⚙️  Production Jobs");
+        console.log("=".repeat(60) + "\n");
+        for (const job of jobs) {
+            try {
+                const response = await fetch(`${BASE_URLS.API}/developer/jobs/${context.agentId}/${job.jobId}`, {
+                    method: 'GET',
+                    headers: {
+                        'Authorization': `Bearer ${context.apiKey}`,
+                        'Content-Type': 'application/json'
+                    }
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    const jobData = data.data || data;
+                    console.log(`⏰ ${job.name}`);
+                    console.log(`   Job ID: ${job.jobId}`);
+                    console.log(`   Status: ${jobData.status || 'active'}`);
+                    if (jobData.schedule) {
+                        console.log(`   Schedule: ${formatSchedule(jobData.schedule)}`);
+                    }
+                    if (jobData.lastRunAt) {
+                        const lastRun = new Date(jobData.lastRunAt);
+                        console.log(`   Last Run: ${lastRun.toLocaleString()}`);
+                    }
+                    if (jobData.nextRunAt) {
+                        const nextRun = new Date(jobData.nextRunAt);
+                        console.log(`   Next Run: ${nextRun.toLocaleString()}`);
+                    }
+                    console.log();
+                }
+                else {
+                    console.log(`⏰ ${job.name}`);
+                    console.log(`   Job ID: ${job.jobId}`);
+                    console.log(`   Status: Unable to fetch info`);
+                    console.log();
+                }
+            }
+            catch (error) {
+                console.log(`⏰ ${job.name}`);
+                console.log(`   Job ID: ${job.jobId}`);
+                console.log(`   Status: Error loading info`);
+                console.log();
+            }
+        }
+        console.log("=".repeat(60) + "\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('❌ Error loading job information:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * View all versions for a specific job
+ */
+async function viewJobVersions(context, config) {
+    const jobs = config.jobs || [];
+    if (jobs.length === 0) {
+        console.log("\nℹ️  No jobs found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a job
+    const jobAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedJob',
+            message: 'Select a job to view versions:',
+            choices: jobs.map((job) => ({
+                name: `${job.name} (${job.jobId})`,
+                value: job
+            }))
+        }
+    ]);
+    if (!jobAnswer)
+        return;
+    const selectedJob = jobAnswer.selectedJob;
+    writeProgress(`🔄 Loading versions for ${selectedJob.name}...`);
+    try {
+        const jobApi = new JobApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await jobApi.getJobVersions(selectedJob.jobId);
+        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 ${selectedJob.name}.\n`);
+            console.log("💡 Push a version first using 'lua push job'.\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;
+        });
+        console.log("\n" + "=".repeat(60));
+        console.log(`📜 Versions for ${selectedJob.name}`);
+        console.log("=".repeat(60) + "\n");
+        sortedVersions.forEach((version) => {
+            const isActive = version.jobId === activeVersionId;
+            const date = new Date(version.createdAt);
+            console.log(`${isActive ? '⭐' : '  '} Version ${version.version}`);
+            console.log(`   Created: ${date.toLocaleString()}`);
+            if (version.schedule) {
+                console.log(`   Schedule: ${formatSchedule(version.schedule)}`);
+            }
+            console.log();
+        });
+        console.log("=".repeat(60) + "\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('\n❌ Error loading versions:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * Deploy a job version to production
+ */
+async function deployJobVersion(context, config) {
+    const jobs = config.jobs || [];
+    if (jobs.length === 0) {
+        console.log("\nℹ️  No jobs found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a job
+    const jobAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedJob',
+            message: 'Select a job to deploy:',
+            choices: jobs.map((job) => ({
+                name: `${job.name} (${job.jobId})`,
+                value: job
+            }))
+        }
+    ]);
+    if (!jobAnswer)
+        return;
+    const selectedJob = jobAnswer.selectedJob;
+    writeProgress(`🔄 Loading versions for ${selectedJob.name}...`);
+    try {
+        const jobApi = new JobApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await jobApi.getJobVersions(selectedJob.jobId);
+        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 ${selectedJob.name}.\n`);
+            console.log("💡 Push a version first using 'lua push job'.\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.jobId === 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(`Job: ${selectedJob.name}`);
+        console.log(`Version: ${selectedVersion.version}`);
+        console.log(`Schedule: ${formatSchedule(selectedJob.schedule)}\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 jobApi instance
+        const deployResponse = await jobApi.publishJobVersion(selectedJob.jobId, 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 job version');
+        }
+        writeSuccess(`\n✅ Version ${selectedVersion.version} of "${selectedJob.name}" deployed successfully to production\n`);
+        writeInfo("💡 The new version is now active and will run on schedule.");
+        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...' }]);
+    }
+}
+async function activateJob(context, config) {
+    const jobs = config.jobs || [];
+    if (jobs.length === 0) {
+        console.log("\nℹ️  No jobs found.\n");
+        return;
+    }
+    const jobAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedJob',
+            message: 'Select a job to activate:',
+            choices: jobs.map((job) => ({
+                name: `${job.name} (${job.jobId})`,
+                value: job
+            }))
+        }
+    ]);
+    if (!jobAnswer)
+        return;
+    writeProgress(`🔄 Activating job "${jobAnswer.selectedJob.name}"...`);
+    const jobApi = new JobApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await jobApi.activateJob(jobAnswer.selectedJob.jobId);
+    if (response.success) {
+        writeSuccess(`✅ Job "${jobAnswer.selectedJob.name}" activated successfully`);
+        writeInfo("💡 The job is now enabled and will run on schedule.");
+    }
+    else {
+        console.error(`❌ Failed to activate job: ${response.error?.message || 'Unknown error'}`);
+    }
+}
+async function deactivateJob(context, config) {
+    const jobs = config.jobs || [];
+    if (jobs.length === 0) {
+        console.log("\nℹ️  No jobs found.\n");
+        return;
+    }
+    const jobAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedJob',
+            message: 'Select a job to deactivate:',
+            choices: jobs.map((job) => ({
+                name: `${job.name} (${job.jobId})`,
+                value: job
+            }))
+        }
+    ]);
+    if (!jobAnswer)
+        return;
+    // Confirm deactivation
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to deactivate "${jobAnswer.selectedJob.name}"? It will stop running on schedule.`,
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Deactivation cancelled.\n");
+        return;
+    }
+    writeProgress(`🔄 Deactivating job "${jobAnswer.selectedJob.name}"...`);
+    const jobApi = new JobApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await jobApi.deactivateJob(jobAnswer.selectedJob.jobId);
+    if (response.success) {
+        writeSuccess(`✅ Job "${jobAnswer.selectedJob.name}" deactivated successfully`);
+        writeInfo("💡 The job is now disabled and will not run.");
+    }
+    else {
+        console.error(`❌ Failed to deactivate job: ${response.error?.message || 'Unknown error'}`);
+    }
+}
+async function triggerJob(context, config) {
+    const jobs = config.jobs || [];
+    if (jobs.length === 0) {
+        console.log("\nℹ️  No jobs found.\n");
+        return;
+    }
+    const jobAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedJob',
+            message: 'Select a job to trigger:',
+            choices: jobs.map((job) => ({
+                name: `${job.name} (${job.jobId})`,
+                value: job
+            }))
+        }
+    ]);
+    if (!jobAnswer)
+        return;
+    writeProgress("⚡ Triggering job...");
+    const jobApi = new JobApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await jobApi.triggerJob(jobAnswer.selectedJob.jobId);
+    if (response.success && response.data) {
+        writeSuccess(`✅ Job "${jobAnswer.selectedJob.name}" triggered successfully`);
+        writeInfo(`📋 Execution ID: ${response.data.executionId || 'N/A'}`);
+    }
+    else {
+        console.error(`❌ Failed to trigger job: ${response.error?.message || 'Unknown error'}`);
+    }
+}
+/**
+ * View execution history for a job
+ */
+async function viewExecutionHistory(context, config) {
+    const jobs = config.jobs || [];
+    if (jobs.length === 0) {
+        console.log("\nℹ️  No jobs found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    // Prompt to select a job
+    const jobAnswer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selectedJob',
+            message: 'Select a job to view execution history:',
+            choices: jobs.map((job) => ({
+                name: `${job.name} (${job.jobId})`,
+                value: job
+            }))
+        }
+    ]);
+    if (!jobAnswer)
+        return;
+    const selectedJob = jobAnswer.selectedJob;
+    writeProgress(`🔄 Loading execution history for ${selectedJob.name}...`);
+    try {
+        const jobApi = new JobApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await jobApi.getJobExecutions(selectedJob.jobId, 20); // Get last 20 executions
+        if (!response.success || !response.data) {
+            throw new Error(response.error?.message || 'Failed to fetch execution history');
+        }
+        const executions = response.data.executions || [];
+        if (executions.length === 0) {
+            console.log(`\nℹ️  No execution history found for ${selectedJob.name}.\n`);
+            console.log("💡 The job hasn't run yet or has no recorded executions.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        console.log("\n" + "=".repeat(60));
+        console.log(`📊 Execution History for ${selectedJob.name}`);
+        console.log("=".repeat(60) + "\n");
+        executions.forEach((execution, index) => {
+            const startedAt = new Date(execution.startedAt);
+            const status = execution.status;
+            const statusEmoji = status === 'completed' ? '✅' :
+                status === 'failed' ? '❌' :
+                    status === 'running' ? '🔄' : '⏳';
+            console.log(`${index + 1}. ${statusEmoji} ${status.toUpperCase()}`);
+            console.log(`   Execution ID: ${execution.executionId}`);
+            console.log(`   Started: ${startedAt.toLocaleString()}`);
+            if (execution.completedAt) {
+                const completedAt = new Date(execution.completedAt);
+                const duration = completedAt.getTime() - startedAt.getTime();
+                console.log(`   Completed: ${completedAt.toLocaleString()}`);
+                console.log(`   Duration: ${Math.round(duration / 1000)}s`);
+            }
+            if (execution.result) {
+                console.log(`   Result: ${JSON.stringify(execution.result).substring(0, 100)}...`);
+            }
+            if (execution.error) {
+                console.log(`   Error: ${execution.error}`);
+            }
+            console.log();
+        });
+        console.log("=".repeat(60) + "\n");
+        console.log(`Showing last ${executions.length} executions\n`);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+    catch (error) {
+        console.error('\n❌ Error loading execution history:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * Format schedule object for display
+ */
+function formatSchedule(schedule) {
+    if (!schedule)
+        return 'Not configured';
+    switch (schedule.type) {
+        case 'cron':
+            return `Cron: ${schedule.expression}${schedule.timezone ? ` (${schedule.timezone})` : ''}`;
+        case 'once':
+            return `Once at: ${new Date(schedule.executeAt).toLocaleString()}`;
+        case 'interval':
+            return `Every ${schedule.seconds} seconds`;
+        default:
+            return 'Unknown schedule type';
+    }
+}

package/dist/commands/logs.js

@@ -176,11 +176,8 @@ function displayLogs(logs, pagination, title) {
         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}`);
+        // Display full message without truncation
+        console.log(`   ${log.message}`);
         if (index < reversedLogs.length - 1) {
             console.log(chalk.gray(`   ${'-'.repeat(78)}`));
         }

package/dist/commands/postprocessors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PostProcessors Command
+ * Manages agent postprocessors for production environment
+ */
+/**
+ * Main postprocessors command - manages agent postprocessors
+ */
+export declare function postprocessorsCommand(): Promise<void>;