lua-cli 3.15.2 → 3.16.0

package/dist/commands/push.js

@@ -1,1145 +0,0 @@
-/**
- * Push Command
- * Orchestrates pushing skill versions to the server
- */
-import { hasPersonaTextContent, flattenPersonaTextAll } from '@lua/shared-types';
-import { compileCommand } from './compile.js';
-import { readYamlConfig } from '../utils/files.js';
-import { withErrorHandling, writeProgress, writeSuccess, writeInfo, writeError, clearPromptLines, writeNextStep, writeHintBlock, writeTip, } from '../utils/cli.js';
-import { requireAuthOrExit } from '../utils/command-utils.js';
-import { safePrompt } from '../utils/prompt-handler.js';
-import { incrementPatchVersion, maxSemver } from '../utils/semver.js';
-import { AuthenticationError } from '../errors/auth.error.js';
-import { BASE_URLS } from '../config/constants.js';
-import PersonaApi from '../api/persona.api.service.js';
-import { loadManifest, getPrimitivesByKind } from '../utils/artifact-loader.js';
-import { ensureBundlesUploaded } from '../utils/bundle-upload.js';
-import { PrimitiveKind } from '../compiler/types.js';
-import { agentHandler } from '../primitives/agent.handler.js';
-import { skillHandler as skillH, webhookHandler as webhookH, jobHandler as jobH, preprocessorHandler as preprocessorH, postprocessorHandler as postprocessorH, deviceHandler as deviceH, deviceTriggerHandler as deviceTriggerH, } from '../primitives/index.js';
-import { pushBackupCommand, runBackupPush } from './pushBackup.js';
-import { buildLogsCommand } from './log-tip.js';
-import { trackEvent } from '../services/analytics.js';
-import { validateOrSuggest } from '../utils/aliases.js';
-export { pickPushAllNextStepVariant, formatPushFailureSummary } from './push-helpers.js';
-import { pickPushAllNextStepVariant, formatPushFailureSummary } from './push-helpers.js';
-/**
- * Maps push target type to a valid `lua deploy …` follow-up (or null when
- * there is no deploy CLI surface for that type — e.g. mcp, device, backup).
- */
-function getDeployHint(type) {
-    const deployableMap = {
-        skill: 'lua deploy skill',
-        webhook: 'lua deploy webhook',
-        job: 'lua deploy job',
-        preprocessor: 'lua deploy preprocessor',
-        postprocessor: 'lua deploy postprocessor',
-        agent: 'lua deploy persona',
-        persona: 'lua deploy persona',
-    };
-    const cmd = deployableMap[type];
-    if (!cmd)
-        return null;
-    return { label: 'Deploy:', command: cmd };
-}
-// ============================================================================
-// Core Push Helpers (shared by all push functions)
-// ============================================================================
-/**
- * Prompts user to confirm or update the version.
- *
- * @param currentVersion - Current version of the skill
- * @returns Confirmed or updated version
- */
-async function promptVersionConfirmOrUpdate(currentVersion) {
-    console.log(`\nCurrent version: ${currentVersion || '(none - first push)'}`);
-    const answer = await safePrompt([
-        {
-            type: 'input',
-            name: 'newVersion',
-            message: 'Enter new version to push:',
-            default: incrementPatchVersion(currentVersion),
-            validate: (input) => {
-                if (!input || input.trim() === '') {
-                    return 'Version cannot be empty';
-                }
-                // Basic semver validation
-                const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
-                if (!semverRegex.test(input.trim())) {
-                    return 'Version must follow semver format (e.g., 1.0.0, 1.0.0-alpha.1)';
-                }
-                return true;
-            },
-        },
-    ]);
-    if (!answer) {
-        console.log('Push cancelled.');
-        process.exit(0);
-    }
-    clearPromptLines(2);
-    return answer.newVersion.trim();
-}
-/**
- * Authenticates the user and returns the API key
- * Exits with error if authentication fails
- */
-async function authenticateOrFail() {
-    return requireAuthOrExit(false);
-}
-/**
- * Selects an entity from a list, either by options.entityName or interactive prompt
- * @param items - Array of items to select from
- * @param options - Push options with entityName
- * @param config - Configuration for selection behavior
- */
-async function selectEntityOrFail(items, options, config) {
-    const { entityType, nameFields = ['id', 'name'], formatChoice } = config;
-    if (items.length === 0) {
-        throw new Error(`No ${entityType}s found in lua.skill.yaml.`);
-    }
-    // Non-interactive: find by name
-    if (options.entityName) {
-        const found = items.find((item) => nameFields.some((field) => item[field] === options.entityName));
-        if (!found) {
-            throw new Error(`${entityType} "${options.entityName}" not found`);
-        }
-        writeInfo(`📦 Selected ${entityType}: ${found.name}`);
-        return found;
-    }
-    // Single item: use it automatically
-    if (items.length === 1) {
-        writeInfo(`📦 Pushing ${entityType}: ${items[0].name}`);
-        return items[0];
-    }
-    // Multiple items: prompt for selection
-    const answer = await safePrompt([
-        {
-            type: 'list',
-            name: 'selected',
-            message: `Select a ${entityType} to push:`,
-            choices: items.map((item) => ({
-                name: formatChoice ? formatChoice(item) : `${item.name} (v${item.version})`,
-                value: item,
-            })),
-        },
-    ]);
-    if (!answer) {
-        console.log('Push cancelled.');
-        process.exit(0);
-    }
-    writeInfo(`📦 Selected ${entityType}: ${answer.selected.name}`);
-    return answer.selected;
-}
-/**
- * Resolves version from options or interactive prompt
- * Validates semantic versioning format
- */
-async function resolveVersionOrFail(currentVersion, options, highestKnownVersion) {
-    // If version explicitly provided, use it
-    if (options.version) {
-        if (!/^\d+\.\d+\.\d+/.test(options.version)) {
-            throw new Error(`Invalid version format: "${options.version}". Use semantic versioning (e.g., 1.0.5)`);
-        }
-        writeInfo(`📝 Using version: ${options.version}`);
-        return options.version;
-    }
-    // If force flag provided, auto-bump without prompting
-    if (options.force) {
-        // Bump from the highest known version (max of YAML and server) to avoid conflicts
-        const baseVersion = highestKnownVersion ? maxSemver(currentVersion, highestKnownVersion) : currentVersion;
-        const newVersion = incrementPatchVersion(baseVersion);
-        writeInfo(`📝 Auto-bumping version: ${currentVersion} → ${newVersion}`);
-        return newVersion;
-    }
-    // Otherwise, prompt interactively
-    return await promptVersionConfirmOrUpdate(currentVersion);
-}
-/**
- * Determines if we should deploy after push based on options or prompt
- */
-async function shouldDeployAfterPush(options) {
-    // Auto-deploy flag takes precedence
-    if (options.autoDeploy) {
-        return true;
-    }
-    // Force mode skips the prompt (no deploy)
-    if (options.force) {
-        return false;
-    }
-    // Interactive: ask user
-    const answer = await safePrompt([
-        {
-            type: 'confirm',
-            name: 'deployNow',
-            message: 'Would you like to deploy this version to production now?',
-            default: false,
-        },
-    ]);
-    return answer?.deployNow || false;
-}
-// ============================================================================
-// Generic Push/Deploy (replaces per-type push/deploy functions)
-// ============================================================================
-/**
- * Generic push for any versioned primitive (webhook, job, preprocessor, postprocessor).
- * Skill has its own flow due to tools array + config validation.
- */
-async function pushVersionedPrimitive(handler, options = {}) {
-    try {
-        // Step 1: Compile
-        writeProgress('📦 Compiling project...');
-        await compileCommand();
-        writeSuccess('✅ Compilation complete');
-        // Step 2: Authenticate
-        const apiKey = await authenticateOrFail();
-        writeSuccess('✅ Authentication verified');
-        // Step 3: Read config
-        const config = readYamlConfig();
-        if (!config?.agent?.agentId) {
-            throw new Error("No agent ID found in lua.skill.yaml. Please run 'lua init' first.");
-        }
-        const agentId = config.agent.agentId;
-        // Step 4: Get items from YAML and select
-        const items = handler.getFromYaml(config);
-        if (items.length === 0) {
-            throw new Error(`No ${handler.displayNamePlural} found in lua.skill.yaml.`);
-        }
-        const selected = await selectEntityOrFail(items, options, {
-            entityType: handler.displayName,
-            nameFields: ['id', handler.yamlConfig.idField, 'name'],
-        });
-        const entityId = selected[handler.yamlConfig.idField];
-        if (!entityId) {
-            throw new Error(`${handler.displayName} "${selected.name}" has no server ID. Run 'lua compile' first.`);
-        }
-        // Step 5: Load bundled data — accumulate raw gzip blobs for presigned upload (BAC-196)
-        const manifest = loadManifest();
-        const bundleAccumulator = new Map();
-        const pushData = handler.prepareForPush(manifest, selected.name, undefined, bundleAccumulator);
-        if (!pushData) {
-            throw new Error(`${handler.displayName} "${selected.name}" not found in compiled output.`);
-        }
-        // Step 5b: Upload missing blobs to S3 via presigned PUT, skip ones already there.
-        let bundleStats = {
-            total: 0,
-            alreadyExisted: 0,
-            uploaded: 0,
-        };
-        if (bundleAccumulator.size > 0) {
-            writeProgress(`📤 Uploading ${bundleAccumulator.size} bundle(s) to S3...`);
-            bundleStats = await ensureBundlesUploaded(apiKey, agentId, bundleAccumulator);
-            writeSuccess('✅ Bundles uploaded');
-        }
-        // Step 6: Resolve version (check server for highest to avoid conflicts)
-        const serverHighest = options.force ? await handler.getHighestServerVersion(apiKey, agentId, entityId) : undefined;
-        const confirmedVersion = await resolveVersionOrFail(selected.version, options, serverHighest ?? undefined);
-        if (confirmedVersion !== selected.version) {
-            handler.updateVersionInYaml(selected.name, confirmedVersion);
-        }
-        // Step 7: Push
-        writeProgress(`\n🚀 Pushing ${selected.name} v${confirmedVersion} to server...`);
-        const result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: confirmedVersion });
-        if (!result.success) {
-            const isVersionConflict = result.error?.toLowerCase().includes('already exists');
-            if (isVersionConflict) {
-                writeHintBlock({
-                    headline: 'Version conflict — this version already exists on the server.',
-                    lines: [
-                        { label: 'Auto-bump:', command: `lua push ${handler.kind} --force` },
-                        { label: 'Or push all:', command: 'lua push all --force' },
-                    ],
-                    when: 'error',
-                });
-            }
-            // Push rejected — the reason is already on screen in the error above.
-            // No lua logs hint here: the push never ran, so no execution logs exist.
-            throw new Error(`Push Error: ${result.error || 'Unknown error'}`);
-        }
-        writeSuccess(`\n✅ Successfully pushed ${selected.name} v${confirmedVersion}\n`);
-        // Step 8: Deploy if requested
-        if (await shouldDeployAfterPush(options)) {
-            const deployedOk = await genericDeployAfterPush(handler, apiKey, agentId, entityId, selected.name, confirmedVersion, options.autoDeploy || false);
-            return { productionDeploySucceeded: deployedOk, bundleStats };
-        }
-        return { productionDeploySucceeded: false, bundleStats };
-        // Staging vs deployed hints run in pushCommand — avoid duplicates here (H8).
-    }
-    catch (error) {
-        throw error;
-    }
-}
-/**
- * Generic deploy/publish after push for any versioned primitive.
- */
-async function genericDeployAfterPush(handler, apiKey, agentId, entityId, entityName, version, skipConfirmation = false) {
-    try {
-        if (!skipConfirmation) {
-            console.log('\n⚠️  WARNING: You are about to deploy to PRODUCTION!');
-            console.log('⚠️  This will affect ALL users immediately.\n');
-            const confirmAnswer = await safePrompt([
-                {
-                    type: 'confirm',
-                    name: 'confirm',
-                    message: 'Are you absolutely sure you want to deploy?',
-                    default: false,
-                },
-            ]);
-            if (!confirmAnswer || !confirmAnswer.confirm) {
-                console.log('\n❌ Deployment cancelled. Version pushed but not deployed.\n');
-                return false;
-            }
-        }
-        writeProgress(`🔄 Publishing ${handler.displayName} version...`);
-        writeInfo('⏱️  Waiting for server to process the new version (3 seconds)...');
-        await new Promise((resolve) => setTimeout(resolve, 3000));
-        const deployed = await retryDeploy(async () => {
-            const result = await handler.publishVersion(apiKey, agentId, entityId, version);
-            if (!result.success)
-                throw new Error(result.error || 'Deploy failed');
-        }, entityName, version, 3);
-        if (!deployed) {
-            console.error(`\n❌ Deploy Error: failed after retries\n`);
-            // Deploy is a management operation — no execution logs exist for a failed deploy.
-            // Suggest retrying via the deploy command.
-            writeTip(`Deploy later with: lua deploy ${handler.kind}`);
-            return false;
-        }
-        writeSuccess(`\n✅ ${entityName} v${version} deployed to production\n`);
-        writeInfo(`💡 The new ${handler.displayName} version is now active.`);
-        return true;
-    }
-    catch (error) {
-        console.error(`\n❌ Error deploying ${handler.displayName}:`, error);
-        // Deploy is a management operation — no execution logs exist for a failed deploy.
-        writeTip(`Deploy later with: lua deploy ${handler.kind}`);
-        return false;
-    }
-}
-/**
- * Main push command - pushes a primitive or agent config to the server.
- *
- * Supports both interactive and non-interactive modes:
- * - Interactive: prompts user to select what to push
- * - Non-interactive: type provided as argument (e.g., `lua push skill --name mySkill`)
- *
- * @param type - Optional type: 'skill', 'agent', 'persona', 'webhook', 'job', 'preprocessor', 'postprocessor', 'mcp', 'backup', or 'all'
- * @param cmdObj - Commander command object with options
- * @returns Promise that resolves when push completes
- */
-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,
-            entityName: cmdObj?.name || null,
-            version: cmdObj?.setVersion || null,
-            // Only meaningful for `lua push backup`; ignored for other types.
-            fresh: cmdObj?.fresh || false,
-        };
-        let agentOutcome;
-        let selectedType;
-        /** Present only after a versioned-primitive route; indicates production publish success after optional deploy. */
-        let versionedPushDeployResult;
-        // Normalize alias first (e.g. 'everything' → 'all', 'skills' → 'skill')
-        // so that the early 'all' guard below can catch aliases like 'everything'
-        if (type) {
-            type = validateOrSuggest('push.type', type, { allowAll: true });
-        }
-        // Handle 'all' type with force flag
-        if (type === 'all') {
-            if (!options.force) {
-                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');
-                throw new Error('The "all" type requires the --force flag');
-            }
-            return await pushAllCommand(options);
-        }
-        // Validate that entityName without type is not allowed
-        if (options.entityName && !type) {
-            console.log('\nUsage:');
-            console.log('  lua push skill --name mySkill --set-version 1.0.5        Push specific skill');
-            console.log('  lua push webhook --name myWebhook --set-version 2.0.0    Push specific webhook');
-            throw new Error('Type must be specified when using the --name option.');
-        }
-        if (type) {
-            selectedType = type;
-        }
-        else {
-            // Step 2: Prompt for type selection
-            const typeAnswer = await safePrompt([
-                {
-                    type: 'list',
-                    name: 'type',
-                    message: 'What would you like to push?',
-                    choices: [
-                        { name: '🛠️  Skill', value: 'skill' },
-                        { name: '🪝 Webhook', value: 'webhook' },
-                        { name: '⏰ Job', value: 'job' },
-                        { name: '📥 PreProcessor', value: 'preprocessor' },
-                        { name: '📤 PostProcessor', value: 'postprocessor' },
-                        { name: '🔌 MCP Server', value: 'mcp' },
-                        { name: '📡 Device', value: 'device' },
-                        { name: '📡 Device Trigger', value: 'device-trigger' },
-                        { name: '🤖 Agent (persona, model)', value: 'agent' },
-                        { name: '💾 Backup (source files)', value: 'backup' },
-                    ],
-                },
-            ]);
-            if (!typeAnswer) {
-                console.log('Push cancelled.');
-                return;
-            }
-            selectedType = typeAnswer.type;
-        }
-        // Step 3: Route to appropriate function
-        if (selectedType === 'skill') {
-            versionedPushDeployResult = await pushVersionedPrimitive(skillH, options);
-        }
-        else if (selectedType === 'webhook') {
-            versionedPushDeployResult = await pushVersionedPrimitive(webhookH, options);
-        }
-        else if (selectedType === 'job') {
-            versionedPushDeployResult = await pushVersionedPrimitive(jobH, options);
-        }
-        else if (selectedType === 'preprocessor') {
-            versionedPushDeployResult = await pushVersionedPrimitive(preprocessorH, options);
-        }
-        else if (selectedType === 'postprocessor') {
-            versionedPushDeployResult = await pushVersionedPrimitive(postprocessorH, options);
-        }
-        else if (selectedType === 'device') {
-            versionedPushDeployResult = await pushVersionedPrimitive(deviceH, options);
-        }
-        else if (selectedType === 'device-trigger') {
-            versionedPushDeployResult = await pushVersionedPrimitive(deviceTriggerH, options);
-        }
-        else if (selectedType === 'mcp') {
-            const mcpActivated = await pushMCPServer(options);
-            // B10: thread activation status so the final hint knows whether MCP is live.
-            versionedPushDeployResult = { productionDeploySucceeded: mcpActivated };
-        }
-        else if (selectedType === 'backup') {
-            await pushBackupCommand({ force: options.force, fresh: options.fresh });
-        }
-        else if (selectedType === 'agent') {
-            agentOutcome = await pushAgentVersion(options);
-        }
-        if (agentOutcome?.cancelled) {
-            return;
-        }
-        // Phase 2 task 2.5: auto-backup-push after every successful primitive push.
-        // Phase 0 deleted runPostPushHook and left this gap; without it, a `lua
-        // push <X>` could exit 0 while the corresponding source backup silently
-        // never made it to S3, leaving the server-deployed code with no way to
-        // recover its source. We use runBackupPush (not pushBackupCommand) for
-        // two reasons:
-        //   1. We need it to throw on failure so the surrounding `lua push`
-        //      exits non-zero — partial success here was the original failure
-        //      mode this is fixing.
-        //   2. The user-facing wrapper has freshness/server-newer guards that
-        //      make sense for `lua push backup` but would block the auto-hook
-        //      after legitimate primitive pushes.
-        // Skip for `backup` (the user already pushed it directly) and `agent`
-        // (no source files change on the agent path).
-        if (selectedType !== 'backup' && selectedType !== 'agent') {
-            const hookApiKey = requireAuthOrExit(false);
-            const hookConfig = readYamlConfig();
-            const hookAgentId = hookConfig?.agent?.agentId;
-            if (!hookAgentId) {
-                throw new Error('Cannot run auto-backup: no agentId in lua.skill.yaml.');
-            }
-            // Source backup is a deploy invariant: a successful primitive push
-            // that doesn't reach the source store leaves `lua init` (and the
-            // Builder's workspace hydration) seeing stale state on the next
-            // restore. We exit non-zero on backup failure to surface the gap
-            // — but the primitive itself is already deployed, so the message
-            // needs to be explicit about that + point at the recovery action
-            // so the user doesn't re-push the primitive thinking it failed.
-            try {
-                const hookResult = await runBackupPush({
-                    apiKey: hookApiKey,
-                    agentId: hookAgentId,
-                    force: true,
-                    fresh: true,
-                    triggeredBy: `push ${selectedType}${options.entityName ? ` ${options.entityName}` : ''}`,
-                });
-                writeInfo(`💾 Backup at v${hookResult.activeVersion} (${hookResult.filesUploaded} new file(s))`);
-            }
-            catch (err) {
-                const reason = err instanceof Error ? err.message : String(err);
-                const label = selectedType + (options.entityName ? ` "${options.entityName}"` : '');
-                writeError(`Source backup failed after ${label} push: ${reason}\n\n` +
-                    `Your ${label} IS deployed and live on the server — do NOT re-push the primitive.\n` +
-                    `The source backup just didn't sync. Recover with:\n\n` +
-                    `    lua push backup --force --fresh\n\n` +
-                    `Until the backup catches up, \`lua init\` for this agent will restore an older snapshot.`);
-                throw err;
-            }
-        }
-        trackEvent('cli_push_completed', {
-            primitive_type: selectedType,
-            force_mode: options.force || false,
-            auto_deploy: options.autoDeploy || false,
-            entity_selected_by_name: !!options.entityName,
-            type_selected_by_arg: !!type,
-            version_specified: !!options.version,
-            // BAC-196 presigned-upload telemetry. `bundles_total` = unique
-            // content-hashes referenced by this push; `bundles_uploaded` = hashes
-            // the server reported missing and we PUT to S3; `bundles_existed`
-            // measures delta-upload hit rate. Zero for non-versioned types
-            // (mcp/agent/backup) — they don't go through the S3 path.
-            bundles_total: versionedPushDeployResult?.bundleStats?.total ?? 0,
-            bundles_uploaded: versionedPushDeployResult?.bundleStats?.uploaded ?? 0,
-            bundles_existed: versionedPushDeployResult?.bundleStats?.alreadyExisted ?? 0,
-        });
-        const productionDeployedActually = versionedPushDeployResult?.productionDeploySucceeded === true ||
-            (!!agentOutcome && !agentOutcome.cancelled && agentOutcome.productionDeployedWithAutoDeploy);
-        const personaAutoDeployRanAndFailed = selectedType === 'agent' &&
-            options.autoDeploy &&
-            !!agentOutcome &&
-            !agentOutcome.cancelled &&
-            'personaAutoDeployFailed' in agentOutcome &&
-            agentOutcome.personaAutoDeployFailed;
-        if (productionDeployedActually) {
-            writeHintBlock({
-                headline: 'Deployed to production. Generate test traffic first:',
-                lines: [
-                    { label: 'Test:', command: `lua chat -e production -m "your test message"` },
-                    { label: 'Inspect:', command: buildLogsCommand({ primitiveType: selectedType }) },
-                ],
-                when: 'success',
-            });
-        }
-        else {
-            const deployHint = getDeployHint(selectedType);
-            if (personaAutoDeployRanAndFailed) {
-                const lines = [];
-                if (deployHint) {
-                    lines.push(deployHint);
-                }
-                else if (selectedType === 'mcp') {
-                    lines.push({
-                        label: 'Activate:',
-                        command: 'use the Lua dashboard or: lua push mcp --force --auto-deploy  (requires --name when multiple MCP servers)',
-                    });
-                }
-                lines.push({
-                    label: 'Or re-push:',
-                    command: selectedType === 'mcp'
-                        ? 'lua push mcp --force --auto-deploy'
-                        : `lua push ${selectedType} --force --auto-deploy`,
-                });
-                writeHintBlock({
-                    headline: 'Push completed — production persona deploy did not succeed. Try:',
-                    lines,
-                    when: 'partial',
-                });
-            }
-            else if (selectedType === 'backup') {
-                // Backup is not a "live" primitive; skip staged-vs-live framing.
-            }
-            else if (deployHint) {
-                writeHintBlock({
-                    headline: 'Staged but NOT live yet. To make it active:',
-                    lines: [deployHint, { label: 'Or re-push:', command: `lua push ${selectedType} --force --auto-deploy` }],
-                    when: 'success',
-                });
-            }
-            else {
-                writeNextStep({
-                    command: selectedType === 'mcp'
-                        ? 'lua push mcp --force --auto-deploy'
-                        : `lua push ${selectedType} --force --auto-deploy`,
-                    rationale: 'to re-push with auto-activation',
-                    when: 'success',
-                });
-            }
-        }
-    }, 'push');
-}
-/**
- * Push agent configuration (persona, model/modelResolver) to the server.
- *
- * Steps:
- * 1. Compile to get latest manifest
- * 2. Show preview of what will be pushed
- * 3. Confirm (unless --force)
- * 4. Push via agentHandler
- * 5. Optionally deploy persona version
- */
-async function pushAgentVersion(options = {}) {
-    // Step 1: Compile to get fresh manifest
-    writeProgress('🔄 Compiling...');
-    await compileCommand();
-    const config = readYamlConfig();
-    if (!config || !config.agent?.agentId) {
-        throw new Error("No agent configuration found. Please run 'lua init' first.");
-    }
-    const manifest = loadManifest();
-    const agentId = config.agent.agentId;
-    const agent = getPrimitivesByKind(manifest, PrimitiveKind.AGENT)[0];
-    const persona = agent?.persona;
-    const model = agent?.model;
-    const hasModelResolver = agent?.hasModelResolver;
-    if (!hasPersonaTextContent(persona) && !model && !hasModelResolver) {
-        throw new Error('No agent configuration to push (no persona or model found).');
-    }
-    writeInfo(`📦 Pushing agent config for: ${agentId}`);
-    // Show preview
-    if (hasPersonaTextContent(persona)) {
-        // Channel-agnostic — preview shows the full persona content regardless
-        // of which channel branches are populated.
-        const personaText = flattenPersonaTextAll(persona);
-        const preview = personaText.length > 200 ? personaText.substring(0, 200) + '...' : personaText;
-        console.log('\nPersona preview:');
-        console.log(preview);
-    }
-    if (model) {
-        console.log(`\nModel: ${model}`);
-    }
-    console.log();
-    // Confirm (skip if --force)
-    if (!options.force) {
-        const confirmAnswer = await safePrompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Push agent configuration to server?',
-                default: true,
-            },
-        ]);
-        if (!confirmAnswer || !confirmAnswer.confirm) {
-            console.log('\n❌ Push cancelled.\n');
-            return { cancelled: true };
-        }
-    }
-    // Authenticate
-    const apiKey = await authenticateOrFail();
-    writeProgress('✅ Authenticated');
-    // Push via agentHandler
-    const result = await agentHandler.pushAgentConfig(apiKey, agentId, manifest);
-    let productionDeployedWithAutoDeploy = false;
-    let personaDeployWasAttempted = false;
-    const personaDeployEligible = !!(result.persona?.success && result.persona.version);
-    // B4: only ask about deploy when a persona was actually pushed — avoid the prompt
-    // when push failed or was a model-only push with no persona version created.
-    if (personaDeployEligible) {
-        const shouldDeploy = await shouldDeployAfterPush(options);
-        if (shouldDeploy) {
-            personaDeployWasAttempted = true;
-            productionDeployedWithAutoDeploy = await deployPersonaVersionAfterPush(apiKey, agentId, result.persona.version, options.autoDeploy || false);
-        }
-        else {
-            writeInfo('💡 You can deploy the persona version later using: lua deploy');
-        }
-    }
-    const personaAutoDeployFailed = Boolean(options.autoDeploy && personaDeployEligible && personaDeployWasAttempted && !productionDeployedWithAutoDeploy);
-    return { cancelled: false, productionDeployedWithAutoDeploy, personaAutoDeployFailed };
-}
-/**
- * Deploy a persona version immediately after pushing
- */
-async function deployPersonaVersionAfterPush(apiKey, agentId, versionNum, skipConfirmation = false) {
-    try {
-        // Skip confirmation when called from auto-deploy with --force
-        if (!skipConfirmation) {
-            // Show warning
-            console.log('\n⚠️  WARNING: You are about to deploy to PRODUCTION!');
-            console.log('⚠️  This will affect ALL users immediately.\n');
-            const confirmAnswer = await safePrompt([
-                {
-                    type: 'confirm',
-                    name: 'confirm',
-                    message: 'Are you absolutely sure you want to deploy this persona version?',
-                    default: false,
-                },
-            ]);
-            if (!confirmAnswer || !confirmAnswer.confirm) {
-                console.log('\n❌ Deployment cancelled. Persona version created but not deployed.\n');
-                return false;
-            }
-        }
-        writeProgress('🔄 Deploying persona version...');
-        const personaApi = new PersonaApi(BASE_URLS.API, apiKey, agentId);
-        const deployResult = await personaApi.deployVersion(versionNum);
-        if (!deployResult.success) {
-            console.error(`\n❌ Deploy Error: ${deployResult.error?.message || 'Unknown error'}\n`);
-            // Persona deploy is a management operation — no execution logs exist.
-            writeTip('Retry with: lua push agent');
-            throw new Error(deployResult.error?.message || 'Failed to deploy persona version');
-        }
-        writeSuccess(`\n✅ Persona version ${versionNum} deployed successfully to production\n`);
-        writeInfo('💡 The new persona is now active for all users.');
-        return true;
-    }
-    catch (error) {
-        console.error('\n❌ Error deploying persona version:', error);
-        writeTip('Retry with: lua push agent');
-        return false;
-    }
-}
-/**
- * Push MCP server (non-versioned, upsert pattern).
- * Uses the same compile→auth→config→select pattern as versioned primitives,
- * with MCP-specific logic delegated to the handler.
- */
-async function pushMCPServer(options = {}) {
-    try {
-        writeProgress('📦 Compiling project...');
-        await compileCommand();
-        writeSuccess('✅ Compilation complete');
-        const apiKey = await authenticateOrFail();
-        writeSuccess('✅ Authentication verified');
-        const config = readYamlConfig();
-        if (!config?.agent?.agentId) {
-            throw new Error("No agent ID found. Run 'lua init' first.");
-        }
-        const agentId = config.agent.agentId;
-        const { mcpServerHandler } = await import('../primitives/mcp-server.handler.js');
-        const bundledServers = mcpServerHandler.loadBundledItems();
-        if (bundledServers.length === 0) {
-            throw new Error('No MCP servers found in compiled output.');
-        }
-        const selectedServer = await selectEntityOrFail(bundledServers, options, {
-            entityType: 'MCP server',
-            nameFields: ['name'],
-            formatChoice: (s) => `${s.name} (${s.transport})`,
-        });
-        writeProgress(`\n🚀 Pushing MCP server "${selectedServer.name}"...`);
-        // upsertOnServer persists the returned id into lua.skill.yaml on success.
-        const result = await mcpServerHandler.upsertOnServer(apiKey, agentId, selectedServer);
-        if (!result.success) {
-            // Push rejected — reason already on screen; no execution logs exist for a failed push.
-            throw new Error(`Failed: ${result.error}`);
-        }
-        writeSuccess(`\n✅ MCP server "${selectedServer.name}" pushed successfully\n`);
-        let activated = false;
-        if (result.id && (await shouldDeployAfterPush(options))) {
-            writeProgress('🔄 Activating MCP server...');
-            const activateResult = await mcpServerHandler.activate(apiKey, agentId, result.id);
-            if (activateResult.success) {
-                writeSuccess(`✅ MCP server activated\n`);
-                activated = true;
-            }
-        }
-        return activated;
-    }
-    catch (error) {
-        throw error;
-    }
-    return false; // unreachable — catch always rethrows
-}
-/**
- * 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 = readYamlConfig();
-    if (!config?.agent?.agentId) {
-        throw new Error('No agent ID found in lua.skill.yaml. Run "lua init" first.');
-    }
-    const apiKey = await requireAuthOrExit(false);
-    const agentId = config.agent.agentId;
-    // Step 3: Load manifest
-    let manifest;
-    try {
-        manifest = loadManifest();
-    }
-    catch (error) {
-        throw new Error(`Compilation output not found. Compilation may have failed. ${error.message}`);
-    }
-    // Track results and deploy queue per handler
-    const allResults = [];
-    const toDeploy = [];
-    // Per-item failures collected across all push surfaces (versioned
-    // primitives + MCP). Drives the post-run aggregate `⚠️ N component(s)
-    // failed` block and the final partial/error writeNextStep variant.
-    const failedItems = [];
-    let deployFailedCount = 0;
-    let personaPushResult = null;
-    let backupSuccess = false;
-    // BAC-196: aggregate bundle-upload stats across all primitives in the run.
-    const bundleStatsAggregate = { total: 0, uploaded: 0, existed: 0 };
-    // Icons per kind for display
-    const kindIcons = {
-        skill: '📦',
-        webhook: '🪝',
-        job: '⏰',
-        preprocessor: '📥',
-        postprocessor: '📤',
-        device: '📡',
-    };
-    // Step 4: Pre-fetch highest versions in parallel (one HTTP call per handler type)
-    const handlers = [
-        skillH,
-        webhookH,
-        jobH,
-        preprocessorH,
-        postprocessorH,
-        deviceH,
-        deviceTriggerH,
-    ];
-    // Collect entity IDs per handler and batch-fetch versions in parallel
-    const handlerItems = handlers
-        .map((handler) => ({
-        handler,
-        items: handler.getFromYaml(config).filter((item) => {
-            const entityId = item[handler.yamlConfig.idField];
-            return entityId && item.version;
-        }),
-    }))
-        .filter((h) => h.items.length > 0);
-    const versionMaps = await Promise.all(handlerItems.map(async ({ handler, items }) => {
-        const entityIds = items.map((item) => item[handler.yamlConfig.idField]);
-        const versions = await handler.batchGetHighestVersions(apiKey, agentId, entityIds);
-        return { handler, versions };
-    }));
-    const versionLookup = new Map();
-    for (const { handler, versions } of versionMaps) {
-        versionLookup.set(handler, versions);
-    }
-    // Step 5: Push all versioned primitives (versions already pre-fetched)
-    for (const handler of handlers) {
-        const items = handler.getFromYaml(config);
-        if (items.length === 0)
-            continue;
-        const icon = kindIcons[handler.kind] || '📦';
-        writeProgress(`\n${icon} Pushing ${items.length} ${handler.displayName}(s)...`);
-        const handlerVersions = versionLookup.get(handler);
-        for (const item of items) {
-            try {
-                const bundleAccumulator = new Map();
-                const pushData = handler.prepareForPush(manifest, item.name, undefined, bundleAccumulator);
-                if (!pushData) {
-                    console.warn(`⚠️  ${handler.displayName} "${item.name}" not found in compiled output, skipping`);
-                    continue;
-                }
-                if (bundleAccumulator.size > 0) {
-                    const stats = await ensureBundlesUploaded(apiKey, agentId, bundleAccumulator);
-                    bundleStatsAggregate.total += stats.total;
-                    bundleStatsAggregate.uploaded += stats.uploaded;
-                    bundleStatsAggregate.existed += stats.alreadyExisted;
-                }
-                const entityId = item[handler.yamlConfig.idField];
-                if (!entityId) {
-                    console.warn(`⚠️  ${handler.displayName} "${item.name}" has no server ID, skipping. Run 'lua compile' first.`);
-                    continue;
-                }
-                if (!item.version) {
-                    console.warn(`⚠️  ${handler.displayName} "${item.name}" has no version, skipping`);
-                    continue;
-                }
-                // Auto-bump version (use pre-fetched server version to avoid conflicts)
-                const serverHighest = handlerVersions?.get(entityId) ?? null;
-                const baseVersion = serverHighest ? maxSemver(item.version, serverHighest) : item.version;
-                let newVersion = incrementPatchVersion(baseVersion);
-                writeInfo(`  📝 ${item.name}: ${item.version} → ${newVersion}`);
-                // Push
-                let result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: newVersion });
-                // On version collision, re-fetch the server's current highest version
-                // and try once more. The pre-fetch in step 4 is racey against
-                // concurrent pushes by the same/another user; a single re-bump
-                // resolves the dominant collision pattern observed in production.
-                if (!result.success && result.error?.toLowerCase().includes('already exists')) {
-                    console.log(`  ⚠️  Version collision on ${item.name}, refetching server state and retrying...`);
-                    const freshHighest = await handler.getHighestServerVersion(apiKey, agentId, entityId);
-                    if (freshHighest) {
-                        const retryVersion = incrementPatchVersion(freshHighest);
-                        writeInfo(`  📝 ${item.name}: re-bumped ${newVersion} → ${retryVersion} after collision`);
-                        result = await handler.pushToServer(apiKey, agentId, entityId, { ...pushData, version: retryVersion });
-                        if (result.success) {
-                            newVersion = retryVersion;
-                        }
-                    }
-                }
-                if (!result.success) {
-                    console.error(`  ❌ Failed to push ${item.name}: ${result.error}`);
-                    failedItems.push({ kind: handler.kind, name: item.name, error: result.error || 'Unknown error' });
-                    continue;
-                }
-                handler.updateVersionInYaml(item.name, newVersion, { silent: true });
-                allResults.push({ handler, name: item.name, version: newVersion, entityId });
-                writeSuccess(`  ✅ ${item.name} v${newVersion} pushed`);
-                if (options.autoDeploy) {
-                    toDeploy.push({ handler, name: item.name, version: newVersion, entityId });
-                }
-            }
-            catch (error) {
-                // Auth errors must propagate so withErrorHandling treats them as
-                // fatal, otherwise the loop continues against a known-broken auth
-                // state. Matches the re-throw pattern in batchGetHighestVersions /
-                // getHighestServerVersion.
-                if (AuthenticationError.isAuthenticationError(error))
-                    throw error;
-                console.error(`  ❌ Failed to push ${item.name}: ${error.message}`);
-                failedItems.push({ kind: handler.kind, name: item.name, error: error.message || 'Unknown error' });
-            }
-        }
-    }
-    // Step 6: Push MCP server configurations (non-versioned, upsert-by-name).
-    // push.ts loads bundled servers once and hands them to pushAll, which
-    // upserts each, persists returned ids into lua.skill.yaml, and activates
-    // when --auto-deploy is set. Here we only print the summary.
-    const { mcpServerHandler: mcpH } = await import('../primitives/mcp-server.handler.js');
-    const bundledMcp = mcpH.loadBundledItems();
-    let mcpPushedCount = 0; // tracks actual successes, not just attempts (B2)
-    if (bundledMcp.length > 0) {
-        writeProgress(`\n🔌 Pushing ${bundledMcp.length} MCP server(s)...`);
-        const mcpResult = await mcpH.pushAll(bundledMcp, apiKey, agentId, { autoDeploy: options.autoDeploy });
-        mcpPushedCount = mcpResult.pushed.length;
-        for (const name of mcpResult.pushed) {
-            writeSuccess(`  ✅ ${name}`);
-            if (mcpResult.activated.includes(name))
-                writeSuccess(`     🔌 Auto-activated`);
-        }
-        for (const { name, error } of mcpResult.failed) {
-            console.error(`  ❌ Failed to push ${name}: ${error}`);
-            failedItems.push({ kind: 'mcp', name, error: error || 'Unknown error' });
-        }
-    }
-    // Aggregate failure block: emit a single grouped summary with a per-item
-    // `lua logs` diagnose hint so users can jump straight to the failing
-    // component's logs without scrolling back through interleaved push output.
-    // Printed before agent config push so the user sees component failures
-    // alongside the persona/backup status that follows.
-    if (failedItems.length > 0) {
-        console.error(formatPushFailureSummary(failedItems));
-    }
-    // Step 6.5: Push agent config (persona, model/modelResolver)
-    const agentPushResult = await agentHandler.pushAgentConfig(apiKey, agentId, manifest);
-    if (agentPushResult.persona?.success) {
-        personaPushResult = { version: agentPushResult.persona.version };
-    }
-    // Persona push creates a new version but doesn't activate it. Without
-    // --auto-deploy the dashboard keeps showing the previously-deployed
-    // version, which is surprising since other primitives feel "live" after
-    // push. Mirror the hint that `push agent` already prints.
-    if (personaPushResult && !options.autoDeploy) {
-        writeInfo(`💡 Persona v${personaPushResult.version} pushed but not active on the dashboard yet.`);
-        writeInfo('   Run `lua deploy` or re-push with `--auto-deploy` to activate it.');
-    }
-    // Step 7: Deploy all queued components
-    if (options.autoDeploy && toDeploy.length > 0) {
-        writeProgress('\n🚀 Deploying all pushed versions to production...');
-        writeInfo('⏱️  Waiting for server to process versions (5 seconds)...\n');
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-        for (const item of toDeploy) {
-            const deployed = await retryDeploy(async () => {
-                const result = await item.handler.publishVersion(apiKey, agentId, item.entityId, item.version);
-                if (!result.success)
-                    throw new Error(result.error || 'Deploy failed');
-            }, item.name, item.version, 3);
-            if (deployed) {
-                writeSuccess(`  🚀 ${item.name} v${item.version} deployed`);
-            }
-            else {
-                console.warn(`  ⚠️  ${item.name} deployment failed`);
-                deployFailedCount++;
-            }
-        }
-    }
-    // Deploy persona if pushed and autoDeploy is on
-    if (personaPushResult && options.autoDeploy) {
-        const deployed = await retryDeploy(async () => {
-            const personaApi = new PersonaApi(BASE_URLS.API, apiKey, agentId);
-            const deployResult = await personaApi.deployVersion(personaPushResult.version);
-            if (!deployResult.success)
-                throw new Error(deployResult.error?.message || 'Deploy failed');
-        }, 'persona', String(personaPushResult.version), 3);
-        if (deployed) {
-            writeSuccess(`  🚀 Persona v${personaPushResult.version} deployed`);
-        }
-        else {
-            console.warn(`  ⚠️  Persona deployment failed`);
-            deployFailedCount++;
-        }
-    }
-    // Step 7.5: Push source backup (Phase 2 task 2.5: auto-backup hook).
-    // No try/catch by design — if the auto-backup-push fails, the whole
-    // `lua push all` should exit non-zero. Phase 2's deploy-invariant is
-    // that a primitive push never silently leaves the server's source
-    // backup out-of-date. Use runBackupPush (not pushBackupCommand) for
-    // the same reasons as the per-primitive hook above.
-    writeProgress('\n💾 Pushing source backup...');
-    {
-        const hookApiKey = requireAuthOrExit(false);
-        const hookConfig = readYamlConfig();
-        const hookAgentId = hookConfig?.agent?.agentId;
-        if (!hookAgentId) {
-            throw new Error('Cannot run auto-backup: no agentId in lua.skill.yaml.');
-        }
-        try {
-            const hookResult = await runBackupPush({
-                apiKey: hookApiKey,
-                agentId: hookAgentId,
-                force: true,
-                fresh: true,
-                triggeredBy: 'batch push',
-            });
-            writeInfo(`💾 Backup at v${hookResult.activeVersion} (${hookResult.filesUploaded} new file(s))`);
-            backupSuccess = true;
-        }
-        catch (err) {
-            const reason = err instanceof Error ? err.message : String(err);
-            writeError(`Source backup failed after batch push: ${reason}\n\n` +
-                `All primitives in this batch ARE deployed and live on the server — do NOT re-push.\n` +
-                `The source backup just didn't sync. Recover with:\n\n` +
-                `    lua push backup --force --fresh\n\n` +
-                `Until the backup catches up, \`lua init\` for this agent will restore an older snapshot.`);
-            throw err;
-        }
-    }
-    // Step 8: Print summary
-    writeSuccess('\n✅ Push All Complete!\n');
-    // Group results by kind for display
-    const byKind = new Map();
-    for (const r of allResults) {
-        const kind = r.handler.displayNamePlural;
-        if (!byKind.has(kind))
-            byKind.set(kind, []);
-        byKind.get(kind).push(r);
-    }
-    const summaryIcons = {
-        skills: '🛠️ ',
-        webhooks: '🪝',
-        jobs: '⏰',
-        preprocessors: '📥',
-        postprocessors: '📤',
-    };
-    for (const [kind, items] of byKind) {
-        const icon = summaryIcons[kind] || '📦';
-        console.log(`${icon} ${kind.charAt(0).toUpperCase() + kind.slice(1)} (${items.length}):`);
-        items.forEach((i) => console.log(`   • ${i.name} v${i.version}`));
-    }
-    if (personaPushResult) {
-        console.log(`🌙 Persona:`);
-        console.log(`   • Version ${personaPushResult.version} created`);
-    }
-    if (backupSuccess) {
-        console.log(`💾 Backup:`);
-        console.log(`   • Source files pushed`);
-    }
-    if (options.autoDeploy) {
-        writeSuccess('\n🚀 All components deployed to production!');
-    }
-    const kindCounts = {};
-    for (const [kind, items] of byKind) {
-        kindCounts[kind] = items.length;
-    }
-    trackEvent('cli_push_completed', {
-        primitive_type: 'all',
-        force_mode: true,
-        auto_deploy: options.autoDeploy || false,
-        primitives_pushed_count: allResults.length,
-        primitives_by_kind: kindCounts,
-        mcp_servers_pushed: mcpPushedCount,
-        persona_pushed: !!personaPushResult,
-        backup_pushed: backupSuccess,
-        // BAC-196 presigned-upload telemetry, summed across every primitive
-        // pushed in this run. `bundles_existed` measures delta-upload hit rate.
-        bundles_total: bundleStatsAggregate.total,
-        bundles_uploaded: bundleStatsAggregate.uploaded,
-        bundles_existed: bundleStatsAggregate.existed,
-    });
-    // B2: use actual successful MCP pushes, not attempt count, to determine pushedSomething.
-    const pushedSomething = allResults.length > 0 || mcpPushedCount > 0 || !!personaPushResult || backupSuccess;
-    // Pick the right hint variant based on the run outcome. We deliberately
-    // ungate the tip from `pushedSomething` for the all-failed case so a
-    // 100%-failed `lua push all --force` still surfaces a `lua logs` nudge
-    // (previously it was silent, leaving users to guess what to do next).
-    const variant = pickPushAllNextStepVariant({
-        pushedSomething,
-        failedCount: failedItems.length + deployFailedCount,
-    });
-    if (variant === 'success') {
-        console.log('');
-        if (options.autoDeploy) {
-            writeHintBlock({
-                headline: 'All deployed. Generate test traffic first, then inspect:',
-                lines: [
-                    { label: 'Test:', command: 'lua chat -e production -m "your test message"' },
-                    { label: 'Inspect:', command: buildLogsCommand({ limit: 10 }) },
-                ],
-                when: 'success',
-            });
-        }
-        else {
-            writeHintBlock({
-                headline: 'Code staged but NOT live. Make it active:',
-                lines: [
-                    { label: 'Deploy all:', command: 'lua deploy all --force' },
-                    { label: 'Or re-push:', command: 'lua push all --force --auto-deploy' },
-                ],
-                when: 'success',
-            });
-        }
-    }
-    else if (variant === 'partial') {
-        console.log('');
-        // Some components pushed, some failed. Suggest re-pushing the failures.
-        // No lua logs hint: failed pushes produce no execution logs.
-        writeNextStep({
-            command: 'lua push all --force',
-            rationale: 'to re-attempt the failed components',
-            when: 'partial',
-        });
-    }
-    else if (variant === 'error') {
-        console.log('');
-        // Total failure — nothing pushed, no execution logs exist.
-        // No hint: the errors are already shown above.
-    }
-}
-/**
- * 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 {
-            // Only delay on retry attempts (not first attempt)
-            if (attempt > 1) {
-                const delay = attempt * 2000; // 2s on 2nd attempt, 4s on 3rd, etc.
-                await new Promise((resolve) => setTimeout(resolve, delay));
-            }
-            await deployFn();
-            // Show success message if succeeded after retrying
-            if (attempt > 1) {
-                writeInfo(`    ✓ Succeeded on retry ${attempt}/${maxRetries}`);
-            }
-            return true;
-        }
-        catch (error) {
-            // Extract detailed error message from API response
-            const errorMessage = error?.error?.message || error?.message || 'Unknown error';
-            if (attempt < maxRetries) {
-                // Intermediate retry - show brief info
-                writeInfo(`    [Attempt ${attempt}/${maxRetries}] ${errorMessage} - retrying...`);
-            }
-            else {
-                // Final attempt failed - show error
-                console.error(`    ❌ [Attempt ${attempt}/${maxRetries}] Deploy failed: ${errorMessage}`);
-            }
-        }
-    }
-    return false;
-}
-//# sourceMappingURL=push.js.map