lua-cli 2.5.8 → 3.0.0-alpha.10

package/dist/utils/deployment.d.ts

@@ -21,5 +21,6 @@ export declare function createDeploymentData(tools: ToolInfo[], distDir: string)
  * @param tools - Array of detected tools
  * @param luaDir - Legacy .lua directory for output
  * @param indexFile - The TypeScript source file for the index
+ * @param agentData - Optional resolved agent data from LuaAgent (for new approach)
  */
-export declare function createLegacyDeploymentData(tools: ToolInfo[], luaDir: string, indexFile: TypeScriptSourceFile): Promise<void>;
+export declare function createLegacyDeploymentData(tools: ToolInfo[], luaDir: string, indexFile: TypeScriptSourceFile, agentData?: any): Promise<void>;

package/dist/utils/deployment.js

@@ -52,10 +52,24 @@ function readPackageJson() {
  * @param tools - Array of detected tools
  * @param luaDir - Legacy .lua directory for output
  * @param indexFile - The TypeScript source file for the index
+ * @param agentData - Optional resolved agent data from LuaAgent (for new approach)
  */
-export async function createLegacyDeploymentData(tools, luaDir, indexFile) {
+export async function createLegacyDeploymentData(tools, luaDir, indexFile, agentData) {
     const config = readSkillConfig();
-    const skillsMetadata = extractSkillsMetadata(indexFile);
+    let skillsMetadata;
+    // Check if we have agent data (from LuaAgent approach)
+    if (agentData && agentData.skills && agentData.skills.length > 0) {
+        // Use skills from LuaAgent
+        // Map 'tools' to 'constructorTools' for compatibility with buildSkillsArray
+        skillsMetadata = agentData.skills.map((skill) => ({
+            ...skill,
+            constructorTools: skill.tools || []
+        }));
+    }
+    else {
+        // Fall back to legacy approach - extract from index file
+        skillsMetadata = extractSkillsMetadata(indexFile);
+    }
     // Map tools to their parent skills
     const skillToTools = mapToolsToSkills(indexFile);
     // Build skills array with their associated tools

package/dist/utils/dev-api.d.ts

@@ -4,7 +4,7 @@
  */
 import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../interfaces/dev.js';
 /**
- * Sends a chat message to the API with skill override for sandbox testing.
+ * Sends a chat message to the API with skill and processor overrides for sandbox testing.
  *
  * @param apiKey - User's API key
  * @param agentId - Agent ID
@@ -13,9 +13,10 @@ import { DevVersionResponse, UpdateDevVersionResponse, SandboxIdsMap } from '../
  * @param message - Message to send
  * @param persona - Optional persona override
  * @param deployData - Deploy data containing all skills
+ * @param config - Optional config for processor overrides
  * @returns The chat response text or null if failed
  */
-export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any): Promise<string | null>;
+export declare function sendChatMessage(apiKey: string, agentId: string, skillId: string, sandboxId: string, message: string, persona: string | undefined, deployData: any, config?: any): Promise<string | null>;
 /**
  * Updates an existing sandbox version.
  *
@@ -59,3 +60,42 @@ export declare function pushSingleSkillToSandbox(apiKey: string, agentId: string
  * @returns Map of skill names to their sandbox IDs
  */
 export declare function pushSkillsToSandbox(apiKey: string, agentId: string, deployData: any, isInitial?: boolean): Promise<SandboxIdsMap>;
+/**
+ * Pushes a single preprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param preprocessorId - PreProcessor ID
+ * @param preprocessorData - PreProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSinglePreProcessorToSandbox(apiKey: string, agentId: string, preprocessorId: string, preprocessorData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes a single postprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param postprocessorId - PostProcessor ID
+ * @param postprocessorData - PostProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export declare function pushSinglePostProcessorToSandbox(apiKey: string, agentId: string, postprocessorId: string, postprocessorData: any, isInitial?: boolean): Promise<boolean>;
+/**
+ * Pushes preprocessors and postprocessors to sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param config - Configuration with preprocessors and postprocessors
+ * @param bundledPreProcessors - Bundled preprocessor data from compilation
+ * @param bundledPostProcessors - Bundled postprocessor data from compilation
+ * @param isInitial - Whether this is the initial push
+ * @returns Object with counts of pushed processors
+ */
+export declare function pushProcessorsToSandbox(apiKey: string, agentId: string, config: any, bundledPreProcessors: any[], bundledPostProcessors: any[], isInitial?: boolean): Promise<{
+    preprocessors: number;
+    postprocessors: number;
+}>;

package/dist/utils/dev-api.js

@@ -4,12 +4,14 @@
  */
 import ChatApi from '../api/chat.api.service.js';
 import SkillApi from '../api/skills.api.service.js';
+import PreProcessorApi from '../api/preprocessor.api.service.js';
+import PostProcessorApi from '../api/postprocessor.api.service.js';
 import { BASE_URLS } from '../config/constants.js';
 import { writeProgress, writeSuccess } from './cli.js';
 import { loadEnvironmentVariables } from './sandbox.js';
-import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './sandbox-storage.js';
+import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds, getSandboxPreProcessorId, setSandboxPreProcessorId, getSandboxPostProcessorId, setSandboxPostProcessorId } from './sandbox-storage.js';
 /**
- * Sends a chat message to the API with skill override for sandbox testing.
+ * Sends a chat message to the API with skill and processor overrides for sandbox testing.
  *
  * @param apiKey - User's API key
  * @param agentId - Agent ID
@@ -18,9 +20,10 @@ import { getSandboxSkillId, setSandboxSkillId, getAllSandboxSkillIds } from './s
  * @param message - Message to send
  * @param persona - Optional persona override
  * @param deployData - Deploy data containing all skills
+ * @param config - Optional config for processor overrides
  * @returns The chat response text or null if failed
  */
-export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData) {
+export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData, config) {
     try {
         // Get all sandbox skill IDs for skill override
         const allSkillOverrides = await getAllSandboxSkillIds(deployData);
@@ -31,6 +34,10 @@ export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, messa
                 sandboxId: sandboxId
             }
         ];
+        // Get sandbox processor overrides if config provided
+        const { getAllSandboxPreProcessorIds, getAllSandboxPostProcessorIds } = await import('./sandbox-storage.js');
+        const preprocessorOverride = config ? await getAllSandboxPreProcessorIds(config) : [];
+        const postprocessorOverride = config ? await getAllSandboxPostProcessorIds(config) : [];
         const chatRequest = {
             messages: [
                 {
@@ -39,7 +46,9 @@ export async function sendChatMessage(apiKey, agentId, skillId, sandboxId, messa
                 }
             ],
             navigate: true,
-            skillOverride: skillOverride
+            skillOverride: skillOverride,
+            preprocessorOverride: preprocessorOverride,
+            postprocessorOverride: postprocessorOverride
         };
         // Add persona override if provided
         if (persona) {
@@ -260,3 +269,167 @@ export async function pushSkillsToSandbox(apiKey, agentId, deployData, isInitial
     }
     return sandboxIds;
 }
+/**
+ * Pushes a single preprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param preprocessorId - PreProcessor ID
+ * @param preprocessorData - PreProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSinglePreProcessorToSandbox(apiKey, agentId, preprocessorId, preprocessorData, isInitial = false) {
+    const preprocessorName = preprocessorData.name || 'Unknown PreProcessor';
+    const sandboxPreProcessorId = await getSandboxPreProcessorId(preprocessorName);
+    // Ensure version has -sandbox postfix
+    const baseVersion = preprocessorData.version || '1.0.0';
+    const sandboxVersion = baseVersion.endsWith('-sandbox') ? baseVersion : `${baseVersion}-sandbox`;
+    const payload = {
+        name: preprocessorName,
+        version: sandboxVersion,
+        description: preprocessorData.description,
+        context: preprocessorData.context,
+        code: preprocessorData.code,
+        executeFunction: preprocessorData.executeFunction,
+        async: Boolean(preprocessorData.async ?? false)
+    };
+    if (sandboxPreProcessorId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress(`🔄 Updating existing preprocessor sandbox version...`);
+        }
+        const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const updateResult = await api.updateDevPreProcessor(preprocessorId, sandboxPreProcessorId, payload);
+        if (updateResult.success && updateResult.data) {
+            return true;
+        }
+        else {
+            if (!isInitial) {
+                writeProgress("⚠️  Failed to update preprocessor sandbox, creating new one...");
+            }
+        }
+    }
+    // Create new sandbox version
+    if (!isInitial) {
+        writeProgress(`🔄 Creating new preprocessor sandbox version...`);
+    }
+    const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+    const result = await api.pushDevPreProcessor(preprocessorId, payload);
+    if (result.success && result.data) {
+        // Store the new sandbox preprocessor ID
+        await setSandboxPreProcessorId(result.data.versionId, preprocessorName);
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ PreProcessor sandbox push failed: ${result.error.message}`);
+        return false;
+    }
+    return false;
+}
+/**
+ * Pushes a single postprocessor to the sandbox.
+ * Attempts to update existing sandbox version, creates new one if update fails.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param postprocessorId - PostProcessor ID
+ * @param postprocessorData - PostProcessor data to push
+ * @param isInitial - Whether this is the initial push (affects logging)
+ * @returns True if successful, false otherwise
+ */
+export async function pushSinglePostProcessorToSandbox(apiKey, agentId, postprocessorId, postprocessorData, isInitial = false) {
+    const postprocessorName = postprocessorData.name || 'Unknown PostProcessor';
+    const sandboxPostProcessorId = await getSandboxPostProcessorId(postprocessorName);
+    // Ensure version has -sandbox postfix
+    const baseVersion = postprocessorData.version || '1.0.0';
+    const sandboxVersion = baseVersion.endsWith('-sandbox') ? baseVersion : `${baseVersion}-sandbox`;
+    const payload = {
+        name: postprocessorName,
+        version: sandboxVersion,
+        description: postprocessorData.description,
+        context: postprocessorData.context,
+        code: postprocessorData.code,
+        executeFunction: postprocessorData.executeFunction,
+        async: Boolean(postprocessorData.async ?? false)
+    };
+    if (sandboxPostProcessorId) {
+        // Try to update existing sandbox version
+        if (!isInitial) {
+            writeProgress(`🔄 Updating existing postprocessor sandbox version...`);
+        }
+        const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const updateResult = await api.updateDevPostProcessor(postprocessorId, sandboxPostProcessorId, payload);
+        if (updateResult.success && updateResult.data) {
+            return true;
+        }
+        else {
+            if (!isInitial) {
+                writeProgress("⚠️  Failed to update postprocessor sandbox, creating new one...");
+            }
+        }
+    }
+    // Create new sandbox version
+    if (!isInitial) {
+        writeProgress(`🔄 Creating new postprocessor sandbox version...`);
+    }
+    const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+    const result = await api.pushDevPostProcessor(postprocessorId, payload);
+    if (result.success && result.data) {
+        // Store the new sandbox postprocessor ID
+        await setSandboxPostProcessorId(result.data.versionId, postprocessorName);
+        return true;
+    }
+    else if (result.error) {
+        console.error(`❌ PostProcessor sandbox push failed: ${result.error.message}`);
+        return false;
+    }
+    return false;
+}
+/**
+ * Pushes preprocessors and postprocessors to sandbox.
+ *
+ * @param apiKey - User's API key
+ * @param agentId - Agent ID
+ * @param config - Configuration with preprocessors and postprocessors
+ * @param bundledPreProcessors - Bundled preprocessor data from compilation
+ * @param bundledPostProcessors - Bundled postprocessor data from compilation
+ * @param isInitial - Whether this is the initial push
+ * @returns Object with counts of pushed processors
+ */
+export async function pushProcessorsToSandbox(apiKey, agentId, config, bundledPreProcessors, bundledPostProcessors, isInitial = false) {
+    let preprocessorCount = 0;
+    let postprocessorCount = 0;
+    // Push preprocessors
+    const configPreProcessors = config.preprocessors || [];
+    for (const preprocessor of configPreProcessors) {
+        const bundled = bundledPreProcessors.find(p => p.name === preprocessor.name);
+        if (bundled && bundled.code && preprocessor.preprocessorId) {
+            try {
+                const success = await pushSinglePreProcessorToSandbox(apiKey, agentId, preprocessor.preprocessorId, bundled, isInitial);
+                if (success)
+                    preprocessorCount++;
+            }
+            catch (error) {
+                console.error(`❌ Failed to push preprocessor ${preprocessor.name}:`, error);
+            }
+        }
+    }
+    // Push postprocessors
+    const configPostProcessors = config.postprocessors || [];
+    for (const postprocessor of configPostProcessors) {
+        const bundled = bundledPostProcessors.find(p => p.name === postprocessor.name);
+        if (bundled && bundled.code && postprocessor.postprocessorId) {
+            try {
+                const success = await pushSinglePostProcessorToSandbox(apiKey, agentId, postprocessor.postprocessorId, bundled, isInitial);
+                if (success)
+                    postprocessorCount++;
+            }
+            catch (error) {
+                console.error(`❌ Failed to push postprocessor ${postprocessor.name}:`, error);
+            }
+        }
+    }
+    return { preprocessors: preprocessorCount, postprocessors: postprocessorCount };
+}

package/dist/utils/dev-server.d.ts

@@ -21,4 +21,4 @@ export interface DevServer {
  * @param port - Port to run server on
  * @returns Server instance with WebSocket and broadcast function
  */
-export declare function createChatServer(apiKey: string, agentId: string, skillId: string, sandboxId: string, port: number): DevServer;
+export declare function createChatServer(apiKey: string, agentId: string, skillId: string, sandboxId: string, port: number, config?: any): DevServer;

package/dist/utils/dev-server.js

@@ -42,7 +42,7 @@ function readDeployJson() {
  * @param port - Port to run server on
  * @returns Server instance with WebSocket and broadcast function
  */
-export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
+export function createChatServer(apiKey, agentId, skillId, sandboxId, port, config) {
     const deployData = readDeployJson();
     const server = createServer((req, res) => {
         // Enable CORS
@@ -56,7 +56,7 @@ export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
         }
         // Route handlers
         if (req.method === 'POST' && req.url === '/chat') {
-            handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData);
+            handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData, config);
             return;
         }
         if (req.method === 'GET' && req.url === '/persona') {
@@ -173,7 +173,7 @@ export function createChatServer(apiKey, agentId, skillId, sandboxId, port) {
 /**
  * Handles POST /chat - Send chat messages
  */
-function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData) {
+function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deployData, config) {
     let body = '';
     req.on('data', (chunk) => {
         body += chunk.toString();
@@ -181,7 +181,7 @@ function handleChatEndpoint(req, res, apiKey, agentId, skillId, sandboxId, deplo
     req.on('end', async () => {
         try {
             const { message, persona } = JSON.parse(body);
-            const response = await sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData);
+            const response = await sendChatMessage(apiKey, agentId, skillId, sandboxId, message, persona, deployData, config);
             res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
                 success: response !== null,

package/dist/utils/dynamic-job-bundler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Dynamic Job Bundler
+ * Handles detection and bundling of Jobs.create() calls within execute functions
+ */
+/**
+ * Detects if code contains Jobs.create() calls
+ */
+export declare function containsJobsCreate(code: string): boolean;
+/**
+ * Extracts Jobs.create() execute functions and bundles them with dependencies.
+ * Finds execute functions in the code and creates standalone bundles.
+ */
+export declare function bundleNestedJobs(code: string, parentName: string, distDir: string): Promise<string>;
+/**
+ * Cleans up temporary bundling directory
+ */
+export declare function cleanupTempDir(distDir: string): void;

package/dist/utils/dynamic-job-bundler.js

@@ -0,0 +1,143 @@
+/**
+ * Dynamic Job Bundler
+ * Handles detection and bundling of Jobs.create() calls within execute functions
+ */
+import { build } from 'esbuild';
+import fs from 'fs';
+import path from 'path';
+import { compressCode } from './compile.js';
+import { sandboxGlobalsPlugin } from './bundling.js';
+/**
+ * Detects if code contains Jobs.create() calls
+ */
+export function containsJobsCreate(code) {
+    const found = /Jobs\.create\s*\(/i.test(code);
+    if (found) {
+        console.log('[DynamicJobs] ✅ Detected Jobs.create() in code');
+    }
+    return found;
+}
+/**
+ * Extracts Jobs.create() execute functions and bundles them with dependencies.
+ * Finds execute functions in the code and creates standalone bundles.
+ */
+export async function bundleNestedJobs(code, parentName, distDir) {
+    if (!containsJobsCreate(code)) {
+        return code;
+    }
+    console.log(`[DynamicJobs] ⚠️  Jobs.create() with external dependencies not yet fully supported`);
+    console.log(`[DynamicJobs] 💡 Recommendation: Use fetch() or lua-cli APIs in job execute functions`);
+    console.log(`[DynamicJobs] 📋 Full bundling support planned for v3.1.0`);
+    // Return original code as-is
+    // The job will have access to lua-cli globals but external packages won't be bundled
+    return code;
+}
+/**
+ * Helper to extract job execute function from code
+ */
+function extractJobExecuteFromCode(code) {
+    // This extracts the execute function body
+    // For now, return a placeholder that indicates the limitation
+    return `
+    // Note: This job execute function runs with limited context
+    // Use fetch() for external APIs or lua-cli globals (User, Data, Products)
+    console.log('Job execute running with user:', user);
+    return { executed: true };
+  `;
+}
+/**
+ * Bundles a job's execute function independently
+ */
+async function bundleJobExecuteFunction(executeFunction, jobName, distDir) {
+    const tempDir = path.join(distDir, '.temp');
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    const tempFile = path.join(tempDir, `${jobName}.js`);
+    const tempOutput = path.join(tempDir, `${jobName}-bundled.js`);
+    try {
+        // Extract imports that the execute function might need
+        // Common ones: Stripe, axios, etc.
+        const moduleCode = `
+// Job execute function for ${jobName}
+// Import dependencies that might be used
+import Stripe from 'stripe';
+import { env, User, Data, Products, Baskets, Orders } from 'lua-cli';
+
+// The execute function with all dependencies available
+const executeFunc = ${executeFunction};
+
+// Export as default for esbuild to bundle
+export default executeFunc;
+`;
+        fs.writeFileSync(tempFile, moduleCode);
+        // Bundle with esbuild - bundle ALL dependencies (including Stripe, axios, etc.)
+        await build({
+            entryPoints: [tempFile],
+            bundle: true,
+            platform: 'node',
+            target: 'node16',
+            format: 'cjs',
+            minify: true,
+            outfile: tempOutput,
+            external: [], // Bundle everything except lua-cli APIs (handled by plugin)
+            plugins: [sandboxGlobalsPlugin], // This handles lua-cli globals
+            // Important: Don't externalize packages like stripe, axios, etc.
+            // They need to be included in the bundle
+        });
+        // Read bundled code (includes all dependencies like Stripe, axios, etc.)
+        let bundledCode = fs.readFileSync(tempOutput, 'utf8');
+        // Log bundle size for debugging
+        console.log(`[DynamicJobs] Bundled size for ${jobName}: ${(bundledCode.length / 1024).toFixed(2)}KB`);
+        // Wrap for VM execution - the bundled code includes ALL dependencies
+        const wrappedCode = `(async (job) => {
+ 
+  ${bundledCode}
+  
+  // Get the execute function from exports
+  const executeFunction = module.exports || module.exports.default;
+  
+  // Execute with job
+  return await executeFunction(job);
+})`;
+        // Compress the wrapped code
+        const compressed = compressCode(wrappedCode);
+        // Clean up temp files
+        try {
+            fs.unlinkSync(tempFile);
+            fs.unlinkSync(tempOutput);
+        }
+        catch (cleanupError) {
+            // Ignore cleanup errors
+        }
+        return compressed;
+    }
+    catch (error) {
+        console.warn(`Warning: Could not bundle job execute function ${jobName}:`, error);
+        // Clean up on error
+        try {
+            if (fs.existsSync(tempFile))
+                fs.unlinkSync(tempFile);
+            if (fs.existsSync(tempOutput))
+                fs.unlinkSync(tempOutput);
+        }
+        catch (cleanupError) {
+            // Ignore cleanup errors
+        }
+        return '';
+    }
+}
+/**
+ * Cleans up temporary bundling directory
+ */
+export function cleanupTempDir(distDir) {
+    const tempDir = path.join(distDir, '.temp');
+    if (fs.existsSync(tempDir)) {
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            // Ignore cleanup errors
+        }
+    }
+}

package/dist/utils/init-agent.d.ts

@@ -28,10 +28,12 @@ export declare function selectBaseAgentType(agentTypes: AgentType[]): AgentType;
  * @param businessConfig - Business configuration
  * @param metadata - Agent metadata
  * @param features - Feature configuration
+ * @param existingOrgId - Optional existing organization ID to use
+ * @param newOrgName - Optional new organization name (if not using existing)
  * @returns Agent creation result with agent and org details
  * @throws Error if agent creation fails
  */
-export declare function createNewAgent(apiKey: string, agentType: AgentType, businessConfig: BusinessConfig, metadata: Record<string, any>, features: Record<string, boolean>): Promise<AgentCreationResult>;
+export declare function createNewAgent(apiKey: string, agentType: AgentType, businessConfig: BusinessConfig, metadata: Record<string, any>, features: Record<string, boolean>, existingOrgId?: string, newOrgName?: string): Promise<AgentCreationResult>;
 /**
  * Fetches detailed agent information for an existing agent.
  * Used when selecting an existing agent during init.

package/dist/utils/init-agent.js

@@ -50,10 +50,12 @@ export function selectBaseAgentType(agentTypes) {
  * @param businessConfig - Business configuration
  * @param metadata - Agent metadata
  * @param features - Feature configuration
+ * @param existingOrgId - Optional existing organization ID to use
+ * @param newOrgName - Optional new organization name (if not using existing)
  * @returns Agent creation result with agent and org details
  * @throws Error if agent creation fails
  */
-export async function createNewAgent(apiKey, agentType, businessConfig, metadata, features) {
+export async function createNewAgent(apiKey, agentType, businessConfig, metadata, features, existingOrgId, newOrgName) {
     writeProgress("🔄 Creating agent...");
     const agentData = {
         id: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
@@ -67,9 +69,9 @@ export async function createNewAgent(apiKey, agentType, businessConfig, metadata
         },
         features,
         channels: [],
-        org: {
-            registeredName: businessConfig.businessName
-        }
+        org: existingOrgId
+            ? { id: existingOrgId } // Use existing org
+            : { registeredName: newOrgName || businessConfig.businessName } // Create new org
     };
     const agentApi = new AgentApi(BASE_URLS.API, apiKey);
     const createAgentResult = await agentApi.createAgent(agentData);

package/dist/utils/init-prompts.d.ts

@@ -42,6 +42,7 @@ export declare function promptFeatureConfiguration(agentType: AgentType): Promis
  * Prompts for business and agent configuration.
  * Collects business name, agent name, type, personality, and traits.
  *
+ * @param skipBusinessName - If true, skips business name prompt (for existing orgs)
  * @returns Complete business configuration
  */
-export declare function promptBusinessConfiguration(): Promise<BusinessConfig>;
+export declare function promptBusinessConfiguration(skipBusinessName?: boolean): Promise<BusinessConfig>;

package/dist/utils/init-prompts.js

@@ -115,17 +115,22 @@ export async function promptFeatureConfiguration(agentType) {
  * Prompts for business and agent configuration.
  * Collects business name, agent name, type, personality, and traits.
  *
+ * @param skipBusinessName - If true, skips business name prompt (for existing orgs)
  * @returns Complete business configuration
  */
-export async function promptBusinessConfiguration() {
-    const { businessName } = await inquirer.prompt([
-        {
-            type: "input",
-            name: "businessName",
-            message: "Enter business name:",
-            default: DEFAULT_BUSINESS_NAME
-        }
-    ]);
+export async function promptBusinessConfiguration(skipBusinessName = false) {
+    let businessName = DEFAULT_BUSINESS_NAME;
+    if (!skipBusinessName) {
+        const result = await inquirer.prompt([
+            {
+                type: "input",
+                name: "businessName",
+                message: "Enter business name:",
+                default: DEFAULT_BUSINESS_NAME
+            }
+        ]);
+        businessName = result.businessName;
+    }
     const { agentName } = await inquirer.prompt([
         {
             type: "input",

package/dist/utils/job-management.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Job Management Utilities
+ * Handles job creation via API and YAML configuration management
+ */
+import { SkillConfig } from '../types/compile.types.js';
+/**
+ * Ensures all detected jobs exist in the YAML config with valid job IDs.
+ * If a job doesn't exist or has no ID, creates it via the API.
+ *
+ * @param jobsArray - Array of jobs detected from source code
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated jobs array with valid job IDs
+ */
+export declare function ensureJobsExistInYaml(jobsArray: any[], config: SkillConfig): Promise<any[]>;
+/**
+ * Syncs the server jobs with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates jobs from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export declare function syncServerJobsWithYaml(config: SkillConfig): Promise<string[]>;