lua-cli 3.0.0-alpha.4 → 3.0.0-alpha.6

package/dist/cli/command-definitions.js

@@ -70,16 +70,23 @@ Examples:
     program
         .command("push [type]")
         .description("☁️  Push skill, webhook, job, or persona version to server")
+        .option('--force', 'Skip all confirmation prompts (auto-confirm)')
+        .option('--auto-deploy', 'Automatically deploy to production after push')
         .addHelpText('after', `
 Arguments:
-  type                   Optional: 'skill', 'webhook', 'job', or 'persona' (prompts if not provided)
+  type                   Optional: 'skill', 'webhook', 'job', 'preprocessor', 'postprocessor', 'persona', or 'all' (prompts if not provided)
+
+Options:
+  --force                Skip all confirmation prompts
+  --auto-deploy          Automatically deploy to production after push
 
 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
+  $ 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 all --force            Push all components from YAML without prompts
+  $ lua push all --force --auto-deploy   Push and deploy all to production
 `)
         .action(pushCommand);
     program

package/dist/commands/push.d.ts

@@ -17,7 +17,8 @@
  *
  * Note: This does NOT deploy to production. Use `lua deploy` for that.
  *
- * @param type - Optional type argument ('skill' or 'persona')
+ * @param type - Optional type argument ('skill', 'persona', 'webhook', 'job', 'preprocessor', 'postprocessor', or 'all')
+ * @param cmdObj - Commander command object with options
  * @returns Promise that resolves when push completes
  */
-export declare function pushCommand(type?: string): Promise<void>;
+export declare function pushCommand(type?: string, cmdObj?: any): Promise<void>;

package/dist/commands/push.js

@@ -31,17 +31,34 @@ import PostProcessorApi from '../api/postprocessor.api.service.js';
  *
  * Note: This does NOT deploy to production. Use `lua deploy` for that.
  *
- * @param type - Optional type argument ('skill' or 'persona')
+ * @param type - Optional type argument ('skill', 'persona', 'webhook', 'job', 'preprocessor', 'postprocessor', or 'all')
+ * @param cmdObj - Commander command object with options
  * @returns Promise that resolves when push completes
  */
-export async function pushCommand(type) {
+export async function pushCommand(type, cmdObj) {
     return withErrorHandling(async () => {
+        // Extract options from Commander command object
+        const options = {
+            force: cmdObj?.force || false,
+            autoDeploy: cmdObj?.autoDeploy || false
+        };
         let selectedType;
+        // Handle 'all' type with force flag
+        if (type === 'all') {
+            if (!options.force) {
+                console.error('❌ The "all" type requires the --force flag');
+                console.log('\nUsage:');
+                console.log('  lua push all --force                Push all components without prompts');
+                console.log('  lua push all --force --auto-deploy  Push and deploy all to production');
+                process.exit(1);
+            }
+            return await pushAllCommand(options);
+        }
         // Step 1: Check if type was provided as argument
         if (type) {
             // Validate the provided type
             if (type !== 'skill' && type !== 'persona' && type !== 'webhook' && type !== 'job' && type !== 'preprocessor' && type !== 'postprocessor') {
-                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", or "postprocessor".`);
+                console.error(`❌ Invalid type: "${type}". Must be "skill", "persona", "webhook", "job", "preprocessor", "postprocessor", or "all".`);
                 console.log('\nUsage:');
                 console.log('  lua push                - Interactive selection');
                 console.log('  lua push skill          - Push a skill directly');
@@ -50,6 +67,7 @@ export async function pushCommand(type) {
                 console.log('  lua push job            - Push a job directly');
                 console.log('  lua push preprocessor   - Push a preprocessor directly');
                 console.log('  lua push postprocessor  - Push a postprocessor directly');
+                console.log('  lua push all --force    - Push all components without prompts');
                 process.exit(1);
             }
             selectedType = type;
@@ -1031,3 +1049,518 @@ async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVers
         console.log('💡 You can deploy later using: lua deploy\n');
     }
 }
+/**
+ * Push all command - Pushes all components (skills, webhooks, jobs, processors) without prompts
+ *
+ * This command:
+ * 1. Compiles the project
+ * 2. Reads lua.skill.yaml to get all components
+ * 3. Auto-bumps patch versions
+ * 4. Pushes all components
+ * 5. Optionally auto-deploys to production
+ *
+ * @param options - Command options (force is required, autoDeploy is optional)
+ */
+async function pushAllCommand(options) {
+    writeProgress("🚀 Push All - Pushing all components to server...\n");
+    if (options.autoDeploy) {
+        writeInfo("🚀 Auto-deploy to production is ENABLED\n");
+    }
+    // Step 1: Compile first
+    writeProgress("📦 Compiling project...");
+    await compileCommand();
+    // Step 2: Load configuration and API key
+    const config = readSkillConfig();
+    if (!config?.agent?.agentId) {
+        console.error('❌ No agent ID found in lua.skill.yaml. Run "lua init" first.');
+        process.exit(1);
+    }
+    const apiKey = await loadApiKey();
+    if (!apiKey) {
+        console.error('❌ No API key found. Run "lua auth configure" first.');
+        process.exit(1);
+    }
+    const agentId = config.agent.agentId; // Validated above, safe to assert
+    // Step 3: Read deploy.json for component data
+    const deployJsonPath = path.join(process.cwd(), '.lua', 'deploy.json');
+    if (!fs.existsSync(deployJsonPath)) {
+        console.error('❌ No deploy.json found. Compilation may have failed.');
+        process.exit(1);
+    }
+    const deployData = JSON.parse(fs.readFileSync(deployJsonPath, 'utf8'));
+    // Step 3b: Read bundled webhooks and jobs from dist/
+    const webhooksJsonPath = path.join(process.cwd(), 'dist', 'webhooks.json');
+    const jobsJsonPath = path.join(process.cwd(), 'dist', 'jobs.json');
+    const preprocessorsJsonPath = path.join(process.cwd(), 'dist', 'preprocessors.json');
+    const postprocessorsJsonPath = path.join(process.cwd(), 'dist', 'postprocessors.json');
+    const bundledWebhooks = fs.existsSync(webhooksJsonPath)
+        ? JSON.parse(fs.readFileSync(webhooksJsonPath, 'utf8'))
+        : [];
+    const bundledJobs = fs.existsSync(jobsJsonPath)
+        ? JSON.parse(fs.readFileSync(jobsJsonPath, 'utf8'))
+        : [];
+    const bundledPreprocessors = fs.existsSync(preprocessorsJsonPath)
+        ? JSON.parse(fs.readFileSync(preprocessorsJsonPath, 'utf8'))
+        : [];
+    const bundledPostprocessors = fs.existsSync(postprocessorsJsonPath)
+        ? JSON.parse(fs.readFileSync(postprocessorsJsonPath, 'utf8'))
+        : [];
+    // Track results for both push and deploy
+    const results = {
+        skills: [],
+        webhooks: [],
+        jobs: [],
+        preprocessors: [],
+        postprocessors: []
+    };
+    // Track what needs to be deployed
+    const toDeploySkills = [];
+    const toDeployWebhooks = [];
+    const toDeployJobs = [];
+    const toDeployPreprocessors = [];
+    const toDeployPostprocessors = [];
+    // Step 4: Push all skills
+    if (config.skills && config.skills.length > 0) {
+        writeProgress(`\n📦 Pushing ${config.skills.length} skill(s)...`);
+        for (const skillConfig of config.skills) {
+            try {
+                const skillData = deployData.skills.find((s) => s.name === skillConfig.name);
+                if (!skillData) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" not found in deploy.json, skipping`);
+                    continue;
+                }
+                // Validate skillId and version exist
+                const skillId = skillConfig.skillId;
+                const currentVersion = skillConfig.version;
+                if (!skillId) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" has no skillId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Skill "${skillConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${skillConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Push version
+                const pushResult = await pushVersion(apiKey, agentId, skillId, {
+                    version: newVersion,
+                    description: skillConfig.description || '',
+                    context: skillConfig.context || '',
+                    code: skillData.code,
+                    executeFunction: skillData.executeFunction,
+                    inputSchema: skillData.inputSchema,
+                    outputSchema: skillData.outputSchema,
+                });
+                if (!pushResult.success) {
+                    console.error(`  ❌ Failed to push ${skillConfig.name}:`, pushResult.error?.message);
+                    continue;
+                }
+                // Update YAML with new version
+                updateSkillVersionInYaml(skillConfig.name, newVersion);
+                results.skills.push({ name: skillConfig.name, version: newVersion, skillId });
+                writeSuccess(`  ✅ ${skillConfig.name} v${newVersion} pushed`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeploySkills.push({ skillId, version: newVersion, name: skillConfig.name });
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${skillConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 5: Push all webhooks
+    if (config.webhooks && config.webhooks.length > 0) {
+        writeProgress(`\n🪝 Pushing ${config.webhooks.length} webhook(s)...`);
+        for (const webhookConfig of config.webhooks) {
+            try {
+                const webhookData = bundledWebhooks.find((w) => w.name === webhookConfig.name);
+                if (!webhookData) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" not found in compiled data, skipping`);
+                    continue;
+                }
+                // Validate webhookId and version exist
+                if (!webhookConfig.webhookId) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" has no webhookId, skipping`);
+                    continue;
+                }
+                if (!webhookConfig.version) {
+                    console.warn(`⚠️  Webhook "${webhookConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(webhookConfig.version);
+                writeInfo(`  📝 ${webhookConfig.name}: ${webhookConfig.version} → ${newVersion}`);
+                // Prepare webhook data for push
+                const pushData = {
+                    name: webhookConfig.name,
+                    version: newVersion,
+                    description: webhookData.description || webhookConfig.description || '',
+                    context: webhookData.context || webhookConfig.context || '',
+                    webhookId: webhookConfig.webhookId,
+                    querySchema: webhookData.querySchema,
+                    headerSchema: webhookData.headerSchema,
+                    bodySchema: webhookData.bodySchema,
+                    code: webhookData.code,
+                    executeFunction: webhookData.executeFunction
+                };
+                // Push version using fetch (like existing webhook push)
+                const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${webhookConfig.webhookId}/version`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(pushData)
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+                }
+                // Update YAML
+                updateWebhookVersionInYaml(webhookConfig.name, newVersion);
+                results.webhooks.push({ name: webhookConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${webhookConfig.name} v${newVersion} pushed`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployWebhooks.push({ webhookId: webhookConfig.webhookId, version: newVersion, name: webhookConfig.name });
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${webhookConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 6: Push all jobs
+    if (config.jobs && config.jobs.length > 0) {
+        writeProgress(`\n⏰ Pushing ${config.jobs.length} job(s)...`);
+        for (const jobConfig of config.jobs) {
+            try {
+                const jobData = bundledJobs.find((j) => j.name === jobConfig.name);
+                if (!jobData) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" not found in compiled data, skipping`);
+                    continue;
+                }
+                // Validate jobId and version exist
+                if (!jobConfig.jobId) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" has no jobId, skipping`);
+                    continue;
+                }
+                if (!jobConfig.version) {
+                    console.warn(`⚠️  Job "${jobConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(jobConfig.version);
+                writeInfo(`  📝 ${jobConfig.name}: ${jobConfig.version} → ${newVersion}`);
+                // Prepare job data for push
+                const pushData = {
+                    name: jobConfig.name,
+                    version: newVersion,
+                    description: jobData.description || jobConfig.description || '',
+                    context: jobData.context || jobConfig.context || '',
+                    jobId: jobConfig.jobId,
+                    schedule: jobData.schedule || jobConfig.schedule,
+                    timeout: jobData.timeout,
+                    retry: jobData.retry,
+                    code: jobData.code,
+                    executeFunction: jobData.executeFunction,
+                    metadata: jobData.metadata || jobConfig.metadata
+                };
+                // Push version using fetch
+                const response = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${jobConfig.jobId}/version`, {
+                    method: 'POST',
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify(pushData)
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+                }
+                // Update YAML
+                updateJobVersionInYaml(jobConfig.name, newVersion);
+                results.jobs.push({ name: jobConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${jobConfig.name} v${newVersion} pushed`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployJobs.push({ jobId: jobConfig.jobId, version: newVersion, name: jobConfig.name });
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${jobConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 7: Push all preprocessors
+    if (config.preprocessors && config.preprocessors.length > 0) {
+        writeProgress(`\n📥 Pushing ${config.preprocessors.length} preprocessor(s)...`);
+        const preprocessorService = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        for (const processorConfig of config.preprocessors) {
+            try {
+                const processorData = bundledPreprocessors.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" not found in compiled data, skipping`);
+                    continue;
+                }
+                // Validate preprocessorId and version exist
+                const preprocessorId = processorConfig.preprocessorId;
+                const currentVersion = processorConfig.version;
+                if (!preprocessorId) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" has no preprocessorId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Preprocessor "${processorConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${processorConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Prepare version data
+                const versionData = {
+                    name: processorConfig.name,
+                    version: newVersion,
+                    description: processorData.description || processorConfig.description || '',
+                    context: processorData.context || processorConfig.context || '',
+                    preprocessorId: preprocessorId,
+                    code: processorData.code,
+                    executeFunction: processorData.executeFunction,
+                    async: Boolean(processorData.async ?? false)
+                };
+                // Push version
+                const result = await preprocessorService.pushPreProcessor(preprocessorId, versionData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push preprocessor');
+                }
+                // Update YAML
+                updateProcessorVersionInYaml('preprocessors', processorConfig.name, newVersion);
+                results.preprocessors.push({ name: processorConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${processorConfig.name} v${newVersion} pushed`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployPreprocessors.push({ preprocessorId, version: newVersion, name: processorConfig.name });
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 8: Push all postprocessors
+    if (config.postprocessors && config.postprocessors.length > 0) {
+        writeProgress(`\n📤 Pushing ${config.postprocessors.length} postprocessor(s)...`);
+        const postprocessorService = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        for (const processorConfig of config.postprocessors) {
+            try {
+                const processorData = bundledPostprocessors.find((p) => p.name === processorConfig.name);
+                if (!processorData) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" not found in compiled data, skipping`);
+                    continue;
+                }
+                // Validate postprocessorId and version exist
+                const postprocessorId = processorConfig.postprocessorId;
+                const currentVersion = processorConfig.version;
+                if (!postprocessorId) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" has no postprocessorId, skipping`);
+                    continue;
+                }
+                if (!currentVersion) {
+                    console.warn(`⚠️  Postprocessor "${processorConfig.name}" has no version, skipping`);
+                    continue;
+                }
+                // Auto-bump patch version
+                const newVersion = bumpPatchVersion(currentVersion);
+                writeInfo(`  📝 ${processorConfig.name}: ${currentVersion} → ${newVersion}`);
+                // Prepare version data
+                const versionData = {
+                    name: processorConfig.name,
+                    version: newVersion,
+                    description: processorData.description || processorConfig.description || '',
+                    context: processorData.context || processorConfig.context || '',
+                    postprocessorId: postprocessorId,
+                    code: processorData.code,
+                    executeFunction: processorData.executeFunction,
+                    async: Boolean(processorData.async ?? false)
+                };
+                // Push version
+                const result = await postprocessorService.pushPostProcessor(postprocessorId, versionData);
+                if (!result.success) {
+                    throw new Error(result.error?.message || 'Failed to push postprocessor');
+                }
+                // Update YAML
+                updateProcessorVersionInYaml('postprocessors', processorConfig.name, newVersion);
+                results.postprocessors.push({ name: processorConfig.name, version: newVersion });
+                writeSuccess(`  ✅ ${processorConfig.name} v${newVersion} pushed`);
+                // Queue for deployment if requested
+                if (options.autoDeploy) {
+                    toDeployPostprocessors.push({ postprocessorId, version: newVersion, name: processorConfig.name });
+                }
+            }
+            catch (error) {
+                console.error(`  ❌ Failed to push ${processorConfig.name}:`, error.message);
+            }
+        }
+    }
+    // Step 9: Deploy all components if autoDeploy is enabled
+    if (options.autoDeploy && (toDeploySkills.length > 0 || toDeployWebhooks.length > 0 || toDeployJobs.length > 0 || toDeployPreprocessors.length > 0 || toDeployPostprocessors.length > 0)) {
+        writeProgress('\n🚀 Deploying all pushed versions to production...');
+        writeInfo('⏱️  Waiting for server to process versions (5 seconds)...\n');
+        // Wait for server to process all pushed versions
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        // Deploy all skills
+        if (toDeploySkills.length > 0) {
+            writeProgress(`📦 Deploying ${toDeploySkills.length} skill(s)...`);
+            for (const skill of toDeploySkills) {
+                const deployed = await retryDeploy(() => publishVersion(apiKey, agentId, skill.skillId, skill.version), skill.name, skill.version, 2 // Only 2 retries since we already waited
+                );
+                if (deployed) {
+                    writeSuccess(`  🚀 ${skill.name} v${skill.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${skill.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all webhooks
+        if (toDeployWebhooks.length > 0) {
+            writeProgress(`🪝 Deploying ${toDeployWebhooks.length} webhook(s)...`);
+            for (const webhook of toDeployWebhooks) {
+                const deployed = await retryDeploy(async () => {
+                    const response = await fetch(`${BASE_URLS.API}/developer/webhooks/${agentId}/${webhook.webhookId}/${webhook.version}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}`);
+                    }
+                }, webhook.name, webhook.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${webhook.name} v${webhook.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${webhook.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all jobs
+        if (toDeployJobs.length > 0) {
+            writeProgress(`⏰ Deploying ${toDeployJobs.length} job(s)...`);
+            for (const job of toDeployJobs) {
+                const deployed = await retryDeploy(async () => {
+                    const response = await fetch(`${BASE_URLS.API}/developer/jobs/${agentId}/${job.jobId}/${job.version}/publish`, {
+                        method: 'PUT',
+                        headers: {
+                            'Authorization': `Bearer ${apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status}`);
+                    }
+                }, job.name, job.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${job.name} v${job.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${job.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all preprocessors
+        if (toDeployPreprocessors.length > 0) {
+            writeProgress(`📥 Deploying ${toDeployPreprocessors.length} preprocessor(s)...`);
+            const preprocessorService = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+            for (const processor of toDeployPreprocessors) {
+                const deployed = await retryDeploy(() => preprocessorService.publishPreProcessorVersion(processor.preprocessorId, processor.version), processor.name, processor.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${processor.name} v${processor.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${processor.name} deployment failed`);
+                }
+            }
+        }
+        // Deploy all postprocessors
+        if (toDeployPostprocessors.length > 0) {
+            writeProgress(`📤 Deploying ${toDeployPostprocessors.length} postprocessor(s)...`);
+            const postprocessorService = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+            for (const processor of toDeployPostprocessors) {
+                const deployed = await retryDeploy(() => postprocessorService.publishPostProcessorVersion(processor.postprocessorId, processor.version), processor.name, processor.version, 2);
+                if (deployed) {
+                    writeSuccess(`  🚀 ${processor.name} v${processor.version} deployed`);
+                }
+                else {
+                    console.warn(`  ⚠️  ${processor.name} deployment failed`);
+                }
+            }
+        }
+    }
+    // Step 10: Print summary
+    writeSuccess('\n✅ Push All Complete!\n');
+    if (results.skills.length > 0) {
+        console.log(`🛠️  Skills (${results.skills.length}):`);
+        results.skills.forEach(s => console.log(`   • ${s.name} v${s.version}`));
+    }
+    if (results.webhooks.length > 0) {
+        console.log(`🪝 Webhooks (${results.webhooks.length}):`);
+        results.webhooks.forEach(w => console.log(`   • ${w.name} v${w.version}`));
+    }
+    if (results.jobs.length > 0) {
+        console.log(`⏰ Jobs (${results.jobs.length}):`);
+        results.jobs.forEach(j => console.log(`   • ${j.name} v${j.version}`));
+    }
+    if (results.preprocessors.length > 0) {
+        console.log(`📥 PreProcessors (${results.preprocessors.length}):`);
+        results.preprocessors.forEach(p => console.log(`   • ${p.name} v${p.version}`));
+    }
+    if (results.postprocessors.length > 0) {
+        console.log(`📤 PostProcessors (${results.postprocessors.length}):`);
+        results.postprocessors.forEach(p => console.log(`   • ${p.name} v${p.version}`));
+    }
+    if (options.autoDeploy) {
+        writeSuccess('\n🚀 All components deployed to production!');
+    }
+    console.log('');
+}
+/**
+ * Bumps the patch version of a semantic version string
+ * e.g., "1.2.3" -> "1.2.4"
+ */
+function bumpPatchVersion(version) {
+    const parts = version.split('.');
+    if (parts.length !== 3) {
+        // If not a valid semver, just return incremented version
+        return version + '.1';
+    }
+    const [major, minor, patch] = parts;
+    const newPatch = parseInt(patch, 10) + 1;
+    return `${major}.${minor}.${newPatch}`;
+}
+/**
+ * Retry deployment with exponential backoff
+ * The server needs time to process pushed versions before they can be deployed
+ */
+async function retryDeploy(deployFn, componentName, version, maxRetries = 3) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const delay = attempt * 2000; // 2s, 4s, 6s (longer delays)
+            await new Promise(resolve => setTimeout(resolve, delay));
+            await deployFn();
+            return true;
+        }
+        catch (error) {
+            if (attempt === maxRetries) {
+                console.error(`    [Retry ${attempt}/${maxRetries}] Deploy failed: ${error.message}`);
+                return false;
+            }
+            // Continue to next retry silently
+        }
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.6",
   "description": "Command-line interface for Lua AI platform - develop, test, and deploy LuaSkills with custom tools",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",

package/template/lua.skill.yaml

@@ -1,47 +1,69 @@
 agent:
   agentId: baseAgent_agent_1760922427216_fk9w0ezhh
   orgId: 026cc41b-e013-4474-9b65-5a15f8881f92
-  persona: |
-    Meet Vivienne, the vibrant and dynamic assistant at V3 Test, a lively retail and consumer goods store that specializes in bringing a splash of color and excitement to everyday life. Vivienne embodies the brand's energetic and fun personality, always ready to engage with customers in a way that makes shopping an enjoyable and memorable experience. Her role is to be the friendly face and knowledgeable guide for anyone who steps into the store, whether they're looking for the latest fashion trends or a unique gift for a loved one.
+  persona: >
+    Meet Vivienne, the vibrant and dynamic assistant at V3 Test, a lively retail and consumer goods store that
+    specializes in bringing a splash of color and excitement to everyday life. Vivienne embodies the brand's energetic
+    and fun personality, always ready to engage with customers in a way that makes shopping an enjoyable and memorable
+    experience. Her role is to be the friendly face and knowledgeable guide for anyone who steps into the store, whether
+    they're looking for the latest fashion trends or a unique gift for a loved one.
 
-    V3 Test is all about creating a joyful and spirited shopping environment, and Vivienne is the perfect personification of this ethos. She is lively, approachable, and always ready with a smile, making every interaction feel like a conversation with a good friend. Her voice is warm and enthusiastic, with a hint of playfulness that puts customers at ease and encourages them to explore the store's offerings.
 
-    Vivienne's target customers are diverse, ranging from young adults in their twenties who are fashion-forward and tech-savvy, to busy parents looking for quality products that add a touch of fun to their family life. She understands the fast-paced lifestyle of her customers and is adept at tailoring her approach to meet their individual needs, whether they're in a hurry or have time to browse.
+    V3 Test is all about creating a joyful and spirited shopping environment, and Vivienne is the perfect
+    personification of this ethos. She is lively, approachable, and always ready with a smile, making every interaction
+    feel like a conversation with a good friend. Her voice is warm and enthusiastic, with a hint of playfulness that
+    puts customers at ease and encourages them to explore the store's offerings.
 
-    Her sales approach is consultative and friendly, focusing on understanding the customer's needs and preferences before suggesting products that align with their style and personality. Vivienne is confident in her recommendations, always ready to upsell when appropriate, but never pushy. She believes in building relationships with customers, ensuring they leave the store not only with products they love but also with a positive impression of the brand.
 
-    In terms of communication style, Vivienne strikes a perfect balance between being informal and efficient. She is warm and engaging, making customers feel valued and appreciated, while also being mindful of their time. Her interactions are peppered with humor and light-hearted banter, creating a shopping experience that is both enjoyable and efficient. Whether it's through in-person interactions or digital communication, Vivienne ensures that every customer feels like a part of the V3 Test family.
+    Vivienne's target customers are diverse, ranging from young adults in their twenties who are fashion-forward and
+    tech-savvy, to busy parents looking for quality products that add a touch of fun to their family life. She
+    understands the fast-paced lifestyle of her customers and is adept at tailoring her approach to meet their
+    individual needs, whether they're in a hurry or have time to browse.
+
+
+    Her sales approach is consultative and friendly, focusing on understanding the customer's needs and preferences
+    before suggesting products that align with their style and personality. Vivienne is confident in her
+    recommendations, always ready to upsell when appropriate, but never pushy. She believes in building relationships
+    with customers, ensuring they leave the store not only with products they love but also with a positive impression
+    of the brand.
+
+
+    In terms of communication style, Vivienne strikes a perfect balance between being informal and efficient. She is
+    warm and engaging, making customers feel valued and appreciated, while also being mindful of their time. Her
+    interactions are peppered with humor and light-hearted banter, creating a shopping experience that is both enjoyable
+    and efficient. Whether it's through in-person interactions or digital communication, Vivienne ensures that every
+    customer feels like a part of the V3 Test family.
   welcomeMessage: Hi, I am your AI assistant. How can I help you today?
 skills:
   - name: general-skill
-    version: 0.0.3
+    version: 0.0.4
     skillId: 1faf9b3a-e352-4e63-a6c4-a3deca815361
   - name: user-data-skill
-    version: 0.0.1
+    version: 0.0.12
     skillId: e0c382c1-f469-4880-962a-a756ea3c1411
   - name: product-skill
-    version: 0.0.1
+    version: 0.0.12
     skillId: d4cdc7bc-6d42-4232-902d-2b9cf68bd74a
   - name: basket-skill
-    version: 0.0.1
+    version: 0.0.11
     skillId: 5b06c5ff-7cf3-49c4-8641-142270c81db4
   - name: order-skill
-    version: 0.0.1
+    version: 0.0.11
     skillId: d4045304-7c30-4750-9edd-340eb1357a39
   - name: custom-data-skill
-    version: 0.0.1
+    version: 0.0.10
     skillId: 83fe411c-90a1-4bd3-9271-ac8e03d6a3be
   - name: payment-skill
-    version: 0.0.1
+    version: 0.0.10
     skillId: f2248c02-c6c6-4c3a-89bf-ff09ec11529a
 jobs:
   - name: test-job
-    version: 1.0.2
+    version: 1.0.9
     jobId: d66b73a0-f944-4718-b6a2-f07bfeabd625
     schedule:
       type: once
       executeAt: '2025-10-20T01:08:04.639Z'
 webhooks:
   - name: test-webhook
-    version: 1.0.1
+    version: 1.0.8
     webhookId: c967fd58-1d4d-49b6-8fa6-ec36b4d23e7f

package/template/package.json

@@ -20,7 +20,7 @@
     "inquirer": "^12.9.6",
     "stripe": "^17.5.0",
     "js-yaml": "^4.1.0",
-    "lua-cli": "^3.0.0-alpha.4",
+    "lua-cli": "^3.0.0-alpha.6",
     "openai": "^5.23.0",
     "uuid": "^13.0.0",
     "zod": "^3.24.1"