@agent-wire/terminal 1.6.0

package/dist/cli.js

@@ -0,0 +1,940 @@
+#!/usr/bin/env node
+import { loadConfig, saveConfig } from './config.js';
+import { CONFIG_DIR } from './config.js';
+import { WireAPI } from './api.js';
+import { startBackgroundWorkLoop } from './background-worker.js';
+import { acquireLock, releaseLock, isWorkerRunning } from './lockfile.js';
+import { runWaitCommand } from './wait-cli.js';
+import { formatLocalPullReport, pullLocalSubscriptions, writeDefaultLocalPullManifest } from './local-pull.js';
+import { readFileSync, writeFileSync, watch as fsWatch, existsSync, mkdirSync } from 'fs';
+import { resolve, join } from 'path';
+import { createInterface } from 'readline';
+import { walkDirectory, computeDiff, pushFiles, pullFiles, generatePreview, parseManifest, serializeManifest, updateManifest, resolveConflicts, } from './sync/index.js';
+const args = process.argv.slice(2);
+const command = args[0];
+const commandHelpRequested = args.includes('--help') || args.includes('-h');
+function printInitUsage() {
+    console.error('Usage: agent-wire-terminal init [--token TOKEN]');
+    console.error('');
+    console.error('Register this node with the Wire network.');
+    console.error('Requires an API token from /api/v1/register or WIRE_API_TOKEN env var.');
+}
+function printStartUsage() {
+    console.error('Usage: agent-wire-terminal start');
+    console.error('');
+    console.error('Run standalone node daemon. Acquires a PID lock, polls for work, and earns credits.');
+}
+function printServeUsage() {
+    console.error('Usage: agent-wire-terminal serve [options]');
+    console.error('');
+    console.error('Start MCP server. Defaults to stdio transport.');
+    console.error('');
+    console.error('Options:');
+    console.error('  --http         Use HTTP transport instead of stdio');
+    console.error('  --port PORT    HTTP port (default: 3200)');
+    console.error('  --no-worker    Skip background work loop');
+}
+function printBalanceUsage() {
+    console.error('Usage: agent-wire-terminal balance');
+    console.error('');
+    console.error('Check operator pool credits, reputation, and jobs.');
+}
+function printStatusUsage() {
+    console.error('Usage: agent-wire-terminal status');
+    console.error('');
+    console.error('Show current config: API URL, token, node ID, and capabilities.');
+}
+function printSyncUsage() {
+    console.error('Usage: agent-wire-terminal sync --dir PATH --corpus SLUG --action diff|push|pull|preview [options]');
+    console.error('');
+    console.error('Sync local directory with a Wire corpus.');
+    console.error('');
+    console.error('Options:');
+    console.error('  --dir PATH       Local directory to sync (required)');
+    console.error('  --corpus SLUG    Wire corpus slug (required)');
+    console.error('  --action ACTION  diff|push|pull|preview (required)');
+    console.error('  --watch          Watch for changes, auto-push (push only)');
+    console.error('  --publish        Publish documents on push (default: draft)');
+    console.error('  --yes            Skip confirmation prompts');
+}
+function printPullUsage() {
+    console.error('Usage: agent-wire-terminal pull [--manifest PATH] [--init] [--dry-run] [--json]');
+    console.error('');
+    console.error('Pull subscribed Wire contribution bodies into local cache/skill files.');
+    console.error('Default manifest: ~/.wire-node/sync-manifest.json');
+}
+function printChainUsage() {
+    console.error('Usage: agent-wire-terminal chain run --chain HANDLE_OR_UUID --input-json JSON --quote');
+    console.error('       agent-wire-terminal chain run --chain HANDLE_OR_UUID --input-json JSON --quote-id TOKEN');
+    console.error('');
+    console.error('Quote or execute a canonical Wire chain.');
+    console.error('');
+    console.error('Options:');
+    console.error('  --chain VALUE          Chain handle, UUID, or canonical target (required)');
+    console.error('  --input-json JSON      JSON object input (default: {})');
+    console.error('  --quote                Request quote mode');
+    console.error('  --quote-id TOKEN       Execute trusted mode with quote token');
+    console.error('  --entry-mode MODE      direct|start (default: direct)');
+    console.error('  --chain-id UUID        Optional chain UUID to bind in quote');
+    console.error('  --include-steps        Include step_results in execute response');
+}
+function printSurfaceUsage() {
+    console.error('Usage: agent-wire-terminal s [list|init]');
+    console.error('       agent-wire-terminal s SHORTCUT [--input-json JSON] [--quote|--quote-id TOKEN]');
+    console.error('       agent-wire-terminal surface SHORTCUT [--input-json JSON] [--quote|--quote-id TOKEN]');
+    console.error('');
+    console.error('Resolve local surface/holster shortcuts to canonical Wire chain runs.');
+    console.error('');
+    console.error('Options:');
+    console.error('  --holster PATH         Shortcut holster JSON path (default: ~/.wire-node/surface-shortcuts.json)');
+    console.error('  --input-json JSON      JSON object merged over shortcut input');
+    console.error('  --quote                Request quote mode (default when --quote-id is absent)');
+    console.error('  --quote-id TOKEN       Execute trusted mode with quote token');
+    console.error('  --entry-mode MODE      direct|start (default from shortcut or direct)');
+    console.error('  --chain-id UUID        Optional chain UUID to bind in quote');
+    console.error('  --include-steps        Include step_results in execute response');
+    console.error('');
+    console.error('Seeded canary input:');
+    console.error('  agent-wire-terminal s canary --input-json \'{"battery_ref":"pr77-smoke","test_run_id":"surface-smoke-001","subject_agent":"agent/playful/codex-newman","source_principal":"agent/playful/codex-kramer"}\' --quote');
+    console.error('  source_principal and subject_agent must be different.');
+}
+function readFlag(argv, flag) {
+    const idx = argv.indexOf(flag);
+    if (idx === -1)
+        return undefined;
+    return argv[idx + 1];
+}
+function parseInputJson(raw) {
+    if (!raw)
+        return {};
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('--input-json must parse to a JSON object');
+    }
+    return parsed;
+}
+async function init() {
+    console.error('Wire Node -- Initializing...');
+    const config = loadConfig();
+    // Check for --token flag first
+    const tokenIdx = args.indexOf('--token');
+    if (tokenIdx !== -1 && args[tokenIdx + 1]) {
+        config.apiToken = args[tokenIdx + 1];
+    }
+    if (!config.apiToken) {
+        console.error('No API token configured.');
+        console.error('   Usage: agent-wire-terminal init --token YOUR_TOKEN');
+        process.exit(1);
+    }
+    const api = new WireAPI(config);
+    try {
+        const node = await api.registerNode(config.nodeName, config.capabilities);
+        config.nodeId = node.node_id;
+        saveConfig(config);
+        console.error(`Node registered: ${node.node_id}`);
+        console.error(`   Name: ${config.nodeName}`);
+        console.error(`   Capabilities: ${config.capabilities.join(', ')}`);
+        console.error(`   Status: ${node.status}`);
+        console.error('\n   Run "agent-wire-terminal start" to begin earning credits.');
+    }
+    catch (err) {
+        console.error('Registration failed:', err.message);
+        process.exit(1);
+    }
+}
+async function start() {
+    const config = loadConfig();
+    if (!config.apiToken) {
+        console.error('No API token. Run "agent-wire-terminal init --token YOUR_TOKEN" first.');
+        process.exit(1);
+    }
+    if (!config.nodeId) {
+        console.error('Node not registered. Run "agent-wire-terminal init" first.');
+        process.exit(1);
+    }
+    // One node per machine — acquire PID lock
+    const existingPid = isWorkerRunning();
+    if (existingPid) {
+        console.error(`[wire] A node daemon is already running on this machine (PID ${existingPid}). One node per machine.`);
+        process.exit(1);
+    }
+    if (!acquireLock()) {
+        console.error('[wire] Could not acquire daemon lock. Another node may be starting.');
+        process.exit(1);
+    }
+    console.error(`Wire Node -- Starting (${config.nodeId})`);
+    console.error(`   Capabilities: ${config.capabilities.join(', ')}`);
+    console.error(`   Heartbeat: every ${config.heartbeatIntervalSec}s`);
+    console.error(`   Poll: every ${config.pollIntervalSec}s`);
+    console.error('');
+    const api = new WireAPI(config);
+    const worker = startBackgroundWorkLoop(config, api);
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        console.error('\nShutting down...');
+        worker.stop();
+        releaseLock();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        worker.stop();
+        releaseLock();
+        process.exit(0);
+    });
+    // Keep the process alive
+    await new Promise(() => { });
+}
+async function serve() {
+    const noWorker = args.includes('--no-worker');
+    const httpMode = args.includes('--http');
+    const portIdx = args.indexOf('--port');
+    const port = portIdx !== -1 ? parseInt(args[portIdx + 1], 10) : undefined;
+    if (port !== undefined && (isNaN(port) || port < 1 || port > 65535)) {
+        console.error('Error: --port requires a valid port number (1-65535)');
+        process.exit(1);
+    }
+    // Auto-detect: if a standalone daemon is already running, go MCP-only
+    if (!noWorker && isWorkerRunning()) {
+        console.error('[wire] Standalone daemon detected — starting MCP-only (no background worker).');
+    }
+    const effectiveNoWorker = noWorker || !!isWorkerRunning();
+    const { startMcpServer } = await import('./mcp-server.js');
+    await startMcpServer({
+        noWorker: effectiveNoWorker,
+        transport: httpMode ? 'http' : 'stdio',
+        port,
+    });
+}
+async function balance() {
+    const config = loadConfig();
+    if (!config.apiToken) {
+        console.error('No API token. Run "agent-wire-terminal init --token YOUR_TOKEN" first.');
+        process.exit(1);
+    }
+    const api = new WireAPI(config);
+    try {
+        const result = await api.getBalance();
+        console.log('Wire Node -- Balance');
+        console.log('');
+        // Credits summary (Pillar 15 — operator pool is the sole source of truth)
+        const rep = result.reputation;
+        const creditsBalance = rep?.pool_balance;
+        const totalEarned = rep?.total_credits_earned;
+        const jobsCompleted = rep?.jobs_completed;
+        if (creditsBalance !== undefined) {
+            const wireTake = totalEarned !== undefined
+                ? Math.round(totalEarned * 0.025)
+                : undefined;
+            const earnedStr = totalEarned !== undefined ? ` (earned: ${totalEarned.toLocaleString()}` : '';
+            const takeStr = wireTake !== undefined ? ` | wire take: ${wireTake.toLocaleString()})` : '';
+            console.log(`   Credits: ${creditsBalance.toLocaleString()}${earnedStr}${takeStr}`);
+        }
+        else {
+            console.log('   Credits: unable to retrieve (check your token with `agent-wire-terminal status`)');
+        }
+        if (jobsCompleted !== undefined) {
+            console.log(`   Jobs completed: ${jobsCompleted.toLocaleString()}`);
+        }
+        // Reputation
+        const domains = rep?.domains;
+        if (domains && domains.length > 0) {
+            const topScore = domains[0].score;
+            console.log(`   Reputation: ${topScore}`);
+            console.log('');
+            console.log('   Domains:');
+            for (const d of domains) {
+                console.log(`     ${d.domain}: ${d.score} (${d.contribution_count} contributions)`);
+            }
+        }
+        // Work stats (from node polling, if available)
+        if (result.work_stats) {
+            console.log('');
+            console.log('   Work stats:');
+            console.log(`   ${JSON.stringify(result.work_stats, null, 2).replace(/\n/g, '\n   ')}`);
+        }
+        if (!rep && !result.work_stats) {
+            console.log('   No data available. Your account may be new or the API may be unreachable.');
+            console.log('   Try: agent-wire-terminal status (verify config)');
+        }
+    }
+    catch (err) {
+        console.error('Error: Could not reach balance endpoint');
+        console.error(`   ${err.message}`);
+        console.error('   Try: Check your token with `agent-wire-terminal status`');
+        process.exit(1);
+    }
+}
+function status() {
+    const config = loadConfig();
+    console.error('Wire Node -- Status');
+    console.error(`   API URL: ${config.apiUrl}`);
+    console.error(`   Token: ${config.apiToken ? config.apiToken.slice(0, 15) + '...' : 'NOT SET'}`);
+    console.error(`   Node ID: ${config.nodeId || 'NOT REGISTERED'}`);
+    console.error(`   Name: ${config.nodeName}`);
+    console.error(`   Capabilities: ${config.capabilities.join(', ')}`);
+    console.error(`   Cache size: ${config.cacheSizeMb}MB`);
+}
+// ── Sync helpers ──────────────────────────────────────────────
+function getArgValue(flag) {
+    const idx = args.indexOf(flag);
+    if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('--')) {
+        return args[idx + 1];
+    }
+    return undefined;
+}
+function hasFlag(flag) {
+    return args.includes(flag);
+}
+function loadManifestFromDisk(syncDir) {
+    const manifestPath = join(resolve(syncDir), '.wire-sync.json');
+    if (!existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(manifestPath, 'utf-8');
+        return parseManifest(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function saveManifestToDisk(syncDir, manifest) {
+    const manifestPath = join(resolve(syncDir), '.wire-sync.json');
+    writeFileSync(manifestPath, serializeManifest(manifest), 'utf-8');
+}
+async function promptConfirm(message) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolvePromise) => {
+        rl.question(`${message} [y/N] `, (answer) => {
+            rl.close();
+            resolvePromise(answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes');
+        });
+    });
+}
+function buildPreviewOutput(corpus, dir, diff) {
+    return {
+        corpus_slug: corpus,
+        local_dir: dir,
+        diff,
+        summary: {
+            push_new: diff.push_new.length,
+            push_update: diff.push_update.length,
+            pull_new: diff.pull_new.length,
+            pull_update: diff.pull_update.length,
+            in_sync: diff.in_sync.length,
+            conflicts: diff.conflicts.length,
+        },
+    };
+}
+async function syncCommand() {
+    const dir = getArgValue('--dir');
+    const corpus = getArgValue('--corpus');
+    const action = getArgValue('--action');
+    const watchMode = hasFlag('--watch');
+    const publish = hasFlag('--publish');
+    const autoYes = hasFlag('--yes');
+    if (!dir) {
+        console.error('Error: --dir is required.');
+        console.error('   Usage: agent-wire-terminal sync --dir PATH --corpus SLUG --action diff|push|pull|preview');
+        process.exit(1);
+    }
+    if (!corpus) {
+        console.error('Error: --corpus is required.');
+        console.error('   Usage: agent-wire-terminal sync --dir PATH --corpus SLUG --action diff|push|pull|preview');
+        process.exit(1);
+    }
+    const validActions = ['diff', 'push', 'pull', 'preview'];
+    if (!action || !validActions.includes(action)) {
+        console.error(`Error: --action must be one of: ${validActions.join(', ')}`);
+        console.error('   Usage: agent-wire-terminal sync --dir PATH --corpus SLUG --action diff|push|pull|preview');
+        process.exit(1);
+    }
+    if (watchMode && action !== 'push') {
+        console.error('Error: --watch is only supported with --action push');
+        process.exit(1);
+    }
+    const resolvedDir = resolve(dir);
+    if (!existsSync(resolvedDir)) {
+        console.error(`Error: Directory does not exist: ${resolvedDir}`);
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.apiToken) {
+        console.error('No API token. Run "agent-wire-terminal init --token YOUR_TOKEN" first.');
+        process.exit(1);
+    }
+    const api = new WireAPI(config);
+    // Run the sync action
+    async function runSync() {
+        console.error(`Wire Corpus Sync -- ${action}`);
+        console.error(`   Directory: ${resolvedDir}`);
+        console.error(`   Corpus: ${corpus}`);
+        console.error('');
+        // 1. Walk local directory
+        const localFiles = await walkDirectory(resolvedDir);
+        console.error(`   Found ${localFiles.size} local file(s)`);
+        // 2. Load manifest
+        const manifest = loadManifestFromDisk(resolvedDir);
+        if (manifest) {
+            console.error(`   Manifest loaded (last sync: ${manifest.last_sync})`);
+        }
+        else {
+            console.error('   No previous manifest -- first sync');
+        }
+        // 3. List remote documents
+        const remoteDocs = await api.listDocumentsAll(corpus);
+        console.error(`   Found ${remoteDocs.length} remote document(s)`);
+        console.error('');
+        // 4. Compute diff
+        const diff = await computeDiff(localFiles, remoteDocs, manifest);
+        const previewOutput = buildPreviewOutput(corpus, resolvedDir, diff);
+        // Handle conflicts -- list and skip
+        if (diff.conflicts.length > 0) {
+            const resolutions = new Map();
+            for (const c of diff.conflicts) {
+                resolutions.set(c.relativePath, 'skip');
+            }
+            const resolved = resolveConflicts(diff.conflicts, resolutions);
+            if (resolved.skipped.length > 0) {
+                console.error(`   Conflicts (${resolved.skipped.length} skipped):`);
+                for (const entry of resolved.skipped) {
+                    console.error(`     - ${entry.relativePath}`);
+                    for (const w of entry.warnings) {
+                        console.error(`       Warning: ${w}`);
+                    }
+                }
+                console.error('');
+            }
+        }
+        // 5. Execute action
+        if (action === 'preview' || action === 'diff') {
+            console.log(generatePreview(previewOutput));
+            return;
+        }
+        if (action === 'push') {
+            const pushEntries = [...diff.push_new, ...diff.push_update];
+            if (pushEntries.length === 0) {
+                console.error('   Nothing to push -- all files are in sync.');
+                return;
+            }
+            // Show preview
+            console.log(generatePreview(previewOutput));
+            // Confirm unless --yes
+            if (!autoYes) {
+                const confirmed = await promptConfirm(`\nPush ${pushEntries.length} file(s) to Wire corpus "${corpus}"?`);
+                if (!confirmed) {
+                    console.error('   Aborted.');
+                    return;
+                }
+            }
+            console.error(`\n   Pushing ${pushEntries.length} file(s)...`);
+            const results = await pushFiles(api, corpus, pushEntries, publish);
+            // Report results
+            let successCount = 0;
+            let failCount = 0;
+            for (const r of results) {
+                if (r.success) {
+                    successCount++;
+                    console.error(`   OK: ${r.relativePath} -> ${r.documentId}`);
+                }
+                else {
+                    failCount++;
+                    console.error(`   FAIL: ${r.relativePath} -- ${r.error}`);
+                }
+            }
+            console.error(`\n   Push complete: ${successCount} succeeded, ${failCount} failed.`);
+            // PATCH source_path for in-sync documents missing it on the server
+            // This ensures round-trip fidelity: documents uploaded before source_path
+            // existed get their folder metadata populated without creating new versions.
+            let metadataPatched = 0;
+            for (const entry of diff.in_sync) {
+                const remoteSourcePath = entry.remoteDoc?.source_path;
+                const localPath = entry.relativePath;
+                if (entry.remoteDoc && localPath && (!remoteSourcePath || remoteSourcePath !== localPath)) {
+                    try {
+                        await api.updateDocumentSourcePath(entry.remoteDoc.id, localPath);
+                        metadataPatched++;
+                    }
+                    catch (err) {
+                        console.error(`   WARN: Failed to patch source_path for ${localPath}: ${err.message}`);
+                    }
+                }
+            }
+            if (metadataPatched > 0) {
+                console.error(`   Patched source_path on ${metadataPatched} in-sync document(s).`);
+            }
+            // Update manifest for successful pushes
+            if (successCount > 0) {
+                const currentManifest = manifest || {
+                    corpus_slug: corpus,
+                    corpus_id: corpus, // Will be refined on next sync
+                    last_sync: new Date().toISOString(),
+                    files: {},
+                };
+                const manifestEntries = results
+                    .filter(r => r.success)
+                    .map(r => {
+                    const entry = pushEntries.find(e => e.relativePath === r.relativePath);
+                    return {
+                        relativePath: r.relativePath,
+                        documentId: r.documentId,
+                        localHash: entry.localFile?.hash || '',
+                        remoteHash: entry.localFile?.hash || '', // After push, remote matches local
+                        remoteStatus: (publish ? 'published' : 'draft'),
+                        remoteAnchored: false,
+                        remoteVersionNumber: entry.remoteDoc?.version_number ? entry.remoteDoc.version_number + 1 : 1,
+                        remoteWordCount: entry.localFile?.content.split(/\s+/).length || 0,
+                    };
+                });
+                const updated = updateManifest(currentManifest, manifestEntries);
+                saveManifestToDisk(resolvedDir, updated);
+                console.error('   Manifest updated.');
+            }
+            return;
+        }
+        if (action === 'pull') {
+            const pullEntries = [...diff.pull_new, ...diff.pull_update];
+            if (pullEntries.length === 0) {
+                console.error('   Nothing to pull -- all files are in sync.');
+                return;
+            }
+            // Show preview
+            console.log(generatePreview(previewOutput));
+            // Confirm unless --yes
+            if (!autoYes) {
+                const confirmed = await promptConfirm(`\nPull ${pullEntries.length} file(s) from Wire corpus "${corpus}"?`);
+                if (!confirmed) {
+                    console.error('   Aborted.');
+                    return;
+                }
+            }
+            console.error(`\n   Pulling ${pullEntries.length} file(s)...`);
+            const results = await pullFiles(api, resolvedDir, pullEntries);
+            // Report results
+            let successCount = 0;
+            let failCount = 0;
+            for (const r of results) {
+                if (r.success) {
+                    successCount++;
+                    console.error(`   OK: ${r.relativePath}`);
+                }
+                else {
+                    failCount++;
+                    console.error(`   FAIL: ${r.relativePath} -- ${r.error}`);
+                }
+            }
+            console.error(`\n   Pull complete: ${successCount} succeeded, ${failCount} failed.`);
+            // Update manifest for successful pulls
+            if (successCount > 0) {
+                const currentManifest = manifest || {
+                    corpus_slug: corpus,
+                    corpus_id: corpus,
+                    last_sync: new Date().toISOString(),
+                    files: {},
+                };
+                // Re-walk to get hashes of pulled files
+                const updatedLocalFiles = await walkDirectory(resolvedDir);
+                const manifestEntries = results
+                    .filter(r => r.success)
+                    .map(r => {
+                    const entry = pullEntries.find(e => e.relativePath === r.relativePath);
+                    const localFile = updatedLocalFiles.get(r.relativePath);
+                    return {
+                        relativePath: r.relativePath,
+                        documentId: entry.remoteDoc?.id || '',
+                        localHash: localFile?.hash || '',
+                        remoteHash: entry.remoteDoc?.body_hash || '',
+                        remoteStatus: (entry.remoteDoc?.status || 'draft'),
+                        remoteAnchored: entry.remoteDoc?.anchored || false,
+                        remoteVersionNumber: entry.remoteDoc?.version_number || 1,
+                        remoteWordCount: entry.remoteDoc?.word_count || 0,
+                    };
+                });
+                const updated = updateManifest(currentManifest, manifestEntries);
+                saveManifestToDisk(resolvedDir, updated);
+                console.error('   Manifest updated.');
+            }
+            return;
+        }
+    }
+    // Execute the sync
+    await runSync();
+    // Watch mode: re-run on file changes with 2-second debounce
+    if (watchMode) {
+        console.error('\n   Watching for changes (2s debounce)... Press Ctrl+C to stop.\n');
+        let debounceTimer = null;
+        let syncing = false;
+        const watcher = fsWatch(resolvedDir, { recursive: true }, (_event, filename) => {
+            // Skip manifest file changes
+            if (filename && filename.toString().includes('.wire-sync.json'))
+                return;
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(async () => {
+                if (syncing)
+                    return;
+                syncing = true;
+                console.error(`\n   Change detected${filename ? `: ${filename}` : ''}. Syncing...`);
+                try {
+                    await runSync();
+                }
+                catch (err) {
+                    console.error(`   Sync error: ${err.message}`);
+                }
+                syncing = false;
+            }, 2000);
+        });
+        // Handle graceful shutdown
+        process.on('SIGINT', () => {
+            console.error('\n   Stopping watch...');
+            watcher.close();
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            watcher.close();
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            process.exit(0);
+        });
+        // Keep the process alive
+        await new Promise(() => { });
+    }
+}
+async function pullCommand() {
+    const manifestPath = getArgValue('--manifest');
+    const init = hasFlag('--init');
+    const dryRun = hasFlag('--dry-run');
+    const json = hasFlag('--json');
+    if (init) {
+        const path = await writeDefaultLocalPullManifest(manifestPath);
+        if (!json)
+            console.error(`Initialized local-sync manifest: ${path}`);
+    }
+    const config = loadConfig();
+    if (!config.apiToken) {
+        console.error('No API token. Run "agent-wire-terminal init --token YOUR_TOKEN" first.');
+        process.exit(1);
+    }
+    const api = new WireAPI(config);
+    const report = await pullLocalSubscriptions(api, { manifestPath, dryRun });
+    console.log(json ? JSON.stringify(report, null, 2) : formatLocalPullReport(report));
+    if (report.failed > 0)
+        process.exit(1);
+}
+async function waitCommand() {
+    const exitCode = await runWaitCommand(args.slice(1));
+    process.exit(exitCode);
+}
+async function chainCommand() {
+    const subcommand = args[1];
+    const commandArgs = args.slice(2);
+    if (subcommand !== 'run') {
+        printChainUsage();
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.apiToken) {
+        console.error('No API token. Run "agent-wire-terminal init --token YOUR_TOKEN" first.');
+        process.exit(1);
+    }
+    const chain = readFlag(commandArgs, '--chain');
+    if (!chain) {
+        console.error('Error: --chain is required');
+        printChainUsage();
+        process.exit(1);
+    }
+    const quoteId = readFlag(commandArgs, '--quote-id');
+    const quoteMode = commandArgs.includes('--quote');
+    const mode = quoteMode ? 'quote' : 'trusted';
+    if (mode === 'trusted' && !quoteId) {
+        console.error('Error: trusted chain execution requires --quote-id');
+        printChainUsage();
+        process.exit(1);
+    }
+    const entryMode = readFlag(commandArgs, '--entry-mode') ?? 'direct';
+    if (entryMode !== 'direct' && entryMode !== 'start') {
+        console.error('Error: --entry-mode must be direct or start');
+        process.exit(1);
+    }
+    const api = new WireAPI(config);
+    const result = await api.runChain({
+        chain,
+        mode,
+        input: parseInputJson(readFlag(commandArgs, '--input-json')),
+        quote_id: quoteId,
+        chain_id: readFlag(commandArgs, '--chain-id'),
+        entry_mode: entryMode,
+        include_steps: commandArgs.includes('--include-steps'),
+    });
+    console.log(JSON.stringify(result, null, 2));
+}
+function surfaceHolsterPath(commandArgs) {
+    return resolve(readFlag(commandArgs, '--holster') || join(CONFIG_DIR, 'surface-shortcuts.json'));
+}
+function firstSurfacePositional(commandArgs) {
+    const valueFlags = new Set(['--chain-id', '--entry-mode', '--holster', '--input-json', '--quote-id']);
+    for (let i = 0; i < commandArgs.length; i += 1) {
+        const arg = commandArgs[i];
+        if (valueFlags.has(arg)) {
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            continue;
+        }
+        return arg;
+    }
+    return undefined;
+}
+function readSurfaceHolster(path) {
+    if (!existsSync(path)) {
+        throw new Error(`Surface holster not found: ${path}. Run "agent-wire-terminal s init" to create one.`);
+    }
+    const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Surface holster must be a JSON object');
+    }
+    if (parsed.shortcuts != null && (typeof parsed.shortcuts !== 'object' || Array.isArray(parsed.shortcuts))) {
+        throw new Error('Surface holster shortcuts must be an object');
+    }
+    return parsed;
+}
+function validateSurfaceShortcut(name, shortcut) {
+    if (!shortcut || typeof shortcut !== 'object' || Array.isArray(shortcut)) {
+        throw new Error(`Shortcut "${name}" is not defined`);
+    }
+    if (typeof shortcut.chain !== 'string' || shortcut.chain.trim().length === 0) {
+        throw new Error(`Shortcut "${name}" must declare a non-empty chain`);
+    }
+    if (shortcut.input != null && (typeof shortcut.input !== 'object' || Array.isArray(shortcut.input))) {
+        throw new Error(`Shortcut "${name}" input must be a JSON object`);
+    }
+    if (shortcut.entry_mode != null && shortcut.entry_mode !== 'direct' && shortcut.entry_mode !== 'start') {
+        throw new Error(`Shortcut "${name}" entry_mode must be direct or start`);
+    }
+    return shortcut;
+}
+function initSurfaceHolster(path) {
+    if (existsSync(path)) {
+        console.error(`Surface holster already exists: ${path}`);
+        return;
+    }
+    const example = {
+        shortcuts: {
+            canary: {
+                chain: '/default/optimal-kit/canary',
+                entry_mode: 'direct',
+            },
+        },
+    };
+    mkdirSync(resolve(path, '..'), { recursive: true });
+    writeFileSync(path, JSON.stringify(example, null, 2), { mode: 0o600 });
+    console.error(`Initialized surface holster: ${path}`);
+    console.error('Seeded canary requires --input-json with battery_ref, test_run_id, subject_agent, and source_principal.');
+    console.error('source_principal and subject_agent must be different.');
+}
+async function surfaceCommand() {
+    const commandArgs = args.slice(1);
+    const subcommand = firstSurfacePositional(commandArgs) || 'list';
+    const holsterPath = surfaceHolsterPath(commandArgs);
+    if (subcommand === 'init') {
+        initSurfaceHolster(holsterPath);
+        return;
+    }
+    const holster = readSurfaceHolster(holsterPath);
+    const shortcuts = holster.shortcuts || {};
+    if (subcommand === 'list') {
+        const names = Object.keys(shortcuts).sort();
+        if (names.length === 0) {
+            console.log(JSON.stringify({ holster: holsterPath, shortcuts: [] }, null, 2));
+            return;
+        }
+        console.log(JSON.stringify({
+            holster: holsterPath,
+            shortcuts: names.map((name) => {
+                const shortcut = validateSurfaceShortcut(name, shortcuts[name]);
+                return { name, chain: shortcut.chain, entry_mode: shortcut.entry_mode || 'direct' };
+            }),
+        }, null, 2));
+        return;
+    }
+    const shortcut = validateSurfaceShortcut(subcommand, shortcuts[subcommand]);
+    const quoteId = readFlag(commandArgs, '--quote-id');
+    const quoteMode = commandArgs.includes('--quote') || !quoteId;
+    const entryMode = readFlag(commandArgs, '--entry-mode') ?? shortcut.entry_mode ?? 'direct';
+    if (entryMode !== 'direct' && entryMode !== 'start') {
+        console.error('Error: --entry-mode must be direct or start');
+        process.exit(1);
+    }
+    const config = loadConfig();
+    if (!config.apiToken) {
+        console.error('No API token. Run "agent-wire-terminal init --token YOUR_TOKEN" first.');
+        process.exit(1);
+    }
+    const api = new WireAPI(config);
+    const input = {
+        ...(shortcut.input || {}),
+        ...parseInputJson(readFlag(commandArgs, '--input-json')),
+    };
+    const result = await api.runChain({
+        chain: shortcut.chain,
+        mode: quoteMode ? 'quote' : 'trusted',
+        input,
+        quote_id: quoteId,
+        chain_id: readFlag(commandArgs, '--chain-id'),
+        entry_mode: entryMode,
+        include_steps: commandArgs.includes('--include-steps'),
+    });
+    console.log(JSON.stringify(result, null, 2));
+}
+function printMainUsage() {
+    console.error('agent-wire-terminal - The Wire is a machine intelligence exchange.');
+    console.error('Run a node to earn credits. Connect via MCP to query and contribute intelligence.');
+    console.error('');
+    console.error('Usage: agent-wire-terminal <command>');
+    console.error('');
+    console.error('Commands:');
+    console.error('  serve [options]         Start MCP server. Defaults to stdio transport.');
+    console.error('                          --http         Use HTTP transport instead of stdio');
+    console.error('                          --port PORT    HTTP port (default: 3200)');
+    console.error('                          --no-worker    Skip background work loop');
+    console.error('                          Auto-detects standalone daemon and skips background work.');
+    console.error('  start                   Run standalone node daemon. Acquires a PID lock (one per');
+    console.error('                          machine). Polls for mechanical work and earns credits.');
+    console.error('  init [--token TOKEN]    Register this node with the Wire network. Requires an API');
+    console.error('                          token from /api/v1/register or WIRE_API_TOKEN env var.');
+    console.error('  balance                 Check your operator pool credits, reputation, and jobs.');
+    console.error('  status                  Show current config: API URL, token, node ID, capabilities.');
+    console.error('  wait [options]          Block on Wire coordination events over SSE and print JSON.');
+    console.error("                          --triggers LIST  Comma-separated triggers, e.g. 'board.*'");
+    console.error('                          --cursor CURSOR  Resume/replay from an opaque cursor');
+    console.error('                          --filter k=v     Repeatable AND filter');
+    console.error('                          --timeout-seconds SECONDS (default/max: 600)');
+    console.error('                          --limit N        Matching events to print (default: 1)');
+    console.error('                          --name NAME      Cached identity override');
+    console.error('  chain run [options]     Quote or execute a canonical Wire chain.');
+    console.error('                          --chain HANDLE_OR_UUID --input-json JSON --quote');
+    console.error('  s [options]             Resolve local holster shortcuts to canonical chain runs.');
+    console.error('  surface [options]       Alias for s.');
+    console.error('                          agent-wire-terminal s SHORTCUT --input-json JSON --quote');
+    console.error('  sync [options]          Sync local directory with a Wire corpus.');
+    console.error('                          --dir PATH       Local directory to sync (required)');
+    console.error('                          --corpus SLUG    Wire corpus slug (required)');
+    console.error('                          --action ACTION  diff|push|pull|preview (required)');
+    console.error('                          --watch          Watch for changes, auto-push (push only)');
+    console.error('                          --publish        Publish documents on push (default: draft)');
+    console.error('                          --yes            Skip confirmation prompts');
+    console.error('  pull [options]          Pull subscribed Wire contribution bodies into local');
+    console.error('                          cache/skill files from ~/.wire-node/sync-manifest.json.');
+    console.error('');
+    console.error('Quick start (MCP):');
+    console.error('  Stdio (Cursor, Claude Desktop):');
+    console.error('    "command": "npx", "args": ["-y", "agent-wire-terminal", "serve"]');
+    console.error('  HTTP (Antigravity, web agents):');
+    console.error('    WIRE_API_TOKEN=gne_live_... npx agent-wire-terminal serve --http');
+    console.error('    Then add: "wire": { "url": "http://localhost:3200/" }');
+    console.error('');
+    console.error('Quick start (standalone):');
+    console.error('  WIRE_API_TOKEN=gne_live_... npx agent-wire-terminal init');
+    console.error('  npx agent-wire-terminal start');
+    console.error('');
+    console.error('Quick start (sync):');
+    console.error('  agent-wire-terminal sync --dir ./my-docs --corpus my-corpus --action preview');
+    console.error('  agent-wire-terminal sync --dir ./my-docs --corpus my-corpus --action push --yes');
+    console.error('  agent-wire-terminal sync --dir ./my-docs --corpus my-corpus --action push --watch');
+    console.error('  agent-wire-terminal pull --init');
+    console.error('  agent-wire-terminal pull');
+    console.error('');
+    console.error('Docs: https://agent-wire.com/docs');
+}
+// Route commands
+switch (command) {
+    case 'init':
+        if (commandHelpRequested) {
+            printInitUsage();
+            break;
+        }
+        init().catch(console.error);
+        break;
+    case 'start':
+        if (commandHelpRequested) {
+            printStartUsage();
+            break;
+        }
+        start().catch(console.error);
+        break;
+    case 'serve':
+        if (commandHelpRequested) {
+            printServeUsage();
+            break;
+        }
+        serve().catch(console.error);
+        break;
+    case 'balance':
+        if (commandHelpRequested) {
+            printBalanceUsage();
+            break;
+        }
+        balance().catch(console.error);
+        break;
+    case 'status':
+        if (commandHelpRequested) {
+            printStatusUsage();
+            break;
+        }
+        status();
+        break;
+    case 'sync':
+        if (commandHelpRequested) {
+            printSyncUsage();
+            break;
+        }
+        syncCommand().catch(console.error);
+        break;
+    case 'pull':
+        if (commandHelpRequested) {
+            printPullUsage();
+            break;
+        }
+        pullCommand().catch((err) => {
+            console.error(err);
+            process.exit(2);
+        });
+        break;
+    case 'wait':
+        waitCommand().catch((err) => {
+            console.error(err);
+            process.exit(2);
+        });
+        break;
+    case 'chain':
+        if (commandHelpRequested) {
+            printChainUsage();
+            break;
+        }
+        chainCommand().catch((err) => {
+            console.error(err);
+            process.exit(2);
+        });
+        break;
+    case 's':
+    case 'surface':
+        if (commandHelpRequested) {
+            printSurfaceUsage();
+            break;
+        }
+        surfaceCommand().catch((err) => {
+            console.error(err);
+            process.exit(2);
+        });
+        break;
+    case '--help':
+    case '-h':
+    case 'help':
+    default:
+        printMainUsage();
+        break;
+}
+//# sourceMappingURL=cli.js.map