lua-cli 3.15.3 → 3.16.0

package/dist/commands/sync.js

@@ -1,802 +0,0 @@
-/**
- * Sync Command
- * Detects drift between server state and local code, allowing users to sync
- */
-import { flattenPersonaTextAll } from '@lua/shared-types';
-import fs from 'fs';
-import path from 'path';
-import { withErrorHandling, writeProgress, writeSuccess, writeInfo, writeError, writeHintBlock, } from '../utils/cli.js';
-import { safePrompt } from '../utils/prompt-handler.js';
-import { initializeCommand } from '../utils/command-utils.js';
-import { compileCommand } from './compile.js';
-import { buildLogsCommand } from './log-tip.js';
-import { showPersonaDiff, showNameDiff, showModelDiff, showGovernanceDiff } from '../utils/sync-helpers.js';
-import { agentHandler } from '../primitives/agent.handler.js';
-import { trackEvent } from '../services/analytics.js';
-import { checkPrimitiveDrift } from '../utils/sync-fetch.js';
-import { showPrimitiveDrift, showPrimitiveDriftSummary } from '../utils/sync-display.js';
-import { checkBackupAvailability, restoreFromBackupForSync, detectLocalConflictsForPull, fetchBackupManifestForPull, } from '../utils/backup-helpers.js';
-import { readYamlConfig } from '../utils/files.js';
-import { mcpServerHandler } from '../primitives/mcp-server.handler.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// Main Command Entry
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Main sync command - detects and resolves drift between server and local code.
- *
- * Supports both interactive and non-interactive modes:
- * - Interactive: prompts for resolution of each drifted component
- * - Non-interactive (--check): just check for drift, exit with code 1 if found
- * - Non-interactive (--accept): auto-accept server state without prompting (pull from server)
- * - Non-interactive (--push): keep local changes without prompting (for pushing to server)
- */
-export async function syncCommand(options) {
-    return withErrorHandling(async () => {
-        // Snapshot YAML versions BEFORE compile runs. `compileCommand()` invokes
-        // each handler's `applySyncToYaml`, which bumps local primitive versions
-        // to match the server's active version (see base.handler.ts version
-        // update block). If we let that run and then read yaml, the drift check
-        // compares server-against-server and always reports no drift — even when
-        // the local source code is stale. Then `restoreFromBackupForSync` never
-        // runs and the user's pull silently does nothing. Capturing versions
-        // before compile preserves the true local state for drift detection.
-        const preCompileYaml = readYamlConfig();
-        // Snapshot raw yaml BYTES pre-compile so we can revert on abort. Compile's
-        // yaml-sync mutates lua.skill.yaml on disk regardless of whether the
-        // surrounding sync command ultimately completes. Without a revert, an
-        // aborted `sync --pull` (e.g., guard rejection, restore failure, network
-        // error) leaves yaml pre-bumped and the NEXT `sync --pull` sees disk ==
-        // server and exits with "No drift detected" — silently skipping the
-        // restore the user actually wanted. Restoring the pre-compile bytes in a
-        // finally block keeps drift detection correct across retries.
-        const yamlPath = path.resolve(process.cwd(), 'lua.skill.yaml');
-        const preCompileYamlBytes = fs.existsSync(yamlPath) ? fs.readFileSync(yamlPath, 'utf-8') : null;
-        let syncCompletedSuccessfully = false;
-        try {
-            writeProgress('🔄 Compiling to get latest local state...');
-            await compileCommand();
-            writeProgress('🔄 Checking for drift between server and local code...');
-            // Initialize command (validates config + auth)
-            const { agentId, apiKey } = await initializeCommand({ showProgress: false });
-            const context = { apiKey, agentId };
-            // Drift check uses the pre-compile snapshot so that compile's yaml
-            // version bumps don't mask true version drift. Everything downstream
-            // (restore, writeback, MCP sync) is keyed off primitive names, not
-            // versions, so using the snapshot here doesn't otherwise skew behavior.
-            const [drift, primitiveDrift] = await Promise.all([
-                agentHandler.checkDrift(apiKey, agentId),
-                preCompileYaml
-                    ? checkPrimitiveDrift(apiKey, agentId, preCompileYaml)
-                    : Promise.resolve({ items: [], hasDrift: false }),
-            ]);
-            // Check backup availability only when drift includes items that restore from backup.
-            // MCP servers pull live from the server, not from source backup — skip the HTTP call
-            // when drift is MCP-only.
-            const needsBackup = primitiveDrift.items.some((item) => item.type !== 'mcpServer');
-            if (primitiveDrift.hasDrift && needsBackup) {
-                const backupStatus = await checkBackupAvailability(apiKey, agentId);
-                primitiveDrift.backupAvailable = backupStatus.available;
-            }
-            const hasAnyDrift = agentHandler.hasDrift(drift) || primitiveDrift.hasDrift;
-            // No drift detected
-            if (!hasAnyDrift) {
-                writeSuccess('✅ No drift detected. Local code is in sync with server.');
-                trackEvent('cli_sync_completed', { has_drift: false });
-                syncCompletedSuccessfully = true;
-                return;
-            }
-            const mode = options?.check ? 'check' : options?.accept ? 'accept' : options?.push ? 'push' : 'interactive';
-            let pullConflictCount = 0;
-            // Execute based on mode
-            if (options?.check) {
-                executeCheckMode(drift, primitiveDrift);
-            }
-            else if (options?.accept) {
-                const acceptResult = await executeAcceptMode(context, drift, primitiveDrift, options.force === true);
-                pullConflictCount = acceptResult.pullConflictCount;
-            }
-            else if (options?.push) {
-                await executePushMode(context, drift, primitiveDrift);
-            }
-            else {
-                await executeInteractiveMode(context, drift, primitiveDrift);
-            }
-            trackEvent('cli_sync_completed', {
-                mode,
-                has_drift: hasAnyDrift,
-                name_drift: !!drift.name,
-                persona_drift: !!drift.persona,
-                model_drift: !!drift.model,
-                primitive_drift: primitiveDrift.hasDrift,
-                primitive_drift_count: primitiveDrift.items.length,
-                pull_force: options?.force === true && options?.accept === true,
-                pull_conflict_count: pullConflictCount,
-            });
-            syncCompletedSuccessfully = true;
-        }
-        finally {
-            // Revert yaml to pre-compile state if we bailed mid-flight. Best-effort:
-            // swallow any filesystem error so we don't mask the original abort's
-            // exception. On success (syncCompletedSuccessfully === true) we leave
-            // disk alone — compile's yaml updates are the intended final state.
-            if (!syncCompletedSuccessfully && preCompileYamlBytes !== null) {
-                try {
-                    fs.writeFileSync(yamlPath, preCompileYamlBytes, 'utf-8');
-                }
-                catch {
-                    // Deliberate: do not throw from finally.
-                }
-            }
-        }
-    }, 'sync');
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Non-Interactive Modes
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Check mode: Display drift summary and exit with code 1 if drift found.
- */
-function executeCheckMode(drift, primitiveDrift) {
-    console.log('\n' + '='.repeat(60));
-    console.log('🔍 Drift Check Summary');
-    console.log('='.repeat(60) + '\n');
-    let driftCount = 0;
-    if (drift.name) {
-        driftCount++;
-        console.log('⚠️  Name drift detected:');
-        console.log(`   Local:  "${drift.name.localName || '(empty)'}"`);
-        console.log(`   Server: "${drift.name.serverName || '(empty)'}"`);
-        console.log();
-    }
-    if (drift.persona) {
-        driftCount++;
-        const localPersona = flattenPersonaTextAll(drift.persona.localPersona) || '';
-        const serverPersona = flattenPersonaTextAll(drift.persona.serverPersona) || '';
-        const localPreview = localPersona
-            ? localPersona.length > 50
-                ? localPersona.substring(0, 50) + '...'
-                : localPersona
-            : '(empty)';
-        const serverPreview = serverPersona
-            ? serverPersona.length > 50
-                ? serverPersona.substring(0, 50) + '...'
-                : serverPersona
-            : '(empty)';
-        console.log('⚠️  Persona drift detected:');
-        console.log(`   Local:  "${localPreview}"`);
-        console.log(`   Server: "${serverPreview}"`);
-        console.log();
-    }
-    if (drift.model) {
-        driftCount++;
-        console.log('⚠️  Model drift detected:');
-        console.log(`   Local:  "${drift.model.localModel || '(empty)'}"`);
-        console.log(`   Server: "${drift.model.serverModel || '(empty)'}"`);
-        console.log();
-    }
-    if (primitiveDrift.hasDrift) {
-        showPrimitiveDriftSummary(primitiveDrift.items);
-        console.log();
-    }
-    const totalDrift = driftCount + primitiveDrift.items.length;
-    if (drift.governance) {
-        driftCount++;
-        const localMode = drift.governance.localGovernance?.mode || '(none)';
-        const serverMode = drift.governance.serverGovernance?.mode || '(none)';
-        console.log('⚠️  Governance drift detected:');
-        console.log(`   Local:  ${localMode} mode`);
-        console.log(`   Server: ${serverMode} mode`);
-        console.log();
-    }
-    console.log('='.repeat(60));
-    console.log(`Total: ${totalDrift} component(s) with drift`);
-    console.log("\n💡 Use 'lua sync --push' to push local changes to server");
-    console.log("   Use 'lua sync --accept' to pull server state to local");
-    console.log("   Use 'lua sync' for interactive resolution\n");
-    throw new Error('Operation failed');
-}
-/**
- * Accept mode: Auto-accept server state for all drifted components.
- */
-async function executeAcceptMode(context, drift, primitiveDrift, force) {
-    console.log('\n⚠️  Drift detected. Auto-accepting server state...\n');
-    let unresolvedCount = 0;
-    let pullConflictCount = 0;
-    const pullableItems = primitiveDrift.hasDrift
-        ? primitiveDrift.items.filter((item) => item.status !== 'missing-on-server')
-        : [];
-    const pullableMcp = pullableItems.filter((item) => item.type === 'mcpServer');
-    const pullableSource = pullableItems.filter((item) => item.type !== 'mcpServer');
-    // Write order matters. The backup restore and the agent-field pulls both
-    // touch `src/index.ts`: the restore writes whatever was on disk during the
-    // last `lua push backup` (older persona/name/model), while the agent-field
-    // pulls AST-edit it with the current server values. The restore must run
-    // FIRST so the pulls land on top — otherwise the backup silently reverts
-    // the persona the user just pulled (bug: "persona appears for half a
-    // second, then reverts").
-    //
-    // The guard must also run before any writes so it hashes unmodified disk
-    // state; keeping it here preserves that invariant.
-    let manifest = null;
-    const willRestoreSources = pullableSource.length > 0 && primitiveDrift.backupAvailable;
-    if (willRestoreSources) {
-        const fetch = await fetchBackupManifestForPull(context.apiKey, context.agentId);
-        manifest = fetch.fetched;
-        const incomingFiles = manifest?.files ?? [];
-        if (manifest && incomingFiles.length > 0) {
-            writeProgress('📥 Checking for local changes before pulling...');
-            const guard = detectLocalConflictsForPull(incomingFiles);
-            pullConflictCount = guard.conflicts.length;
-            if (!force && guard.warning === 'no-tracking') {
-                writeInfo('⚠️  No local backup tracking found.');
-                writeInfo('   Cannot detect local changes — proceeding without conflict check.');
-                writeInfo('   Run `lua push backup` after pulling if you want this check enabled next time.');
-            }
-            else if (!force && guard.conflicts.length > 0) {
-                console.log();
-                writeError(`❌ Refusing to pull — ${guard.conflicts.length} local file(s) have uncommitted changes since your last push:`);
-                for (const p of guard.conflicts) {
-                    writeError(`   - ${p}`);
-                }
-                console.log();
-                writeInfo('Your options:');
-                writeInfo('   • Save your changes:   lua push backup      (then re-run lua sync --pull)');
-                writeInfo('   • Overwrite them:      lua sync --pull --force   (destructive — cannot be undone)');
-                writeInfo('   • Resolve manually:    edit or revert each file, then re-run');
-                console.log();
-                writeInfo('Sync aborted. No files were modified.');
-                throw new Error(`Sync aborted: ${guard.conflicts.length} local file(s) have uncommitted changes`);
-            }
-        }
-        else if (!force && !manifest) {
-            writeInfo('⚠️  Could not verify local backup (network or server error).');
-            writeInfo('   Proceeding without conflict check.');
-        }
-    }
-    // Guard passed (or didn't run) — safe to proceed with writes.
-    // Primitive drift first: MCP servers pull live from the server (handler
-    // owns its YAML sync); source-based primitives (skills/webhooks/jobs/
-    // pre-post-processors) restore from S3 backup. Both happen before the
-    // agent-field pulls so the restore cannot clobber them (see comment above).
-    if (primitiveDrift.hasDrift) {
-        if (pullableMcp.length > 0) {
-            writeProgress('📥 Syncing MCP servers from server...');
-            try {
-                const yamlConfig = readYamlConfig();
-                const result = await mcpServerHandler.syncWithServer(context.apiKey, context.agentId, yamlConfig);
-                if (result.yamlUpdated) {
-                    writeSuccess('✅ MCP servers synced from server');
-                }
-                else {
-                    writeSuccess('✅ MCP servers already in sync');
-                }
-            }
-            catch (error) {
-                console.error(`❌ Failed to sync MCP servers: ${error.message}`);
-            }
-        }
-        if (pullableSource.length > 0) {
-            if (primitiveDrift.backupAvailable) {
-                const expectedNames = pullableSource.map((i) => i.name);
-                const restoreSuffix = force ? ' (--force: skipping conflict check)' : '';
-                writeProgress(`📥 Restoring project files from backup${restoreSuffix}...`);
-                const result = await restoreFromBackupForSync(context.apiKey, context.agentId, expectedNames, undefined, manifest ?? undefined);
-                unresolvedCount += reportRestoreResult(result, pullableSource, { verbose: true });
-            }
-            else {
-                // No backup to restore from: every drifted source primitive is unresolved.
-                // Without this, `--pull` would exit 0 even though nothing was actually synced.
-                writeInfo('⚠️  Primitive drift detected but no backup available.');
-                writeInfo('   Run "lua push backup" first to enable pulling primitives from server.');
-                unresolvedCount += pullableSource.length;
-            }
-        }
-    }
-    if (drift.name?.serverName) {
-        writeProgress('📝 Syncing name from server...');
-        if (agentHandler.pullName(drift.name.serverName)) {
-            writeSuccess('✅ Name synced from server');
-        }
-        else {
-            console.error('❌ Failed to update name in code.');
-        }
-    }
-    if (drift.persona?.serverPersona) {
-        writeProgress('📝 Syncing persona from server...');
-        if (agentHandler.pullPersona(drift.persona.serverPersona)) {
-            writeSuccess('✅ Persona synced from server');
-        }
-        else {
-            console.error('❌ Failed to update persona in code.');
-        }
-    }
-    if (drift.model?.serverModel) {
-        writeProgress('📝 Syncing model from server...');
-        if (agentHandler.pullModel(drift.model.serverModel)) {
-            writeSuccess('✅ Model synced from server');
-        }
-        else {
-            console.error('❌ Failed to update model in code.');
-        }
-    }
-    // Partial sync = exit non-zero so CI and scripts fail loudly.
-    if (unresolvedCount > 0) {
-        writeInfo(`\n⚠️  Sync partially complete — ${unresolvedCount} primitive(s) unresolved. See above.`);
-        throw new Error(`Sync partially complete: ${unresolvedCount} primitive(s) could not be resolved from backup`);
-    }
-    writeSuccess('\n✅ Sync complete.');
-    writeHintBlock({
-        headline: 'Local config updated from server. Verify before pushing:',
-        lines: [
-            { label: 'Test it first:', command: 'lua chat -e sandbox -m "test"' },
-            { label: 'When ready to publish:', command: 'lua push all --force' },
-        ],
-        when: 'success',
-    });
-    return { pullConflictCount };
-}
-/**
- * Print the outcome of `restoreFromBackupForSync` and return the number of
- * drifted primitives the backup couldn't resolve. `verbose` adds the remediation
- * hint shown in non-interactive (--pull) mode.
- */
-function reportRestoreResult(result, pullableSource, options) {
-    if (!result.success) {
-        console.error(`❌ Failed to restore from backup: ${result.error}`);
-        // A complete restore failure means NO primitives were resolved.
-        // `restoreFromBackupForSync` populates `primitivesUnresolved` with the full
-        // expected list on any error path, so this count is correct.
-        return result.primitivesUnresolved.length;
-    }
-    if (result.filesWritten > 0) {
-        writeSuccess(`✅ Restored ${result.filesWritten} file(s) from backup (${result.filesUnchanged} unchanged)`);
-    }
-    else {
-        writeInfo(`ℹ️  Backup matched local disk — 0 files written${options.verbose ? ` (${result.filesUnchanged} already up-to-date)` : ''}`);
-    }
-    if (result.primitivesUnresolved.length === 0)
-        return 0;
-    console.log();
-    writeInfo(options.verbose
-        ? '⚠️  The following primitives drifted but are NOT in the backup:'
-        : '⚠️  Primitives not in backup (source unavailable):');
-    for (const name of result.primitivesUnresolved) {
-        const item = pullableSource.find((i) => i.name === name);
-        const label = item ? `${item.type}/${name}` : name;
-        writeInfo(`   - ${label}`);
-    }
-    if (options.verbose) {
-        writeInfo('   The backup does not contain source for these primitives.');
-        writeInfo('   Ask whoever made the changes to run `lua push all --force`,');
-        writeInfo('   or run `lua <primitive> delete <name>` to remove them from the server.');
-        if (result.backupAgeDays !== null && result.backupAgeDays >= 1) {
-            writeInfo(`   (Backup is ${result.backupAgeDays} day(s) old — may be stale.)`);
-        }
-    }
-    return result.primitivesUnresolved.length;
-}
-/**
- * Push mode: Push local changes to server without prompting.
- */
-async function executePushMode(context, drift, primitiveDrift) {
-    console.log('\n⚠️  Drift detected. Pushing local changes to server...\n');
-    let syncFullySucceeded = true;
-    try {
-        if (drift.persona) {
-            writeProgress('📤 Pushing persona to server...');
-            const result = await agentHandler.pushPersona(context, drift.persona.localPersona);
-            if (result.success) {
-                writeSuccess(`✅ Persona version ${result.version} created on server`);
-            }
-            else {
-                console.error('❌ Failed to push persona');
-                syncFullySucceeded = false;
-            }
-        }
-        if (drift.name) {
-            writeProgress('📤 Pushing name to server...');
-            if (await agentHandler.pushName(context, drift.name.localName)) {
-                writeSuccess(`✅ Agent name updated to "${drift.name.localName}"`);
-            }
-            else {
-                console.error('❌ Failed to update name');
-                syncFullySucceeded = false;
-            }
-        }
-        if (drift.model) {
-            writeProgress('📤 Pushing model to server...');
-            if (await agentHandler.pushModel(context, drift.model.localModel)) {
-                writeSuccess(`✅ Agent model updated to "${drift.model.localModel}"`);
-            }
-            else {
-                console.error('❌ Failed to update model');
-                syncFullySucceeded = false;
-            }
-        }
-        if (drift.governance) {
-            writeProgress('📤 Pushing governance config to server...');
-            if (await agentHandler.pushGovernance(context, drift.governance.localGovernance)) {
-                writeSuccess('✅ Governance config pushed to server');
-            }
-            else {
-                console.error('❌ Failed to push governance config');
-                syncFullySucceeded = false;
-            }
-        }
-    }
-    catch (error) {
-        console.error('❌ Failed to push to server:', error.message);
-        syncFullySucceeded = false;
-    }
-    // Handle primitive drift — show which primitives need pushing
-    if (primitiveDrift.hasDrift) {
-        const pushableItems = primitiveDrift.items.filter((item) => item.status !== 'missing-locally');
-        if (pushableItems.length > 0) {
-            console.log('\n⚠️  Primitive drift detected:');
-            for (const item of pushableItems) {
-                const localV = item.localVersion ? `v${item.localVersion}` : '(none)';
-                const serverV = item.serverVersion ? `v${item.serverVersion}` : '(none)';
-                console.log(`   ${item.type}: ${item.name} (local ${localV}, server ${serverV})`);
-            }
-            console.log('\n💡 To push these primitives, run: lua push all --force');
-        }
-        const missingLocally = primitiveDrift.items.filter((item) => item.status === 'missing-locally');
-        if (missingLocally.length > 0) {
-            console.log('\n⚠️  Primitives on server but not in local config:');
-            for (const item of missingLocally) {
-                const serverV = item.serverVersion ? `v${item.serverVersion}` : '(none)';
-                console.log(`   ${item.type}: ${item.name} (server ${serverV})`);
-            }
-            console.log('   These cannot be pushed. Use "lua sync --accept" to pull them.');
-        }
-    }
-    writeSuccess('\n' + `${syncFullySucceeded ? '✅' : '⚠️ '} Sync complete${syncFullySucceeded ? '.' : ' (with errors).'}`);
-    writeHintBlock({
-        headline: syncFullySucceeded
-            ? 'Server updated. Verify the changes:'
-            : 'Sync completed with errors. Verify what succeeded:',
-        lines: [
-            { label: 'Sandbox test:', command: 'lua chat -e sandbox -m "test"' },
-            { label: 'Production test:', command: 'lua chat -e production -m "test"' },
-            { label: 'Inspect logs:', command: buildLogsCommand({ limit: 10 }) },
-        ],
-        when: syncFullySucceeded ? 'success' : 'partial',
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Interactive Mode
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Interactive mode: Prompt for resolution of each drifted component.
- *
- * Primitive drift is handled first so that a "pull from backup" choice
- * doesn't overwrite the persona/name/model the user just pulled — same
- * write-ordering rule as `executeAcceptMode`.
- */
-async function executeInteractiveMode(context, drift, primitiveDrift) {
-    if (primitiveDrift.hasDrift) {
-        await handlePrimitiveDriftInteractive(context, primitiveDrift);
-    }
-    if (drift.name) {
-        await handleNameDriftInteractive(context, drift.name);
-    }
-    if (drift.persona) {
-        await handlePersonaDriftInteractive(context, drift.persona);
-    }
-    if (drift.model) {
-        await handleModelDriftInteractive(context, drift.model);
-    }
-    if (primitiveDrift.hasDrift) {
-        await handlePrimitiveDriftInteractive(context, primitiveDrift);
-    }
-    if (drift.governance) {
-        await handleGovernanceDriftInteractive(context, drift.governance);
-    }
-    writeSuccess('\n✅ Sync complete.');
-    writeHintBlock({
-        headline: 'Sync complete. Verify the changes:',
-        lines: [
-            { label: 'Sandbox test:', command: 'lua chat -e sandbox -m "test"' },
-            { label: 'Production test:', command: 'lua chat -e production -m "test"' },
-            { label: 'Inspect logs:', command: buildLogsCommand({ limit: 10 }) },
-        ],
-        when: 'success',
-    });
-}
-/**
- * Handle name drift interactively.
- */
-async function handleNameDriftInteractive(context, drift) {
-    showNameDiff(drift.serverName, drift.localName);
-    const answer = await safePrompt([
-        {
-            type: 'list',
-            name: 'action',
-            message: 'What would you like to do with the name?',
-            choices: [
-                { name: '📤 Push local to server', value: 'push' },
-                { name: '📥 Pull server to local', value: 'pull' },
-                { name: '⏭️  Skip', value: 'skip' },
-            ],
-        },
-    ]);
-    if (!answer || answer.action === 'skip') {
-        writeInfo('Skipped name sync.');
-        return;
-    }
-    if (answer.action === 'push') {
-        writeProgress('📤 Pushing name to server...');
-        try {
-            if (await agentHandler.pushName(context, drift.localName)) {
-                writeSuccess(`✅ Agent name updated to "${drift.localName}"`);
-            }
-            else {
-                console.error('❌ Failed to update name');
-            }
-        }
-        catch (error) {
-            console.error('❌ Failed to update name:', error.message);
-        }
-    }
-    else if (answer.action === 'pull' && drift.serverName) {
-        writeProgress('📥 Updating name in code...');
-        if (agentHandler.pullName(drift.serverName)) {
-            writeSuccess('✅ Name updated in src/index.ts');
-        }
-        else {
-            console.error('❌ Failed to update name in code.');
-        }
-    }
-}
-/**
- * Handle persona drift interactively.
- */
-async function handlePersonaDriftInteractive(context, drift) {
-    showPersonaDiff(drift.serverPersona, drift.localPersona);
-    const answer = await safePrompt([
-        {
-            type: 'list',
-            name: 'action',
-            message: 'What would you like to do with persona?',
-            choices: [
-                { name: '📤 Push local to server', value: 'push' },
-                { name: '📥 Pull server to local', value: 'pull' },
-                { name: '⏭️  Skip', value: 'skip' },
-            ],
-        },
-    ]);
-    if (!answer || answer.action === 'skip') {
-        writeInfo('Skipped persona sync.');
-        return;
-    }
-    if (answer.action === 'push') {
-        writeProgress('📤 Pushing persona to server...');
-        try {
-            const result = await agentHandler.pushPersona(context, drift.localPersona);
-            if (result.success) {
-                writeSuccess(`✅ Persona version ${result.version} created on server`);
-            }
-            else {
-                console.error('❌ Failed to push persona');
-            }
-        }
-        catch (error) {
-            console.error('❌ Failed to push persona:', error.message);
-        }
-    }
-    else if (answer.action === 'pull' && drift.serverPersona) {
-        writeProgress('📥 Updating persona in code...');
-        if (agentHandler.pullPersona(drift.serverPersona)) {
-            writeSuccess('✅ Persona updated in src/index.ts');
-        }
-        else {
-            console.error('❌ Failed to update persona in code.');
-        }
-    }
-}
-/**
- * Handle model drift interactively.
- */
-async function handleModelDriftInteractive(context, drift) {
-    showModelDiff(drift.serverModel, drift.localModel);
-    const answer = await safePrompt([
-        {
-            type: 'list',
-            name: 'action',
-            message: 'What would you like to do with the model?',
-            choices: [
-                { name: '📤 Push local to server', value: 'push' },
-                { name: '📥 Pull server to local', value: 'pull' },
-                { name: '⏭️  Skip', value: 'skip' },
-            ],
-        },
-    ]);
-    if (!answer || answer.action === 'skip') {
-        writeInfo('Skipped model sync.');
-        return;
-    }
-    if (answer.action === 'push') {
-        writeProgress('📤 Pushing model to server...');
-        try {
-            if (await agentHandler.pushModel(context, drift.localModel)) {
-                writeSuccess(`✅ Agent model updated to "${drift.localModel}"`);
-            }
-            else {
-                console.error('❌ Failed to update model');
-            }
-        }
-        catch (error) {
-            console.error('❌ Failed to update model:', error.message);
-        }
-    }
-    else if (answer.action === 'pull' && drift.serverModel) {
-        writeProgress('📥 Updating model in code...');
-        if (agentHandler.pullModel(drift.serverModel)) {
-            writeSuccess('✅ Model updated in src/index.ts');
-        }
-        else {
-            console.error('❌ Failed to update model in code.');
-        }
-    }
-}
-/**
- * Handle primitive drift interactively.
- * Displays all drifted primitives, then prompts for each one.
- * If the user chooses "pull" for any primitive, the entire project
- * is restored from backup (once).
- */
-async function handlePrimitiveDriftInteractive(context, primitiveDrift) {
-    showPrimitiveDrift(primitiveDrift.items, primitiveDrift.backupAvailable);
-    let hasRestoredFromBackup = false;
-    let hasSyncedMcp = false;
-    for (const item of primitiveDrift.items) {
-        const choices = [];
-        const isMcp = item.type === 'mcpServer';
-        if (item.status !== 'missing-locally') {
-            choices.push({ name: '📤 Push local to server', value: 'push' });
-        }
-        if (item.status !== 'missing-on-server') {
-            if (isMcp) {
-                // MCP servers pull live from the server, not from backup.
-                choices.push({ name: '📥 Pull from server', value: 'pull-mcp' });
-            }
-            else if (primitiveDrift.backupAvailable) {
-                choices.push({ name: '📥 Pull from backup', value: 'pull' });
-            }
-            else {
-                choices.push({ name: '📥 Pull from backup (unavailable)', value: 'pull-unavailable' });
-            }
-        }
-        choices.push({ name: '⏭️  Skip', value: 'skip' });
-        const answer = await safePrompt([
-            {
-                type: 'list',
-                name: 'action',
-                message: `${item.type}: ${item.name} — What would you like to do?`,
-                choices,
-            },
-        ]);
-        if (!answer || answer.action === 'skip') {
-            writeInfo(`Skipped ${item.type}: ${item.name}`);
-            continue;
-        }
-        if (answer.action === 'push') {
-            // The internal drift type 'mcpServer' maps to CLI arg 'mcp' (see validTypes in push.ts).
-            const pushArg = item.type === 'mcpServer' ? 'mcp' : item.type;
-            writeInfo(`💡 To push this ${item.type}, run: lua push ${pushArg} --name "${item.name}"`);
-        }
-        else if (answer.action === 'pull-mcp') {
-            // mcpServerHandler.syncWithServer does a bulk sync of all MCP servers,
-            // so only call it once per session.
-            if (hasSyncedMcp) {
-                writeInfo(`✅ Already synced MCP servers (includes ${item.name})`);
-            }
-            else {
-                writeProgress('📥 Syncing MCP servers from server...');
-                try {
-                    const yamlConfig = readYamlConfig();
-                    const result = await mcpServerHandler.syncWithServer(context.apiKey, context.agentId, yamlConfig);
-                    writeSuccess(result.yamlUpdated ? '✅ MCP servers synced from server' : '✅ MCP servers already in sync');
-                    hasSyncedMcp = true;
-                }
-                catch (error) {
-                    console.error(`❌ Failed to sync MCP servers: ${error.message}`);
-                }
-            }
-        }
-        else if (answer.action === 'pull') {
-            if (hasRestoredFromBackup) {
-                writeInfo(`✅ Already restored from backup (includes ${item.name})`);
-            }
-            else {
-                const pullableSource = primitiveDrift.items.filter((i) => i.type !== 'mcpServer' && i.status !== 'missing-on-server');
-                writeProgress('📥 Restoring project files from backup...');
-                const result = await restoreFromBackupForSync(context.apiKey, context.agentId, pullableSource.map((i) => i.name));
-                if (result.success) {
-                    hasRestoredFromBackup = true;
-                    reportRestoreResult(result, pullableSource, { verbose: false });
-                }
-                else {
-                    console.error(`❌ Failed to restore from backup: ${result.error}`);
-                }
-            }
-        }
-        else if (answer.action === 'pull-unavailable') {
-            writeInfo('⚠️  No backup available. Run "lua push backup" first to enable pulling from server.');
-        }
-    }
-}
-/**
- * Handle governance drift interactively.
- * Governance is push-only — pull is not supported since it's a structured config
- * object defined in code, not a simple string we can write back.
- */
-async function handleGovernanceDriftInteractive(context, drift) {
-    showGovernanceDiff(drift.serverGovernance, drift.localGovernance);
-    const answer = await safePrompt([
-        {
-            type: 'list',
-            name: 'action',
-            message: 'What would you like to do with governance config?',
-            choices: [
-                { name: '📤 Push local to server', value: 'push' },
-                { name: '⏭️  Skip', value: 'skip' },
-            ],
-        },
-    ]);
-    if (!answer || answer.action === 'skip') {
-        writeInfo('Skipped governance sync.');
-        return;
-    }
-    if (answer.action === 'push') {
-        writeProgress('📤 Pushing governance config to server...');
-        try {
-            if (await agentHandler.pushGovernance(context, drift.localGovernance)) {
-                writeSuccess('✅ Governance config pushed to server');
-            }
-            else {
-                console.error('❌ Failed to push governance config');
-            }
-        }
-        catch (error) {
-            console.error('❌ Failed to push governance config:', error.message);
-        }
-    }
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Compile Flow Integration
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Run sync check during compile flow.
- * By default, warns about drift but continues compilation (non-blocking).
- */
-export async function runSyncCheck(apiKey, agentId) {
-    const drift = await agentHandler.checkDrift(apiKey, agentId);
-    if (!agentHandler.hasDrift(drift)) {
-        return true;
-    }
-    // Warn about drift but continue compilation
-    console.log('\n⚠️  Drift detected between local code and server.');
-    if (drift.name) {
-        writeInfo(`   Name: local "${drift.name.localName}" ≠ server "${drift.name.serverName || '(empty)'}"`);
-    }
-    if (drift.persona) {
-        writeInfo('   Persona: local and server versions differ');
-    }
-    if (drift.model) {
-        writeInfo(`   Model: local "${drift.model.localModel}" ≠ server "${drift.model.serverModel || '(empty)'}"`);
-    }
-    if (drift.governance) {
-        const localMode = drift.governance.localGovernance?.mode || '(none)';
-        const serverMode = drift.governance.serverGovernance?.mode || '(none)';
-        writeInfo(`   Governance: local "${localMode}" ≠ server "${serverMode}"`);
-    }
-    console.log();
-    writeInfo('💡 To resolve drift:');
-    writeInfo('   lua sync --push    Push local changes to server');
-    writeInfo('   lua sync --accept  Pull server changes to local');
-    writeInfo('   lua sync           Interactive resolution');
-    console.log();
-    return true;
-}
-//# sourceMappingURL=sync.js.map