lua-cli 3.15.3 → 3.16.0

package/dist/commands/init.js

@@ -1,992 +0,0 @@
-/**
- * Init Command
- * Orchestrates the initialization of a new Lua skill project
- */
-import inquirer from 'inquirer';
-import { checkApiKey } from '../services/auth.js';
-import { requireAuthOrExit } from '../utils/command-utils.js';
-import { withErrorHandling, writeProgress, writeSuccess, writeInfo, writeError, writeHintBlock } from '../utils/cli.js';
-import { promptAgentChoice, promptOrganizationSelection, promptAgentSelection, promptMetadataCollection, promptAgentName, promptModelSelection, displayPersonaInstructions, promptDuplicateOptions, } from '../utils/init-prompts.js';
-import { fetchAgentTypes, selectBaseAgentType, createNewAgent, fetchExistingAgentDetails, fetchApprovedModels, validateModelCode, updateAgentModel, } from '../utils/init-agent.js';
-import { initializeProject, installDependencies, clearLinesIfNeeded } from '../utils/init-helpers.js';
-import { readYamlConfig, updateYamlAgent, writeYamlConfig } from '../utils/files.js';
-import BackupApi from '../api/backup.api.service.js';
-import AgentApi from '../api/agent.api.service.js';
-import { restoreProjectFromBackup, checkRestoreConflicts, downloadBlobsParallel, fetchBackupManifestForPull, } from '../utils/backup-helpers.js';
-import { BASE_URLS } from '../config/constants.js';
-import { trackEvent } from '../services/analytics.js';
-import { agentHandler } from '../primitives/agent.handler.js';
-import { fetchServerName, fetchServerPersona, fetchServerModel } from '../utils/sync-fetch.js';
-/**
- * Determines the init mode based on provided options.
- * Validates that options are used correctly.
- */
-function determineInitMode(options) {
-    const { agentId, agentName, orgId, orgName, fromAgentId } = options;
-    // --from-agent-id provided (duplicate agent)
-    if (fromAgentId) {
-        // Cannot combine with --agent-id (different mode)
-        if (agentId) {
-            return {
-                type: 'error',
-                message: '--from-agent-id cannot be combined with --agent-id',
-            };
-        }
-        // --org-id and --org-name are mutually exclusive
-        if (orgId && orgName) {
-            return {
-                type: 'error',
-                message: 'Cannot use both --org-id and --org-name together',
-            };
-        }
-        // --agent-name is reused as the new name for the duplicate (optional)
-        return {
-            type: 'duplicate-agent',
-            sourceAgentId: fromAgentId,
-            orgId,
-            orgName,
-            newName: agentName,
-        };
-    }
-    // No non-interactive flags provided
-    if (!agentId && !agentName && !orgId && !orgName) {
-        return { type: 'interactive' };
-    }
-    // --agent-id provided (use existing agent)
-    if (agentId) {
-        // Cannot combine with new agent flags
-        if (agentName || orgId || orgName) {
-            return {
-                type: 'error',
-                message: '--agent-id cannot be combined with --agent-name, --org-id, or --org-name',
-            };
-        }
-        return { type: 'existing-agent', agentId };
-    }
-    // --agent-name provided (create new agent)
-    if (agentName) {
-        // Must have either --org-id or --org-name, but not both
-        if (!orgId && !orgName) {
-            return {
-                type: 'error',
-                message: '--agent-name requires either --org-id or --org-name',
-            };
-        }
-        if (orgId && orgName) {
-            return {
-                type: 'error',
-                message: 'Cannot use both --org-id and --org-name together',
-            };
-        }
-        return { type: 'new-agent', agentName, orgId, orgName };
-    }
-    // --org-id or --org-name without --agent-name
-    if (orgId || orgName) {
-        return {
-            type: 'error',
-            message: '--org-id and --org-name require --agent-name',
-        };
-    }
-    return { type: 'interactive' };
-}
-/**
- * Shows usage help for non-interactive init
- */
-function showInitUsage() {
-    console.log('\nUsage:');
-    console.log('  lua init --agent-id <id>                              Use existing agent');
-    console.log('  lua init --agent-name <name> --org-id <id>            Create agent in existing org');
-    console.log('  lua init --agent-name <name> --org-name <name>        Create agent + new org');
-    console.log('  lua init --agent-id <id> --force                      Override existing project');
-    console.log('  lua init --agent-id <id> --restore-sources            Restore project from backup');
-    console.log('  lua init --from-agent-id <id>                          Duplicate an existing agent + scaffold');
-}
-/**
- * Non-interactive: Duplicates an existing agent into a new one.
- *
- * @param apiKey - User's API key
- * @param userData - User data containing organizations
- * @param mode - Duplicate mode with sourceAgentId, orgId, orgName, newName
- * @param options - Init command options for include flags
- * @returns Created agent, organization, and optional persona
- */
-async function duplicateAgentNonInteractive(apiKey, userData, mode, options) {
-    // Find the source agent's org
-    const orgs = userData.admin?.orgs || [];
-    let sourceOrgId;
-    for (const org of orgs) {
-        const agent = org.agents?.find((a) => a.agentId === mode.sourceAgentId);
-        if (agent) {
-            sourceOrgId = org.id;
-            break;
-        }
-    }
-    if (!sourceOrgId) {
-        throw new Error(`Cannot duplicate "${mode.sourceAgentId}": agent not found in any organization where you are an admin. ` +
-            `Duplicating an agent requires admin access to its org. ` +
-            `If you have non-admin access, ask an admin to perform the duplicate.`);
-    }
-    // Resolve target org ID
-    let targetOrgId;
-    if (mode.orgId) {
-        // Validate the org exists
-        const existingOrg = orgs.find((o) => o.id === mode.orgId);
-        if (!existingOrg) {
-            console.error(`❌ Organization not found: ${mode.orgId}`);
-            writeInfo('\nAvailable organizations:');
-            for (const org of orgs) {
-                writeInfo(`  - ${org.registeredName} (${org.id})`);
-            }
-            throw new Error('Operation failed');
-        }
-        targetOrgId = mode.orgId;
-        writeProgress(`✅ Using target organization: ${existingOrg.registeredName}`);
-    }
-    else if (mode.orgName) {
-        // Find org by name (case-insensitive)
-        const matchedOrg = orgs.find((o) => o.registeredName.toLowerCase() === mode.orgName.toLowerCase());
-        if (matchedOrg) {
-            targetOrgId = matchedOrg.id;
-            writeProgress(`✅ Found target organization: ${matchedOrg.registeredName}`);
-        }
-        else {
-            console.error(`❌ Organization not found: ${mode.orgName}`);
-            writeInfo('\nAvailable organizations:');
-            for (const org of orgs) {
-                writeInfo(`  - ${org.registeredName} (${org.id})`);
-            }
-            throw new Error('Operation failed');
-        }
-    }
-    else {
-        // Use source org
-        targetOrgId = sourceOrgId;
-    }
-    return runAgentDuplication({
-        apiKey,
-        sourceAgentId: mode.sourceAgentId,
-        sourceOrgId,
-        targetOrgId: targetOrgId,
-        newName: mode.newName,
-        include: {
-            resources: options.includeResources,
-            customData: options.includeCustomData,
-            inquiryForm: options.includeInquiryForm,
-            devices: options.includeDevices,
-            ecommerceCatalog: options.includeEcommerceCatalog,
-        },
-        orgs,
-        nonInteractive: true,
-    });
-}
-/**
- * Shared core for both interactive and non-interactive duplicate flows:
- * builds the request, calls the API, handles errors with telemetry,
- * prints copied counts + warnings, fires the success event, and returns
- * the resolved agent + org.
- */
-async function runAgentDuplication(params) {
-    const { apiKey, sourceAgentId, sourceOrgId, targetOrgId, newName, include, orgs, nonInteractive } = params;
-    const body = { newName, include };
-    if (targetOrgId !== sourceOrgId) {
-        body.targetOrgId = targetOrgId;
-    }
-    const includedBuckets = [
-        include?.resources && 'resources',
-        include?.customData && 'customData',
-        include?.inquiryForm && 'inquiryForm',
-        include?.devices && 'devices',
-        include?.ecommerceCatalog && 'ecommerceCatalog',
-    ].filter(Boolean);
-    const crossOrg = targetOrgId !== sourceOrgId;
-    writeProgress(`✅ Duplicating agent: ${sourceAgentId}`);
-    const agentApi = new AgentApi(BASE_URLS.API, apiKey);
-    const response = await agentApi.duplicateAgent(sourceOrgId, sourceAgentId, body);
-    if (!response.success) {
-        trackEvent('cli_init_duplicate_failed', {
-            non_interactive: nonInteractive,
-            cross_org: crossOrg,
-            included_buckets: includedBuckets,
-            status_code: response.error?.statusCode,
-            error_message: response.error?.message,
-        });
-        throw new Error(response.error?.message || 'Failed to duplicate agent');
-    }
-    const data = response.data;
-    writeSuccess(`✅ Agent duplicated successfully`);
-    writeInfo(`   New Agent ID: ${data.agentId}`);
-    writeInfo(`   Name: ${data.name}`);
-    writeInfo(`   Org: ${data.orgId}`);
-    if (Object.keys(data.copied).length > 0) {
-        writeInfo(`\n📦 Copied resources:`);
-        for (const [key, count] of Object.entries(data.copied)) {
-            writeInfo(`   ${key}: ${count}`);
-        }
-    }
-    if (data.warnings.length > 0) {
-        writeInfo(`\n⚠️  Warnings:`);
-        for (const warning of data.warnings) {
-            writeInfo(`   ${warning}`);
-        }
-    }
-    trackEvent('cli_init_duplicate_completed', {
-        non_interactive: nonInteractive,
-        cross_org: crossOrg,
-        included_buckets: includedBuckets,
-    });
-    // Trust the API response for the resolved org id. Don't propagate the cached
-    // `agents` array — it's stale (won't include the just-created agent) and
-    // downstream callers don't read it.
-    const targetOrg = orgs.find((o) => o.id === data.orgId);
-    // The just-duplicated agent already has the model copied from source.
-    // Fetch it so the caller can skip the model prompt — no point asking the
-    // user to pick a model when the duplicate flow inherits the source's.
-    let inheritedModel;
-    try {
-        const fetched = await fetchServerModel(apiKey, data.agentId);
-        if (fetched)
-            inheritedModel = fetched;
-    }
-    catch {
-        // Non-fatal — caller will fall back to its existing prompt/default path.
-    }
-    return {
-        agent: { agentId: data.agentId, name: data.name },
-        org: { id: data.orgId, name: targetOrg?.registeredName },
-        persona: undefined,
-        model: inheritedModel,
-        warnings: data.warnings,
-    };
-}
-/**
- * Interactive: prompts the user to select a source agent + duplicate options
- * and runs the duplication. Mirrors `duplicateAgentNonInteractive` but with
- * inquirer prompts in place of CLI flags.
- *
- * Throws on cancellation so the caller can exit cleanly.
- */
-async function duplicateAgentInteractive(apiKey, userData) {
-    const orgs = userData.admin?.orgs || [];
-    if (orgs.length === 0) {
-        throw new Error('No organizations found.');
-    }
-    // Pick source org + source agent — reuse existing prompts
-    const sourceOrg = await promptOrganizationSelection(orgs);
-    const sourceAgent = await promptAgentSelection(sourceOrg);
-    // Duplicate-specific prompts (target org if cross-org-eligible, name, include flags, confirm)
-    const promptResult = await promptDuplicateOptions(sourceOrg, orgs, sourceAgent.name);
-    if (!promptResult.confirmed) {
-        writeInfo('\n❌ Cancelled.\n');
-        return null;
-    }
-    return runAgentDuplication({
-        apiKey,
-        sourceAgentId: sourceAgent.agentId,
-        sourceOrgId: sourceOrg.id,
-        targetOrgId: promptResult.targetOrg.id,
-        newName: promptResult.newName,
-        include: promptResult.include,
-        orgs,
-        nonInteractive: false,
-    });
-}
-/**
- * Main init command - initializes a new Lua skill project.
- *
- * This command performs the following steps:
- * 1. Authenticates the user
- * 2. Prompts to select existing agent or create new one
- * 3. For existing: Lets user select organization and agent
- * 4. For new: Collects configuration and creates agent
- * 5. Copies template files to current directory
- * 6. Creates lua.skill.yaml configuration
- * 7. Installs npm dependencies
- *
- * Features:
- * - Interactive agent selection or creation
- * - Non-interactive mode with --agent-id or --agent-name flags
- * - Organization management
- * - Business configuration
- * - Agent type selection (defaults to Base Agent)
- * - Feature configuration
- * - Automatic project scaffolding
- * - Dependency installation
- * - Optional example code with --with-examples flag
- *
- * @param options - Command options including --with-examples and non-interactive flags
- * @returns Promise that resolves when initialization is complete
- */
-export async function initCommand(options = {}) {
-    const withExamples = options.withExamples ?? false;
-    return withErrorHandling(async () => {
-        // Step 1: Determine init mode
-        const mode = determineInitMode(options);
-        if (mode.type === 'error') {
-            console.error(`❌ ${mode.message}`);
-            showInitUsage();
-            throw new Error(`${mode.message}`);
-        }
-        const isNonInteractive = mode.type !== 'interactive';
-        // Step 2: Authenticate
-        const apiKey = await requireAuthOrExit(false);
-        const userData = await checkApiKey(apiKey);
-        writeProgress('✅ Authenticated');
-        // Step 3: Check for existing YAML file
-        const existingYaml = readYamlConfig();
-        const yamlExists = existingYaml !== null;
-        if (yamlExists) {
-            const existingAgentId = existingYaml?.agent?.agentId;
-            if (existingAgentId) {
-                // Non-interactive mode: require --force to override
-                if (isNonInteractive && !options.force) {
-                    writeError('\n⚠️  Project already initialized with an agent');
-                    writeInfo(`   Current Agent ID: ${existingAgentId}`);
-                    writeInfo('\n💡 Use --force to override the existing configuration\n');
-                    throw new Error('Operation failed');
-                }
-                // Non-interactive mode with --force: proceed with override
-                if (isNonInteractive && options.force) {
-                    writeInfo('\n🔄 Overriding existing project configuration...\n');
-                    // Continue to non-interactive flow below
-                }
-                else {
-                    // Interactive mode: check access and prompt
-                    const hasAccess = checkUserHasAccessToAgent(userData, existingAgentId);
-                    if (!hasAccess) {
-                        writeError("\n⚠️  You don't have access to the agent in this project");
-                        writeInfo(`   Agent ID: ${existingAgentId}\n`);
-                        const { action } = await inquirer.prompt([
-                            {
-                                type: 'list',
-                                name: 'action',
-                                message: 'What would you like to do?',
-                                choices: [
-                                    { name: '📧 Contact the agent admin to request access', value: 'contact' },
-                                    { name: '🔄 Switch to a different agent', value: 'switch' },
-                                    { name: '❌ Cancel', value: 'cancel' },
-                                ],
-                            },
-                        ]);
-                        if (action === 'contact') {
-                            writeInfo('\n💡 Please contact the agent administrator to grant you access.');
-                            writeInfo(`   Agent ID: ${existingAgentId}\n`);
-                            process.exit(0);
-                        }
-                        if (action === 'cancel') {
-                            writeInfo('\n❌ Initialization cancelled.\n');
-                            process.exit(0);
-                        }
-                        // User chose to switch agent - update existing YAML only
-                        await handleAgentSwitch(userData, apiKey, existingYaml);
-                        return;
-                    }
-                    else {
-                        // User has access - ask if they want to switch anyway
-                        writeInfo('\n📋 Found existing project configuration');
-                        writeInfo(`   Current Agent ID: ${existingAgentId}\n`);
-                        const { wantSwitch } = await inquirer.prompt([
-                            {
-                                type: 'list',
-                                name: 'wantSwitch',
-                                message: 'Do you want to switch this project to a different agent?',
-                                choices: [
-                                    { name: 'No - Keep current agent', value: false },
-                                    { name: 'Yes - Switch to a different agent', value: true },
-                                ],
-                                default: false,
-                            },
-                        ]);
-                        if (wantSwitch) {
-                            // User wants to switch agent - update existing YAML only
-                            await handleAgentSwitch(userData, apiKey, existingYaml);
-                            return;
-                        }
-                        else {
-                            writeInfo('\n✅ Keeping current agent configuration\n');
-                            process.exit(0);
-                        }
-                    }
-                }
-            }
-        }
-        let selectedAgent;
-        let selectedOrg;
-        let persona;
-        let serverModel;
-        let isNewAgent = false;
-        let selectedModel;
-        // Non-interactive --model flag: validate early
-        if (options.model) {
-            const models = await fetchApprovedModels(apiKey);
-            selectedModel = validateModelCode(models, options.model);
-        }
-        // Step 4: Execute based on mode — select or create agent
-        if (mode.type === 'existing-agent') {
-            const result = await selectExistingAgentById(userData, apiKey, mode.agentId);
-            selectedAgent = result.agent;
-            selectedOrg = result.org;
-            persona = result.persona;
-            serverModel = result.model;
-        }
-        else if (mode.type === 'new-agent') {
-            const result = await createNewAgentNonInteractive(apiKey, userData, mode.agentName, mode.orgId, mode.orgName, options.promoCode, selectedModel);
-            selectedAgent = result.agent;
-            selectedOrg = result.org;
-            persona = result.persona;
-            isNewAgent = true;
-        }
-        else if (mode.type === 'duplicate-agent') {
-            const result = await duplicateAgentNonInteractive(apiKey, userData, mode, options);
-            selectedAgent = result.agent;
-            selectedOrg = result.org;
-            persona = result.persona;
-            // The duplicate inherits the source's model — record it so the prompt
-            // block below sees a serverModel and skips the redundant LLM picker.
-            serverModel = result.model;
-            // CRITICAL: force the existing-agent + restore-sources flow so the new agent's
-            // duplicated project backup is downloaded into the local project.
-            options.restoreSources = true;
-        }
-        else {
-            // Interactive mode
-            const agentChoice = await promptAgentChoice();
-            if (agentChoice === 'existing') {
-                const result = await selectExistingAgent(userData, apiKey);
-                selectedAgent = result.agent;
-                selectedOrg = result.org;
-                persona = result.persona;
-                serverModel = result.model;
-            }
-            else if (agentChoice === 'duplicate') {
-                const result = await duplicateAgentInteractive(apiKey, userData);
-                if (!result) {
-                    // User cancelled at the confirmation step — exit cleanly
-                    return;
-                }
-                selectedAgent = result.agent;
-                selectedOrg = result.org;
-                persona = result.persona;
-                serverModel = result.model;
-                // Mirror the non-interactive duplicate path: force restore-from-backup so
-                // the new agent's project bundle is downloaded into the local project.
-                options.restoreSources = true;
-            }
-            else {
-                const result = await createNewAgentFlow(apiKey, userData, options.promoCode);
-                selectedAgent = result.agent;
-                selectedOrg = result.org;
-                persona = result.persona;
-                selectedModel = result.model;
-                isNewAgent = true;
-            }
-        }
-        // Step 4.5: Check for backup restoration (existing agents only)
-        let sourcesRestored = false;
-        if (!isNewAgent && !yamlExists) {
-            sourcesRestored = await checkAndRestoreBackup(apiKey, selectedAgent.agentId, {
-                interactive: mode.type === 'interactive',
-                autoRestore: options.restoreSources === true,
-            });
-        }
-        // Step 4.6: After restoration, mirror server config (name/persona/model) into source.
-        // Fetch server state directly rather than agentHandler.checkDrift — drift detection
-        // reads from the compilation manifest, which doesn't exist after a fresh init + restore.
-        if (sourcesRestored && !isNewAgent) {
-            try {
-                console.log('\nSyncing agent configuration from server...');
-                const [syncName, syncPersonaData, syncModel] = await Promise.all([
-                    fetchServerName(apiKey, selectedAgent.agentId),
-                    fetchServerPersona(apiKey, selectedAgent.agentId),
-                    fetchServerModel(apiKey, selectedAgent.agentId),
-                ]);
-                if (syncPersonaData?.persona) {
-                    agentHandler.pullPersona(syncPersonaData.persona);
-                }
-                if (syncName) {
-                    agentHandler.pullName(syncName);
-                }
-                if (syncModel) {
-                    agentHandler.pullModel(syncModel);
-                }
-                writeSuccess('  ✅ Agent configuration synced');
-            }
-            catch (error) {
-                writeInfo('  ⚠ Failed to sync agent config — run "lua sync" manually');
-            }
-        }
-        // Resolve model for existing agents (new agents already prompted above).
-        // Backup restored: server sync (Step 4.6) already handled it.
-        // Existing (no backup): use server model if present, else prompt.
-        if (!sourcesRestored && !isNewAgent && !selectedModel) {
-            if (serverModel) {
-                selectedModel = serverModel;
-            }
-            else if (mode.type === 'interactive') {
-                const models = await fetchApprovedModels(apiKey);
-                if (models.length > 0) {
-                    selectedModel = await promptModelSelection(models);
-                }
-            }
-        }
-        // Show persona instructions (new agents only, after all prompts)
-        if (isNewAgent) {
-            displayPersonaInstructions();
-        }
-        // Push model to server only for existing agents where the user explicitly changed it.
-        // New agents already have the model set in the create request — no separate PATCH needed.
-        const userChoseModel = selectedModel && selectedModel !== serverModel;
-        if (userChoseModel && !isNewAgent) {
-            try {
-                writeProgress(`🤖 Setting model: ${selectedModel}...`);
-                await updateAgentModel(apiKey, selectedAgent.agentId, selectedModel);
-                writeProgress(`✅ Model set: ${selectedModel}`);
-            }
-            catch (error) {
-                writeInfo(`⚠️  Could not set model on server — you can push it later with \`lua push agent\``);
-            }
-        }
-        // Step 5: Initialize or update project
-        if (yamlExists) {
-            // Update existing YAML and LuaAgent in index.ts
-            writeInfo('📝 Updating existing lua.skill.yaml with new agent...');
-            updateYamlAgent(selectedAgent.agentId, selectedOrg.id);
-            const { updateAgentConfig } = await import('../compiler/index.js');
-            updateAgentConfig({ name: selectedAgent.name, persona, model: selectedModel }, { projectDir: process.cwd() });
-            writeSuccess('✅ lua.skill.yaml updated successfully!');
-            writeSuccess('✅ LuaAgent configuration updated!');
-        }
-        else {
-            // Full project initialization
-            // Skip template source files if sources were restored from backup
-            const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, selectedAgent.name, withExamples, sourcesRestored, // skipSourceTemplates - don't copy src/ if restored
-            selectedModel);
-            // Step 6: Install dependencies
-            await installDependencies(currentDir);
-            if (sourcesRestored) {
-                writeSuccess('✅ Project initialized with restored sources!');
-                writeInfo("💡 Run 'lua compile' to rebuild from restored sources");
-            }
-            else if (withExamples) {
-                writeSuccess('✅ Lua skill project initialized with examples!');
-                writeInfo('💡 Check the examples/ folder for sample skills, tools, jobs, and webhooks');
-            }
-            else {
-                writeSuccess('✅ Lua skill project initialized successfully!');
-                writeInfo('💡 Tip: Use `lua init --with-examples` to include example code');
-            }
-            writeHintBlock({
-                headline: 'Project ready. Start the build loop:',
-                lines: [
-                    { label: '1. Compile:', command: 'lua compile' },
-                    { label: '2. Test locally:', command: 'lua test' },
-                    { label: '3. Chat in sandbox:', command: 'lua chat -e sandbox -m "test"' },
-                    { label: '4. Push & deploy:', command: 'lua push all --force --auto-deploy' },
-                ],
-                when: 'success',
-            });
-        }
-        // Note: cli_init_duplicate_completed is fired inside runAgentDuplication for
-        // both interactive and non-interactive paths — no separate hook needed here.
-        trackEvent('cli_init_completed', {
-            init_mode: mode.type,
-            is_new_agent: isNewAgent,
-            yaml_already_existed: yamlExists,
-            force_override: options.force || false,
-            restore_from_backup: options.restoreSources || false,
-            examples_included: withExamples,
-            sources_restored: sourcesRestored,
-            model_selected: !!selectedModel,
-            model: selectedModel,
-        });
-    }, 'initialization');
-}
-/**
- * Handles the flow for selecting an existing agent.
- * Fetches the agent details from the server to get persona.
- *
- * @param userData - User's data
- * @param apiKey - User's API key
- * @returns Selected agent, organization, and optional persona
- */
-async function selectExistingAgent(userData, apiKey) {
-    // Extract organizations
-    const orgs = userData.admin.orgs;
-    if (!orgs || orgs.length === 0) {
-        throw new Error('No organizations found.');
-    }
-    // Select organization
-    const selectedOrg = await promptOrganizationSelection(orgs);
-    // Select agent from organization
-    const selectedAgent = await promptAgentSelection(selectedOrg);
-    // Fetch agent details to get persona and model
-    const agentDetails = await fetchExistingAgentDetails(apiKey, selectedAgent.agentId);
-    return {
-        agent: selectedAgent,
-        org: selectedOrg,
-        persona: agentDetails.persona,
-        model: agentDetails.model,
-    };
-}
-/**
- * Non-interactive: Selects an existing agent by ID.
- * Finds the agent across all user's organizations.
- *
- * @param userData - User's data
- * @param apiKey - User's API key
- * @param agentId - Agent ID to find
- * @returns Selected agent, organization, and optional persona
- */
-async function selectExistingAgentById(userData, apiKey, agentId) {
-    const orgs = userData.admin?.orgs || [];
-    if (orgs.length === 0) {
-        console.error('❌ No organizations found.');
-        throw new Error('No organizations found.');
-    }
-    // Find agent across all organizations
-    for (const org of orgs) {
-        const agent = org.agents?.find((a) => a.agentId === agentId);
-        if (agent) {
-            writeProgress(`✅ Found agent: ${agent.name}`);
-            // Fetch agent details to get persona and model
-            const agentDetails = await fetchExistingAgentDetails(apiKey, agentId);
-            return {
-                agent: { agentId: agent.agentId, name: agent.name },
-                org: { id: org.id, name: org.registeredName, agents: org.agents },
-                persona: agentDetails.persona,
-                model: agentDetails.model,
-            };
-        }
-    }
-    // Agent not found
-    console.error(`❌ Agent not found: ${agentId}`);
-    writeInfo('\nAvailable agents:');
-    for (const org of orgs) {
-        if (org.agents && org.agents.length > 0) {
-            writeInfo(`  ${org.registeredName}:`);
-            for (const agent of org.agents) {
-                writeInfo(`    - ${agent.name} (${agent.agentId})`);
-            }
-        }
-    }
-    throw new Error('Operation failed');
-}
-/**
- * Non-interactive: Creates a new agent with provided parameters.
- *
- * @param apiKey - User's API key
- * @param userData - User data containing organizations
- * @param agentName - Name for the new agent
- * @param orgId - Optional existing org ID
- * @param orgName - Optional new org name
- * @returns Created agent, organization, and optional persona
- */
-async function createNewAgentNonInteractive(apiKey, userData, agentName, orgId, orgName, promoCode, model) {
-    // Fetch and select agent type
-    const agentTypes = await fetchAgentTypes(apiKey);
-    const selectedAgentType = selectBaseAgentType(agentTypes);
-    // Validate org if --org-id provided
-    if (orgId) {
-        const orgs = userData.admin?.orgs || [];
-        const existingOrg = orgs.find((o) => o.id === orgId);
-        if (!existingOrg) {
-            console.error(`❌ Organization not found: ${orgId}`);
-            writeInfo('\nAvailable organizations:');
-            for (const org of orgs) {
-                writeInfo(`  - ${org.registeredName} (${org.id})`);
-            }
-            throw new Error('Operation failed');
-        }
-        writeProgress(`✅ Using organization: ${existingOrg.registeredName}`);
-    }
-    else if (orgName) {
-        writeProgress(`✅ Creating new organization: ${orgName}`);
-    }
-    // Enable all features by default
-    const availableFeatures = Object.keys(selectedAgentType.features);
-    const features = availableFeatures.reduce((acc, feature) => {
-        acc[feature] = true;
-        return acc;
-    }, {});
-    writeProgress(`✅ Creating agent: ${agentName}`);
-    // Create the agent (model included in request — no separate PATCH needed)
-    const result = await createNewAgent(apiKey, selectedAgentType, agentName, {}, // Empty metadata - base agent doesn't require any
-    features, orgId, orgName, promoCode, model);
-    return result;
-}
-/**
- * Handles the flow for creating a new agent.
- *
- * @param apiKey - User's API key
- * @param userData - User data containing organizations
- * @returns Created agent, organization, and optional persona
- */
-async function createNewAgentFlow(apiKey, userData, promoCode) {
-    // Fetch and select agent type
-    const agentTypes = await fetchAgentTypes(apiKey);
-    const selectedAgentType = selectBaseAgentType(agentTypes);
-    // Ask about organization selection FIRST
-    const { orgChoice } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'orgChoice',
-            message: 'Organization:',
-            choices: [
-                { name: '🏢 Use existing organization', value: 'existing' },
-                { name: '➕ Create new organization', value: 'create' },
-            ],
-        },
-    ]);
-    let orgId;
-    let orgName;
-    let usingExistingOrg = false;
-    if (orgChoice === 'existing') {
-        // Select from existing organizations
-        const orgs = userData.admin?.orgs || [];
-        if (orgs.length === 0) {
-            writeInfo('\n⚠️  No existing organizations found. Creating new organization instead.\n');
-        }
-        else {
-            const selectedOrg = await promptOrganizationSelection(orgs);
-            orgId = selectedOrg.id;
-            usingExistingOrg = true;
-        }
-    }
-    if (!orgId) {
-        // Create new organization - ask for org name
-        const { organizationName } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'organizationName',
-                message: 'Organization name:',
-                validate: (input) => {
-                    if (!input || input.trim() === '') {
-                        return 'Organization name is required';
-                    }
-                    return true;
-                },
-            },
-        ]);
-        orgName = organizationName.trim();
-    }
-    // Collect required metadata
-    let linesToClear = 2; // orgChoice + (org selection OR org name)
-    const metadata = selectedAgentType.requiredSubAgentMetadata?.length
-        ? await promptMetadataCollection(selectedAgentType.requiredSubAgentMetadata)
-        : {};
-    // Enable all features by default (skip configuration prompt)
-    const availableFeatures = Object.keys(selectedAgentType.features);
-    const features = availableFeatures.reduce((acc, feature) => {
-        acc[feature] = true;
-        return acc;
-    }, {});
-    // Collect agent name
-    const agentName = await promptAgentName();
-    linesToClear += 1; // agentName prompt
-    // Prompt for model (last config step before creation)
-    let selectedModel;
-    const models = await fetchApprovedModels(apiKey);
-    if (models.length > 0) {
-        selectedModel = await promptModelSelection(models);
-    }
-    // Clear all prompts
-    clearLinesIfNeeded(linesToClear);
-    // Create the agent (model included in request — no separate PATCH needed)
-    const result = await createNewAgent(apiKey, selectedAgentType, agentName, metadata, features, orgId, orgName, promoCode, selectedModel);
-    return { ...result, model: selectedModel };
-}
-/**
- * Check if user has access to a specific agent
- */
-function checkUserHasAccessToAgent(userData, agentId) {
-    const orgs = userData.admin.orgs;
-    for (const org of orgs) {
-        const agent = org.agents.find((a) => a.agentId === agentId);
-        if (agent) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Handle switching to a different agent
- */
-async function handleAgentSwitch(userData, apiKey, existingYaml) {
-    writeInfo("\n🔄 Let's switch to a different agent...\n");
-    const agentChoice = await promptAgentChoice();
-    let selectedAgent;
-    let selectedOrg;
-    let persona;
-    let serverModel;
-    let isNewAgent = false;
-    let selectedModel;
-    if (agentChoice === 'existing') {
-        const result = await selectExistingAgent(userData, apiKey);
-        selectedAgent = result.agent;
-        selectedOrg = result.org;
-        persona = result.persona;
-        serverModel = result.model;
-        // Use server model if present, else prompt
-        if (serverModel) {
-            selectedModel = serverModel;
-        }
-        else {
-            const models = await fetchApprovedModels(apiKey);
-            if (models.length > 0) {
-                selectedModel = await promptModelSelection(models);
-            }
-        }
-    }
-    else if (agentChoice === 'duplicate') {
-        const result = await duplicateAgentInteractive(apiKey, userData);
-        if (!result)
-            return; // user cancelled
-        selectedAgent = result.agent;
-        selectedOrg = result.org;
-        persona = result.persona;
-        selectedModel = result.model;
-    }
-    else {
-        const result = await createNewAgentFlow(apiKey, userData);
-        selectedAgent = result.agent;
-        selectedOrg = result.org;
-        persona = result.persona;
-        selectedModel = result.model;
-        isNewAgent = true;
-        displayPersonaInstructions();
-    }
-    // Ask about persona
-    const finalPersona = await promptPersonaReplacement(existingYaml, persona);
-    // Push model to server only for existing agents where the user explicitly changed it.
-    // New agents already have the model set in the create request — no separate PATCH needed.
-    const userChoseModel = selectedModel && selectedModel !== serverModel;
-    if (userChoseModel && !isNewAgent) {
-        try {
-            writeProgress(`🤖 Setting model: ${selectedModel}...`);
-            await updateAgentModel(apiKey, selectedAgent.agentId, selectedModel);
-            writeProgress(`✅ Model set: ${selectedModel}`);
-        }
-        catch (error) {
-            writeInfo(`⚠️  Could not set model on server — you can push it later with \`lua push agent\``);
-        }
-    }
-    // Update existing YAML file with new agent
-    writeInfo('\n📝 Updating lua.skill.yaml with new agent...');
-    updateYamlAgent(selectedAgent.agentId, selectedOrg.id);
-    const { updateAgentConfig } = await import('../compiler/index.js');
-    updateAgentConfig({ name: selectedAgent.name, persona: finalPersona, model: selectedModel }, { projectDir: process.cwd() });
-    writeSuccess('✅ lua.skill.yaml updated successfully!');
-    writeSuccess('✅ LuaAgent configuration updated!');
-    writeInfo("\n💡 Your project now uses the new agent. Run 'lua compile' to update your skills.\n");
-    trackEvent('cli_init_agent_switched', { model_selected: !!selectedModel, model: selectedModel });
-}
-/**
- * Prompt user about replacing existing persona
- */
-async function promptPersonaReplacement(existingYaml, newPersona) {
-    const existingPersona = existingYaml?.agent?.persona;
-    // If no existing persona, use new one
-    if (!existingPersona) {
-        return newPersona;
-    }
-    // If no new persona, keep existing
-    if (!newPersona) {
-        return existingPersona;
-    }
-    // Both exist - ask user
-    writeInfo('\n📝 Persona Configuration:');
-    writeInfo('   Existing persona found in project');
-    const { replacePersona } = await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'replacePersona',
-            message: "Replace existing persona with the new agent's persona?",
-            default: false,
-        },
-    ]);
-    return replacePersona ? newPersona : existingPersona;
-}
-/**
- * Check if canonical source exists for an agent and restore workspace files.
- *
- * @param apiKey - User's API key
- * @param agentId - Agent ID to check source for
- * @param options - Options for restoration (kept for interface compatibility)
- * @param options.interactive - Unused; restore is non-interactive on fresh init
- * @param options.autoRestore - Unused; restore always runs when source is found
- * @returns True if sources were restored, false otherwise
- */
-async function checkAndRestoreBackup(apiKey, agentId, options) {
-    const targetDir = process.cwd();
-    const { fetched: manifest } = await fetchBackupManifestForPull(apiKey, agentId);
-    if (!manifest) {
-        writeInfo('   No backup on file for this agent. Push your local sources with `lua push` to enable future restores.');
-        return false;
-    }
-    const conflicts = checkRestoreConflicts(manifest, targetDir);
-    if (!options.autoRestore && conflicts.existingFiles.length > 0) {
-        const { confirm } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: `Restoring will overwrite ${conflicts.existingFiles.length} existing file(s). Continue?`,
-                default: false,
-            },
-        ]);
-        if (!confirm)
-            return false;
-    }
-    // Network/restore failures must not crash `lua init` — keep the same
-    // graceful return-false posture the OLD restore flow had before the
-    // canonical-source pipeline was added. The user can retry, push fresh,
-    // or proceed with an empty workspace.
-    try {
-        const backupApi = new BackupApi(BASE_URLS.API, apiKey, agentId);
-        const urlsResponse = await backupApi.getBlobUrls(manifest.files.map((f) => f.hash));
-        if (!urlsResponse.success || !urlsResponse.data) {
-            writeError(`Failed to fetch download URLs: ${urlsResponse.error?.message ?? 'unknown error'}`);
-            return false;
-        }
-        const blobs = await downloadBlobsParallel(urlsResponse.data.urls);
-        restoreProjectFromBackup(manifest, blobs, targetDir, { overwrite: true });
-    }
-    catch (err) {
-        writeError(`Backup restore failed: ${err instanceof Error ? err.message : String(err)}. ` +
-            'Continuing with an empty workspace.');
-        return false;
-    }
-    // Phase 2 task 2.6: persist the restored manifest's projectHash and
-    // activeVersion into lua.skill.yaml so the next `lua push backup` (and
-    // the auto-backup hook) can detect cross-machine drift via CAS.
-    // Without this, a fresh-cloned workspace would always look "out of
-    // sync" relative to the server, and the V2 saveManifestV2 path would
-    // see no baseline activeVersion to compare against.
-    //
-    // restoreProjectFromBackup wrote `lua.skill.yaml` itself (it's part of
-    // the restored manifest), so re-read from disk before merging — we
-    // don't want to clobber the just-restored agent block.
-    //
-    // targetDir == process.cwd() here (see top of this function); the
-    // existing read/write helpers always operate on cwd, so we don't need
-    // to thread a path through them.
-    try {
-        const restoredConfig = readYamlConfig();
-        if (restoredConfig) {
-            restoredConfig.backup = {
-                ...(restoredConfig.backup ?? {}),
-                lastHash: manifest.projectHash,
-                lastPushedAt: manifest.createdAt,
-            };
-            if (typeof manifest.activeVersion === 'number') {
-                restoredConfig.backup.activeVersion = manifest.activeVersion;
-            }
-            writeYamlConfig(restoredConfig);
-        }
-    }
-    catch {
-        // Best-effort: a tracking-write failure must not undo a successful
-        // file restore. The next `lua push backup` will reconcile.
-    }
-    writeSuccess(`Restored ${manifest.files.length} files from backup`);
-    return true;
-}
-//# sourceMappingURL=init.js.map