lua-cli 2.5.8 → 3.0.0-alpha.1

package/dist/commands/postprocessors.js

@@ -0,0 +1,431 @@
+/**
+ * PostProcessors Command
+ * Manages agent postprocessors for production environment
+ */
+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 PostProcessorApi from '../api/postprocessor.api.service.js';
+/**
+ * Main postprocessors command - manages agent postprocessors
+ */
+export async function postprocessorsCommand() {
+    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 = {
+            agentId,
+            apiKey,
+        };
+        // Start postprocessor management
+        await manageProductionPostProcessors(context, config);
+    }, "postprocessors");
+}
+/**
+ * Manage production postprocessors
+ */
+async function manageProductionPostProcessors(context, config) {
+    let continueManaging = true;
+    while (continueManaging) {
+        console.log("\n" + "=".repeat(60));
+        console.log("🚀 Production PostProcessors");
+        console.log("=".repeat(60) + "\n");
+        const actionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What would you like to do?',
+                choices: [
+                    { name: '👁️  View deployed postprocessors', value: 'view' },
+                    { name: '📜 View postprocessor versions', value: 'versions' },
+                    { name: '🚀 Deploy a version', value: 'deploy' },
+                    { name: '✅ Activate a postprocessor', value: 'activate' },
+                    { name: '🚫 Deactivate a postprocessor', value: 'deactivate' },
+                    { name: '🗑️  Delete a postprocessor', value: 'delete' },
+                    { name: '❌ Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        if (!actionAnswer)
+            return;
+        const { action } = actionAnswer;
+        switch (action) {
+            case 'view':
+                await viewDeployedPostProcessors(context, config);
+                break;
+            case 'versions':
+                await viewPostProcessorVersions(context, config);
+                break;
+            case 'deploy':
+                await deployPostProcessorVersion(context, config);
+                break;
+            case 'activate':
+                await activatePostProcessor(context, config);
+                break;
+            case 'deactivate':
+                await deactivatePostProcessor(context, config);
+                break;
+            case 'delete':
+                await deletePostProcessor(context, config);
+                break;
+            case 'exit':
+                continueManaging = false;
+                console.log("\n👋 Goodbye!\n");
+                break;
+        }
+    }
+}
+/**
+ * View deployed postprocessors in production
+ */
+async function viewDeployedPostProcessors(context, config) {
+    writeProgress("🔄 Loading postprocessor information...");
+    try {
+        const postprocessors = config.postprocessors || [];
+        if (postprocessors.length === 0) {
+            console.log("\nℹ️  No postprocessors found in configuration.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        console.log("\n" + "=".repeat(60));
+        console.log("⚙️  Production PostProcessors");
+        console.log("=".repeat(60) + "\n");
+        const api = new PostProcessorApi(BASE_URLS.API, context.apiKey, context.agentId);
+        for (const postprocessor of postprocessors) {
+            try {
+                const response = await api.getPostProcessorVersions(postprocessor.postprocessorId);
+                if (response.success && response.data) {
+                    const versions = response.data.versions || [];
+                    const activeVersionId = response.data.activeVersionId;
+                    const activeVersion = versions.find((v) => v.versionId === activeVersionId);
+                    console.log(`📤 ${postprocessor.name}`);
+                    console.log(`   PostProcessor ID: ${postprocessor.postprocessorId}`);
+                    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(`📤 ${postprocessor.name}`);
+                    console.log(`   PostProcessor ID: ${postprocessor.postprocessorId}`);
+                    console.log(`   Status: Unable to fetch version info`);
+                    console.log();
+                }
+            }
+            catch (error) {
+                console.log(`📤 ${postprocessor.name}`);
+                console.log(`   PostProcessor ID: ${postprocessor.postprocessorId}`);
+                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 postprocessor information:', error);
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+    }
+}
+/**
+ * View versions for a specific postprocessor
+ */
+async function viewPostProcessorVersions(context, config) {
+    const postprocessors = config.postprocessors || [];
+    if (postprocessors.length === 0) {
+        console.log("\nℹ️  No postprocessors found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selected',
+            message: 'Select a postprocessor to view versions:',
+            choices: postprocessors.map((p) => ({
+                name: `${p.name} (${p.postprocessorId})`,
+                value: p
+            }))
+        }
+    ]);
+    if (!answer)
+        return;
+    const selected = answer.selected;
+    writeProgress(`🔄 Loading versions for ${selected.name}...`);
+    try {
+        const api = new PostProcessorApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await api.getPostProcessorVersions(selected.postprocessorId);
+        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 ${selected.name}.\n`);
+            console.log("💡 Push a version first using 'lua push postprocessor'.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        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 ${selected.name}`);
+        console.log("=".repeat(60) + "\n");
+        sortedVersions.forEach((version) => {
+            const isActive = version.postprocessorId === activeVersionId;
+            const date = new Date(version.createdAt);
+            console.log(`${isActive ? '⭐' : '  '} Version ${version.version}`);
+            console.log(`   Created: ${date.toLocaleString()}`);
+            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 postprocessor version to production
+ */
+async function deployPostProcessorVersion(context, config) {
+    const postprocessors = config.postprocessors || [];
+    if (postprocessors.length === 0) {
+        console.log("\nℹ️  No postprocessors found in configuration.\n");
+        await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+        return;
+    }
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selected',
+            message: 'Select a postprocessor to deploy:',
+            choices: postprocessors.map((p) => ({
+                name: `${p.name} (${p.postprocessorId})`,
+                value: p
+            }))
+        }
+    ]);
+    if (!answer)
+        return;
+    const selected = answer.selected;
+    writeProgress(`🔄 Loading versions for ${selected.name}...`);
+    try {
+        const api = new PostProcessorApi(BASE_URLS.API, context.apiKey, context.agentId);
+        const response = await api.getPostProcessorVersions(selected.postprocessorId);
+        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 ${selected.name}.\n`);
+            console.log("💡 Push a version first using 'lua push postprocessor'.\n");
+            await safePrompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
+            return;
+        }
+        const sortedVersions = versions.sort((a, b) => {
+            const dateA = new Date(a.createdAt).getTime();
+            const dateB = new Date(b.createdAt).getTime();
+            return dateB - dateA;
+        });
+        const versionAnswer = await safePrompt([
+            {
+                type: 'list',
+                name: 'selectedVersion',
+                message: 'Select a version to deploy:',
+                choices: sortedVersions.map((version) => {
+                    const isActive = version.postprocessorId === 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;
+        console.log("\n⚠️  WARNING: You are about to deploy to PRODUCTION!");
+        console.log("⚠️  This will affect ALL users immediately.\n");
+        console.log(`PostProcessor: ${selected.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...");
+        const deployResponse = await api.publishPostProcessorVersion(selected.postprocessorId, 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 postprocessor version');
+        }
+        writeSuccess(`\n✅ Version ${selectedVersion.version} of "${selected.name}" deployed successfully to production\n`);
+        writeInfo("💡 The new version is now active and will process all outgoing responses.");
+        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 postprocessor
+ */
+async function activatePostProcessor(context, config) {
+    const postprocessors = config.postprocessors || [];
+    if (postprocessors.length === 0) {
+        console.log("\nℹ️  No postprocessors found.\n");
+        return;
+    }
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selected',
+            message: 'Select a postprocessor to activate:',
+            choices: postprocessors.map((p) => ({
+                name: `${p.name} (${p.postprocessorId})`,
+                value: p
+            }))
+        }
+    ]);
+    if (!answer)
+        return;
+    writeProgress(`🔄 Activating postprocessor "${answer.selected.name}"...`);
+    const api = new PostProcessorApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await api.activatePostProcessor(answer.selected.postprocessorId);
+    if (response.success) {
+        writeSuccess(`✅ PostProcessor "${answer.selected.name}" activated successfully`);
+        writeInfo("💡 The postprocessor is now enabled and will process all outgoing responses.");
+    }
+    else {
+        console.error(`❌ Failed to activate postprocessor: ${response.error?.message || 'Unknown error'}`);
+    }
+}
+/**
+ * Deactivate a postprocessor
+ */
+async function deactivatePostProcessor(context, config) {
+    const postprocessors = config.postprocessors || [];
+    if (postprocessors.length === 0) {
+        console.log("\nℹ️  No postprocessors found.\n");
+        return;
+    }
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selected',
+            message: 'Select a postprocessor to deactivate:',
+            choices: postprocessors.map((p) => ({
+                name: `${p.name} (${p.postprocessorId})`,
+                value: p
+            }))
+        }
+    ]);
+    if (!answer)
+        return;
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to deactivate "${answer.selected.name}"? Responses will not be postprocessed.`,
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Deactivation cancelled.\n");
+        return;
+    }
+    writeProgress(`🔄 Deactivating postprocessor "${answer.selected.name}"...`);
+    const api = new PostProcessorApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await api.deactivatePostProcessor(answer.selected.postprocessorId);
+    if (response.success) {
+        writeSuccess(`✅ PostProcessor "${answer.selected.name}" deactivated successfully`);
+        writeInfo("💡 The postprocessor is now disabled.");
+    }
+    else {
+        console.error(`❌ Failed to deactivate postprocessor: ${response.error?.message || 'Unknown error'}`);
+    }
+}
+/**
+ * Delete a postprocessor
+ */
+async function deletePostProcessor(context, config) {
+    const postprocessors = config.postprocessors || [];
+    if (postprocessors.length === 0) {
+        console.log("\nℹ️  No postprocessors found.\n");
+        return;
+    }
+    const answer = await safePrompt([
+        {
+            type: 'list',
+            name: 'selected',
+            message: 'Select a postprocessor to delete:',
+            choices: postprocessors.map((p) => ({
+                name: `${p.name} (${p.postprocessorId})`,
+                value: p
+            }))
+        }
+    ]);
+    if (!answer)
+        return;
+    const confirmAnswer = await safePrompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: `⚠️  Are you sure you want to DELETE "${answer.selected.name}"? This cannot be undone.`,
+            default: false
+        }
+    ]);
+    if (!confirmAnswer || !confirmAnswer.confirm) {
+        console.log("\n❌ Deletion cancelled.\n");
+        return;
+    }
+    writeProgress(`🔄 Deleting postprocessor "${answer.selected.name}"...`);
+    const api = new PostProcessorApi(BASE_URLS.API, context.apiKey, context.agentId);
+    const response = await api.deletePostProcessor(answer.selected.postprocessorId);
+    if (response.success) {
+        if (response.data?.deleted) {
+            writeSuccess(`✅ PostProcessor "${answer.selected.name}" deleted successfully`);
+        }
+        else if (response.data?.deactivated) {
+            writeInfo(`⚠️  PostProcessor "${answer.selected.name}" has versions and cannot be deleted. It has been deactivated instead.`);
+        }
+    }
+    else {
+        console.error(`❌ Failed to delete postprocessor: ${response.error?.message || 'Unknown error'}`);
+    }
+}

package/dist/commands/preprocessors.d.ts

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