lua-cli 2.5.8 → 3.0.0-alpha.1

package/dist/cli/command-definitions.js

@@ -2,7 +2,7 @@
  * Command Definitions
  * Centralized command structure for the CLI
  */
-import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand, completionCommand, skillsCommand, featuresCommand } from "../commands/index.js";
+import { configureCommand, initCommand, destroyCommand, apiKeyCommand, compileCommand, testCommand, pushCommand, deployCommand, chatCommand, chatClearCommand, envCommand, personaCommand, productionCommand, resourcesCommand, adminCommand, docsCommand, channelsCommand, logsCommand, completionCommand, skillsCommand, webhooksCommand, jobsCommand, featuresCommand, preprocessorsCommand, postprocessorsCommand } from "../commands/index.js";
 /**
  * Sets up authentication-related commands.
  *
@@ -53,20 +53,32 @@ export function setupSkillCommands(program) {
         .description("📦 Compile skill to deployable format")
         .action(compileCommand);
     program
-        .command("test")
-        .description("🧪 Test skill tools interactively")
+        .command("test [type]")
+        .description("🧪 Test skills, webhooks, or jobs interactively")
+        .addHelpText('after', `
+Arguments:
+  type                   Optional: 'skill', 'webhook', or 'job' (prompts if not provided)
+
+Examples:
+  $ lua test             Interactive selection
+  $ lua test skill       Test a skill/tool directly
+  $ lua test webhook     Test a webhook with query/headers/body
+  $ lua test job         Test a job by executing it
+`)
         .action(testCommand);
     // Deployment Commands
     program
         .command("push [type]")
-        .description("☁️  Push skill or persona version to server")
+        .description("☁️  Push skill, webhook, job, or persona version to server")
         .addHelpText('after', `
 Arguments:
-  type                   Optional: 'skill' or 'persona' (prompts if not provided)
+  type                   Optional: 'skill', 'webhook', 'job', or 'persona' (prompts if not provided)
 
 Examples:
   $ lua push             Interactive selection
   $ lua push skill       Push a skill directly
+  $ lua push webhook     Push a webhook directly
+  $ lua push job         Push a job directly
   $ lua push persona     Push a persona directly
 `)
         .action(pushCommand);
@@ -160,6 +172,34 @@ Examples:
   $ lua skills production      Manage production skills directly
 `)
         .action(skillsCommand);
+    program
+        .command("webhooks [env]")
+        .description("🪝 Manage and view webhooks")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua webhooks                 Interactive selection
+  $ lua webhooks sandbox         View sandbox webhooks directly
+  $ lua webhooks staging         View staging webhooks (alias for sandbox)
+  $ lua webhooks production      Manage production webhooks directly
+`)
+        .action(webhooksCommand);
+    program
+        .command("jobs [env]")
+        .description("⏰ Manage and view scheduled jobs")
+        .addHelpText('after', `
+Arguments:
+  env                    Optional: 'sandbox', 'staging', or 'production' (prompts if not provided)
+
+Examples:
+  $ lua jobs                     Interactive selection
+  $ lua jobs sandbox             View sandbox jobs directly
+  $ lua jobs staging             View staging jobs (alias for sandbox)
+  $ lua jobs production          Manage production jobs (pause/resume/trigger)
+`)
+        .action(jobsCommand);
     program
         .command("features")
         .description("🎯 Manage agent features (tickets, RAG, etc.)")
@@ -174,6 +214,36 @@ Examples:
   $ lua features               View and manage all agent features
 `)
         .action(featuresCommand);
+    program
+        .command("preprocessors")
+        .description("📥 Manage message preprocessors")
+        .addHelpText('after', `
+Features:
+  • View deployed preprocessors
+  • View preprocessor versions
+  • Deploy versions to production
+  • Activate/deactivate preprocessors
+  • Delete preprocessors
+
+Examples:
+  $ lua preprocessors          Manage production preprocessors
+`)
+        .action(preprocessorsCommand);
+    program
+        .command("postprocessors")
+        .description("📤 Manage response postprocessors")
+        .addHelpText('after', `
+Features:
+  • View deployed postprocessors
+  • View postprocessor versions
+  • Deploy versions to production
+  • Activate/deactivate postprocessors
+  • Delete postprocessors
+
+Examples:
+  $ lua postprocessors         Manage production postprocessors
+`)
+        .action(postprocessorsCommand);
     program
         .command("completion [shell]")
         .description("🎯 Generate shell completion script")

package/dist/commands/compile.js

@@ -6,13 +6,18 @@ import fs from "fs";
 import path from "path";
 import { Project } from "ts-morph";
 import { withErrorHandling, writeProgress, writeSuccess } from "../utils/cli.js";
-import { findIndexFile } from '../utils/compile.js';
+import { findIndexFile, extractWebhooksMetadata, extractJobsMetadata, extractPreProcessorsMetadata, extractPostProcessorsMetadata } from '../utils/compile.js';
 import { detectTools } from '../utils/tool-detection.js';
-import { bundleTool, bundleMainIndex, extractExecuteCode } from '../utils/bundling.js';
+import { bundleTool, bundleMainIndex, extractExecuteCode, bundleWebhook, bundleJob, bundlePreProcessor, bundlePostProcessor } from '../utils/bundling.js';
 import { createDeploymentData, createLegacyDeploymentData } from '../utils/deployment.js';
 import { syncYamlWithDeployJson, syncServerSkillsWithYaml } from '../utils/skill-management.js';
+import { ensureWebhooksExistInYaml, syncServerWebhooksWithYaml } from '../utils/webhook-management.js';
+import { ensureJobsExistInYaml, syncServerJobsWithYaml } from '../utils/job-management.js';
+import { ensurePreProcessorsExistInYaml, syncServerPreProcessorsWithYaml } from '../utils/preprocessor-management.js';
+import { ensurePostProcessorsExistInYaml, syncServerPostProcessorsWithYaml } from '../utils/postprocessor-management.js';
 import { readSkillConfig } from '../utils/files.js';
 import { COMPILE_DIRS, COMPILE_FILES } from '../config/compile.constants.js';
+import { syncAgentPersonaWithYaml } from '../utils/agent-management.js';
 /**
  * Main compile command - orchestrates the entire skill compilation process.
  *
@@ -49,7 +54,28 @@ export async function compileCommand() {
         const indexPath = findIndexFile();
         const project = createTypeScriptProject();
         const indexFile = project.addSourceFileAtPath(indexPath);
-        const tools = await detectTools(indexFile, project);
+        // Step 2a: Check for LuaAgent (unified agent configuration)
+        writeProgress("🔍 Checking for LuaAgent configuration...");
+        const { extractLuaAgentMetadata, resolveLuaAgentReferences, getSkillFilePaths } = await import('../utils/compile.js');
+        const agentMetadata = extractLuaAgentMetadata(indexFile);
+        let skillFilePaths = [];
+        let resolvedAgentData = null;
+        if (agentMetadata) {
+            writeProgress(`✨ Found LuaAgent: ${agentMetadata.name}`);
+            writeProgress(`   Using new unified agent configuration approach`);
+            // Sync persona and welcome message with YAML
+            await syncAgentPersonaWithYaml(agentMetadata);
+            // Resolve references to get actual metadata for all components
+            resolvedAgentData = resolveLuaAgentReferences(agentMetadata, indexFile, project);
+            // Get file paths where skills are defined so we can scan them for tools
+            skillFilePaths = getSkillFilePaths(agentMetadata, indexFile);
+            writeProgress(`📦 Agent contains: ${resolvedAgentData.skills.length} skill(s), ${resolvedAgentData.webhooks.length} webhook(s), ${resolvedAgentData.jobs.length} job(s), ${resolvedAgentData.preProcessors.length} preprocessor(s), ${resolvedAgentData.postProcessors.length} postprocessor(s)`);
+        }
+        else {
+            writeProgress(`ℹ️  No LuaAgent found, using legacy detection for individual components`);
+        }
+        // Step 2b: Detect tools from index file and skill files
+        const tools = await detectTools(indexFile, project, skillFilePaths);
         writeProgress(`📦 Found ${tools.length} tools to bundle...`);
         // Step 3: Bundle each tool and extract metadata
         for (const tool of tools) {
@@ -60,7 +86,7 @@ export async function compileCommand() {
         await bundleMainIndex(indexPath, distDir);
         // Step 5: Create deployment data in both formats
         await createDeploymentData(tools, distDir);
-        await createLegacyDeploymentData(tools, luaDir, indexFile);
+        await createLegacyDeploymentData(tools, luaDir, indexFile, resolvedAgentData);
         // Step 6: Sync YAML with deploy.json
         writeProgress("🔄 Syncing YAML with deploy.json...");
         const deployJsonPath = path.join(luaDir, COMPILE_FILES.DEPLOY_JSON);
@@ -70,7 +96,100 @@ export async function compileCommand() {
         writeProgress("🔄 Syncing server with YAML...");
         const updatedConfig = readSkillConfig(); // Re-read config after YAML sync
         await syncServerSkillsWithYaml(updatedConfig);
-        writeSuccess(`✅ Skill compiled successfully - ${tools.length} tools bundled`);
+        // Step 8: Detect and process webhooks
+        writeProgress("🔍 Detecting webhooks...");
+        // Use resolved agent webhooks if available, otherwise scan index file
+        let webhooksMetadata = resolvedAgentData?.webhooks || extractWebhooksMetadata(indexFile);
+        let bundledWebhooks = [];
+        if (webhooksMetadata.length > 0) {
+            writeProgress(`📦 Found ${webhooksMetadata.length} webhook(s)...`);
+            // Bundle each webhook (extract execute function and schemas)
+            for (const webhook of webhooksMetadata) {
+                const bundled = await bundleWebhook(webhook, indexFile, distDir, project);
+                bundledWebhooks.push(bundled);
+            }
+            // Ensure webhooks exist in YAML with valid IDs
+            const configForWebhooks = readSkillConfig(); // Re-read for webhooks
+            await ensureWebhooksExistInYaml(webhooksMetadata, configForWebhooks);
+            // Sync server webhooks with YAML
+            writeProgress("🔄 Syncing server webhooks with YAML...");
+            const webhookConfig = readSkillConfig(); // Re-read after webhook updates
+            await syncServerWebhooksWithYaml(webhookConfig);
+            // Write bundled webhooks to file for reference
+            fs.writeFileSync(path.join(distDir, 'webhooks.json'), JSON.stringify(bundledWebhooks, null, 2));
+        }
+        // Step 9: Detect and process jobs
+        writeProgress("🔍 Detecting jobs...");
+        // Use resolved agent jobs if available, otherwise scan index file
+        let jobsMetadata = resolvedAgentData?.jobs || extractJobsMetadata(indexFile);
+        let bundledJobs = [];
+        if (jobsMetadata.length > 0) {
+            writeProgress(`📦 Found ${jobsMetadata.length} job(s)...`);
+            // Bundle each job (extract execute function)
+            for (const job of jobsMetadata) {
+                const bundled = await bundleJob(job, indexFile, distDir, project);
+                bundledJobs.push(bundled);
+            }
+            // Ensure jobs exist in YAML with valid IDs
+            const configForJobs = readSkillConfig(); // Re-read for jobs
+            await ensureJobsExistInYaml(jobsMetadata, configForJobs);
+            // Sync server jobs with YAML
+            writeProgress("🔄 Syncing server jobs with YAML...");
+            const jobConfig = readSkillConfig(); // Re-read after job updates
+            await syncServerJobsWithYaml(jobConfig);
+            // Write bundled jobs to file for reference
+            fs.writeFileSync(path.join(distDir, 'jobs.json'), JSON.stringify(bundledJobs, null, 2));
+        }
+        // Step 10: Detect and process preprocessors
+        writeProgress("🔍 Detecting preprocessors...");
+        // Use resolved agent preprocessors if available, otherwise scan index file
+        let preprocessorsMetadata = resolvedAgentData?.preProcessors || extractPreProcessorsMetadata(indexFile);
+        let bundledPreProcessors = [];
+        if (preprocessorsMetadata.length > 0) {
+            writeProgress(`📦 Found ${preprocessorsMetadata.length} preprocessor(s)...`);
+            for (const preprocessor of preprocessorsMetadata) {
+                const bundled = await bundlePreProcessor(preprocessor, indexFile, distDir, project);
+                bundledPreProcessors.push(bundled);
+            }
+            // Ensure preprocessors exist in YAML with valid IDs
+            const configForPreProcessors = readSkillConfig();
+            await ensurePreProcessorsExistInYaml(preprocessorsMetadata, configForPreProcessors);
+            // Sync server preprocessors with YAML
+            writeProgress("🔄 Syncing server preprocessors with YAML...");
+            const preprocessorConfig = readSkillConfig();
+            await syncServerPreProcessorsWithYaml(preprocessorConfig);
+            fs.writeFileSync(path.join(distDir, 'preprocessors.json'), JSON.stringify(bundledPreProcessors, null, 2));
+        }
+        // Step 11: Detect and process postprocessors
+        writeProgress("🔍 Detecting postprocessors...");
+        // Use resolved agent postprocessors if available, otherwise scan index file
+        let postprocessorsMetadata = resolvedAgentData?.postProcessors || extractPostProcessorsMetadata(indexFile);
+        let bundledPostProcessors = [];
+        if (postprocessorsMetadata.length > 0) {
+            writeProgress(`📦 Found ${postprocessorsMetadata.length} postprocessor(s)...`);
+            for (const postprocessor of postprocessorsMetadata) {
+                const bundled = await bundlePostProcessor(postprocessor, indexFile, distDir, project);
+                bundledPostProcessors.push(bundled);
+            }
+            // Ensure postprocessors exist in YAML with valid IDs
+            const configForPostProcessors = readSkillConfig();
+            await ensurePostProcessorsExistInYaml(postprocessorsMetadata, configForPostProcessors);
+            // Sync server postprocessors with YAML
+            writeProgress("🔄 Syncing server postprocessors with YAML...");
+            const postprocessorConfig = readSkillConfig();
+            await syncServerPostProcessorsWithYaml(postprocessorConfig);
+            fs.writeFileSync(path.join(distDir, 'postprocessors.json'), JSON.stringify(bundledPostProcessors, null, 2));
+        }
+        const summaryParts = [`${tools.length} tools bundled`];
+        if (webhooksMetadata.length > 0)
+            summaryParts.push(`${webhooksMetadata.length} webhook(s) registered`);
+        if (jobsMetadata.length > 0)
+            summaryParts.push(`${jobsMetadata.length} job(s) registered`);
+        if (preprocessorsMetadata.length > 0)
+            summaryParts.push(`${preprocessorsMetadata.length} preprocessor(s) registered`);
+        if (postprocessorsMetadata.length > 0)
+            summaryParts.push(`${postprocessorsMetadata.length} postprocessor(s) registered`);
+        writeSuccess(`✅ Skill compiled successfully - ${summaryParts.join(', ')}`);
     }, "compilation");
 }
 /**

package/dist/commands/index.d.ts

@@ -19,4 +19,8 @@ export { channelsCommand } from "./channels.js";
 export { logsCommand } from "./logs.js";
 export { completionCommand } from "./completion.js";
 export { skillsCommand } from "./skills.js";
+export { webhooksCommand } from "./webhooks.js";
+export { jobsCommand } from "./jobs.js";
 export { featuresCommand } from "./features.js";
+export { preprocessorsCommand } from "./preprocessors.js";
+export { postprocessorsCommand } from "./postprocessors.js";

package/dist/commands/index.js

@@ -19,4 +19,8 @@ export { channelsCommand } from "./channels.js";
 export { logsCommand } from "./logs.js";
 export { completionCommand } from "./completion.js";
 export { skillsCommand } from "./skills.js";
+export { webhooksCommand } from "./webhooks.js";
+export { jobsCommand } from "./jobs.js";
 export { featuresCommand } from "./features.js";
+export { preprocessorsCommand } from "./preprocessors.js";
+export { postprocessorsCommand } from "./postprocessors.js";

package/dist/commands/init.js

@@ -119,7 +119,7 @@ export async function initCommand() {
         }
         else {
             // Step 4b: Create new agent
-            const result = await createNewAgentFlow(apiKey);
+            const result = await createNewAgentFlow(apiKey, userData);
             selectedAgent = result.agent;
             selectedOrg = result.org;
             persona = result.persona;
@@ -172,14 +172,59 @@ async function selectExistingAgent(userData, apiKey) {
  * Handles the flow for creating a new agent.
  *
  * @param apiKey - User's API key
+ * @param userData - User data containing organizations
  * @returns Created agent, organization, and optional persona/welcome message
  */
-async function createNewAgentFlow(apiKey) {
+async function createNewAgentFlow(apiKey, userData) {
     // Fetch and select agent type
     const agentTypes = await fetchAgentTypes(apiKey);
     const selectedAgentType = selectBaseAgentType(agentTypes);
+    // Ask about organization selection FIRST
+    const { orgChoice } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'orgChoice',
+            message: 'Organization:',
+            choices: [
+                { name: '🏢 Use existing organization', value: 'existing' },
+                { name: '➕ Create new organization', value: 'create' }
+            ]
+        }
+    ]);
+    let orgId;
+    let orgName;
+    let usingExistingOrg = false;
+    if (orgChoice === 'existing') {
+        // Select from existing organizations
+        const orgs = userData.admin?.orgs || [];
+        if (orgs.length === 0) {
+            writeInfo("\n⚠️  No existing organizations found. Creating new organization instead.\n");
+        }
+        else {
+            const selectedOrg = await promptOrganizationSelection(orgs);
+            orgId = selectedOrg.id;
+            usingExistingOrg = true;
+        }
+    }
+    if (!orgId) {
+        // Create new organization - ask for org name
+        const { organizationName } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'organizationName',
+                message: 'Organization name:',
+                validate: (input) => {
+                    if (!input || input.trim() === '') {
+                        return 'Organization name is required';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        orgName = organizationName.trim();
+    }
     // Collect required metadata
-    let linesToClear = 1;
+    let linesToClear = 2; // orgChoice + (org selection OR org name)
     const metadata = selectedAgentType.requiredSubAgentMetadata?.length
         ? await promptMetadataCollection(selectedAgentType.requiredSubAgentMetadata)
         : {};
@@ -190,12 +235,13 @@ async function createNewAgentFlow(apiKey) {
         : {};
     linesToClear += availableFeatures.length;
     // Collect business configuration
-    const businessConfig = await promptBusinessConfiguration();
-    linesToClear += 5; // businessName, agentName, businessType, brandPersonality, brandTraits
+    // If using existing org, don't ask for business name (use org name)
+    const businessConfig = await promptBusinessConfiguration(usingExistingOrg);
+    linesToClear += usingExistingOrg ? 4 : 5; // Skip businessName prompt if using existing org
     // Clear all prompts
     clearLinesIfNeeded(linesToClear);
     // Create the agent
-    const result = await createNewAgent(apiKey, selectedAgentType, businessConfig, metadata, features);
+    const result = await createNewAgent(apiKey, selectedAgentType, businessConfig, metadata, features, orgId, orgName);
     return result;
 }
 /**
@@ -232,7 +278,7 @@ async function handleAgentSwitch(userData, apiKey, existingYaml) {
     }
     else {
         // Create new agent
-        const result = await createNewAgentFlow(apiKey);
+        const result = await createNewAgentFlow(apiKey, userData);
         selectedAgent = result.agent;
         selectedOrg = result.org;
         persona = result.persona;

package/dist/commands/jobs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Jobs Command
+ * Manages agent scheduled jobs for sandbox and production environments
+ */
+/**
+ * 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 declare function jobsCommand(): Promise<void>;