swarm-orchestrator 7.0.0-alpha.0

package/dist/src/cli/demo-handlers.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * Demo and template CLI command handlers.
+ * Extracted from cli-handlers.ts for modularity.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDemoDependencies = installDemoDependencies;
+exports.handleDemoCommand = handleDemoCommand;
+exports.runDemo = runDemo;
+exports.handleTemplatesCommand = handleTemplatesCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const demo_mode_1 = require("../demo-mode");
+const plan_files_1 = require("../plan-files");
+const flags_1 = require("./flags");
+const logger_1 = require("../logger");
+// Minimal ANSI helpers for a cleaner demo UX. No chalk dep to keep the
+// dist footprint unchanged. NO_COLOR env disables coloring for CI / pipes.
+const colorOn = process.stdout.isTTY && !process.env.NO_COLOR;
+const c = {
+    bold: (s) => colorOn ? `\x1b[1m${s}\x1b[22m` : s,
+    dim: (s) => colorOn ? `\x1b[2m${s}\x1b[22m` : s,
+    cyan: (s) => colorOn ? `\x1b[36m${s}\x1b[39m` : s,
+    magenta: (s) => colorOn ? `\x1b[35m${s}\x1b[39m` : s,
+    green: (s) => colorOn ? `\x1b[32m${s}\x1b[39m` : s,
+};
+const logger = (0, logger_1.getLogger)('cli:demo');
+/**
+ * Install npm dependencies for all package.json files in demo output.
+ * Makes the demo runnable immediately after completion.
+ */
+async function installDemoDependencies(demoDir) {
+    const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
+    const packageJsonPaths = [];
+    function findPackageJsons(dir, depth = 0) {
+        if (depth > 3)
+            return;
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'runs')
+                    continue;
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    findPackageJsons(fullPath, depth + 1);
+                }
+                else if (entry.name === 'package.json') {
+                    packageJsonPaths.push(dir);
+                }
+            }
+        }
+        catch {
+            // Permission denied or broken symlink; skip this subtree
+        }
+    }
+    findPackageJsons(demoDir);
+    if (packageJsonPaths.length === 0) {
+        return;
+    }
+    packageJsonPaths.sort((a, b) => a.length - b.length);
+    const colorOn = process.stdout.isTTY && !process.env.NO_COLOR;
+    const dim = (s) => colorOn ? `\x1b[2m${s}\x1b[22m` : s;
+    const green = (s) => colorOn ? `\x1b[32m${s}\x1b[39m` : s;
+    const red = (s) => colorOn ? `\x1b[31m${s}\x1b[39m` : s;
+    logger.info(`\n  ${dim(`installing dependencies (${packageJsonPaths.length} location${packageJsonPaths.length === 1 ? '' : 's'})`)}`);
+    let successCount = 0;
+    let failCount = 0;
+    for (const pkgDir of packageJsonPaths) {
+        const relativePath = path.relative(demoDir, pkgDir) || '.';
+        try {
+            execSync('npm install --loglevel=error', {
+                cwd: pkgDir,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: 120000
+            });
+            logger.info(`  ${green('✓')} ${relativePath}`);
+            successCount++;
+        }
+        catch {
+            logger.warn(`  ${red('✗')} ${relativePath} ${dim('(run npm install manually)')}`);
+            failCount++;
+        }
+    }
+    if (failCount > 0) {
+        logger.warn(`  ${dim(`installed ${successCount}/${packageJsonPaths.length}; resolve failures before running`)}`);
+    }
+    logger.info(`\n  ${dim('to run:')}`);
+    logger.info(`    cd ${demoDir}`);
+    const rootPkgPath = path.join(demoDir, 'package.json');
+    if (fs.existsSync(rootPkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(rootPkgPath, 'utf8'));
+            if (pkg.scripts?.['start:server']) {
+                logger.info(`    npm run start:server   ${dim('# backend')}`);
+            }
+            else if (pkg.scripts?.start) {
+                logger.info(`    npm start              ${dim('# server')}`);
+            }
+            if (pkg.scripts?.dev) {
+                logger.info(`    npm run dev            ${dim('# dev server')}`);
+            }
+            if (pkg.scripts?.test) {
+                logger.info(`    npm test               ${dim('# tests')}`);
+            }
+        }
+        catch {
+            logger.info('    npm start');
+        }
+    }
+    const frontendPkgPath = path.join(demoDir, 'frontend', 'package.json');
+    if (fs.existsSync(frontendPkgPath)) {
+        logger.info(`\n    ${dim('# frontend (separate terminal)')}`);
+        logger.info('    cd frontend && npm run dev');
+    }
+    logger.info('');
+}
+async function handleDemoCommand(args) {
+    const subcommand = args[1];
+    if (!subcommand || subcommand === '--help') {
+        (0, logger_1.setPrettyMode)(true);
+        logger.info('\n  demo scenarios');
+        logger.info('    demo-fast    two independent utility files, one wave');
+        logger.info('    api-quick    REST API + tests + Dockerfile, two waves');
+        logger.info('\n  run:  swarm demo <name>');
+        logger.info('  list: swarm demo list\n');
+        return 0;
+    }
+    if (subcommand === 'list') {
+        (0, logger_1.setPrettyMode)(true);
+        const demoMode = new demo_mode_1.DemoMode();
+        const scenarios = demoMode.getAvailableScenarios();
+        logger.info(`\n  ${c.bold('demo scenarios')}\n`);
+        scenarios.forEach(scenario => {
+            logger.info(`  ${c.bold(scenario.name)}`);
+            logger.info(`    ${c.dim(scenario.description)}`);
+            logger.info(`    ${c.dim(`${scenario.steps.length} step${scenario.steps.length === 1 ? '' : 's'} · ${scenario.expectedDuration}`)}\n`);
+        });
+        logger.info(`  ${c.dim('run:')} swarm demo <name>\n`);
+        return 0;
+    }
+    // Run a demo scenario
+    try {
+        return await runDemo(subcommand);
+    }
+    catch (error) {
+        logger.error('Error running demo:', error instanceof Error ? error.message : error);
+        return 1;
+    }
+}
+async function runDemo(scenarioName) {
+    // Demos get a cleaner UX: drop `[scope]` log prefixes.
+    (0, logger_1.setPrettyMode)(true);
+    const { executeSwarm } = await Promise.resolve().then(() => __importStar(require('./swarm-handlers')));
+    const demoMode = new demo_mode_1.DemoMode();
+    const scenario = demoMode.getScenario(scenarioName);
+    // Parse all CLI flags (including --target, --pr, --hooks, etc.)
+    const cliArgs = process.argv.slice(2);
+    const parsedFlags = (0, flags_1.parseSwarmFlags)(cliArgs);
+    const os = require('os');
+    let demoDir;
+    let isExternalTarget = false;
+    if (parsedFlags.targetDir) {
+        demoDir = path.resolve(parsedFlags.targetDir);
+        isExternalTarget = true;
+        if (!fs.existsSync(demoDir)) {
+            logger.error(`${c.bold('error:')} target directory does not exist: ${demoDir}`);
+            return 1;
+        }
+    }
+    else {
+        demoDir = fs.mkdtempSync(path.join(os.tmpdir(), `swarm-demo-${scenarioName}-`));
+        const { execSync } = require('child_process');
+        execSync('git init', { cwd: demoDir, stdio: 'pipe' });
+        execSync('git config user.email "demo@swarm.local"', { cwd: demoDir, stdio: 'pipe' });
+        execSync('git config user.name "Swarm Demo"', { cwd: demoDir, stdio: 'pipe' });
+        fs.writeFileSync(path.join(demoDir, 'README.md'), `# Swarm Demo: ${scenarioName}\n`);
+        execSync('git add . && git commit -m "init demo"', { cwd: demoDir, stdio: 'pipe' });
+    }
+    // Run the demo in the target directory; restore cwd when done
+    const originalDir = process.cwd();
+    process.chdir(demoDir);
+    try {
+        if (!scenario) {
+            logger.error(`${c.bold('error:')} demo scenario "${scenarioName}" not found`);
+            logger.info('');
+            logger.info('Available scenarios:');
+            demoMode.getAvailableScenarios().forEach(s => {
+                logger.info(`  ${c.cyan(s.name.padEnd(12))}  ${c.dim(s.description)}`);
+            });
+            logger.info('');
+            logger.info(`Run: ${c.bold('swarm demo list')}`);
+            return 1;
+        }
+        logger.info('');
+        logger.info(`  ${c.bold('swarm')} ${c.dim('·')} ${scenario.name}`);
+        logger.info(`  ${c.dim(scenario.description)}`);
+        logger.info('');
+        logger.info(`  steps     ${scenario.steps.length}`);
+        logger.info(`  duration  ${c.dim(scenario.expectedDuration)}`);
+        logger.info(`  folder    ${demoDir} ${c.dim(isExternalTarget ? '(target)' : '(temp)')}`);
+        logger.info('');
+        const plan = demoMode.scenarioToPlan(scenario);
+        const planPath = (0, plan_files_1.savePlanFile)(plan);
+        const execOpts = {
+            ...parsedFlags,
+            noQualityGates: true,
+        };
+        const exitCode = await executeSwarm(path.basename(planPath), execOpts);
+        await installDemoDependencies(demoDir);
+        return exitCode;
+    }
+    finally {
+        process.chdir(originalDir);
+    }
+}
+async function handleTemplatesCommand() {
+    const templatesDir = path.join(__dirname, '..', '..', 'templates');
+    const resolvedDir = fs.existsSync(templatesDir) ? templatesDir : path.join(__dirname, '..', '..', '..', 'templates');
+    if (!fs.existsSync(resolvedDir)) {
+        logger.error('Templates directory not found.');
+        return 1;
+    }
+    const files = fs.readdirSync(resolvedDir).filter((f) => f.endsWith('.json'));
+    logger.info('\n  Available Plan Templates\n');
+    logger.info('  ' + '-'.repeat(60));
+    for (const file of files) {
+        try {
+            const plan = JSON.parse(fs.readFileSync(path.join(resolvedDir, file), 'utf8'));
+            const steps = plan.steps?.length || 0;
+            const duration = plan.metadata?.estimatedDuration || 'unknown';
+            logger.info(`  ${file.padEnd(20)} ${String(steps).padStart(2)} steps   ${duration}`);
+        }
+        catch {
+            // Template file is malformed; show it in the listing with an error indicator
+            logger.info(`  ${file.padEnd(20)}  (invalid JSON)`);
+        }
+    }
+    logger.info('  ' + '-'.repeat(60));
+    logger.info(`\n  Usage: swarm swarm templates/<template>.json\n`);
+    return 0;
+}

package/dist/src/cli/flags.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOutputFormat = parseOutputFormat;
+exports.extractPositionalArgs = extractPositionalArgs;
+exports.normalizeLeadingGlobalFlags = normalizeLeadingGlobalFlags;
+exports.parseSwarmFlags = parseSwarmFlags;
+function parseOutputFormat(args) {
+    if (args.includes('--json'))
+        return 'json';
+    const outputIndex = args.indexOf('--output');
+    if (outputIndex !== -1 && args[outputIndex + 1] === 'json')
+        return 'json';
+    return 'text';
+}
+function extractPositionalArgs(args, options = {}) {
+    const booleanFlags = new Set(options.booleanFlags ?? []);
+    const valueFlags = new Set(options.valueFlags ?? []);
+    const positional = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (booleanFlags.has(arg))
+            continue;
+        if (valueFlags.has(arg)) {
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--'))
+            continue;
+        positional.push(arg);
+    }
+    return positional;
+}
+function normalizeLeadingGlobalFlags(args) {
+    const reorderedFlags = [];
+    let index = 0;
+    while (index < args.length) {
+        const arg = args[index];
+        if (arg === '--verbose' || arg === '--quiet' || arg === '-q' || arg === '--json' || arg === '--help' || arg === '-h') {
+            reorderedFlags.push(arg);
+            index += 1;
+            continue;
+        }
+        if (arg === '--output') {
+            reorderedFlags.push(arg);
+            if (args[index + 1]) {
+                reorderedFlags.push(args[index + 1]);
+                index += 2;
+            }
+            else {
+                index += 1;
+            }
+            continue;
+        }
+        break;
+    }
+    if (reorderedFlags.length === 0) {
+        return args;
+    }
+    if (index >= args.length) {
+        if (reorderedFlags.includes('--help') || reorderedFlags.includes('-h')) {
+            const trailingFlags = reorderedFlags.filter((flag) => flag !== '--help' && flag !== '-h');
+            return ['--help', ...trailingFlags];
+        }
+        return args;
+    }
+    return [args[index], ...reorderedFlags, ...args.slice(index + 1)];
+}
+function parseSwarmFlags(args) {
+    const opts = {};
+    if (parseOutputFormat(args) === 'json') {
+        opts.outputFormat = 'json';
+    }
+    const modelIndex = args.indexOf('--model');
+    if (modelIndex !== -1 && args[modelIndex + 1])
+        opts.model = args[modelIndex + 1];
+    if (args.includes('--confirm-deploy'))
+        opts.confirmDeploy = true;
+    if (args.includes('--no-quality-gates'))
+        opts.noQualityGates = true;
+    if (args.includes('--pm'))
+        opts.pm = true;
+    if (args.includes('--strict-isolation'))
+        opts.strictIsolation = true;
+    if (args.includes('--lean'))
+        opts.lean = true;
+    if (args.includes('--verbose'))
+        opts.verbose = true;
+    if (args.includes('--useInnerFleet') || args.includes('--wrap-fleet'))
+        opts.useInnerFleet = true;
+    if (args.includes('--cost-estimate-only'))
+        opts.costEstimateOnly = true;
+    if (args.includes('--yes') || args.includes('-y'))
+        opts.yes = true;
+    if (args.includes('--quiet') || args.includes('-q'))
+        opts.quiet = true;
+    if (args.includes('--stream-agent'))
+        opts.streamAgent = true;
+    if (args.includes('--no-hooks')) {
+        opts.hooksEnabled = false;
+    }
+    else if (args.includes('--hooks')) {
+        opts.hooksEnabled = true;
+    }
+    const maxPremIdx = args.indexOf('--max-premium-requests');
+    if (maxPremIdx !== -1 && args[maxPremIdx + 1]) {
+        const parsed = parseInt(args[maxPremIdx + 1], 10);
+        if (isNaN(parsed) || parsed < 0) {
+            throw new Error(`--max-premium-requests requires a non-negative integer, got "${args[maxPremIdx + 1]}"`);
+        }
+        opts.maxPremiumRequests = parsed;
+    }
+    const maxRetriesIdx = args.indexOf('--max-retries');
+    if (maxRetriesIdx !== -1 && args[maxRetriesIdx + 1]) {
+        const parsed = parseInt(args[maxRetriesIdx + 1], 10);
+        if (isNaN(parsed) || parsed < 0) {
+            throw new Error(`--max-retries requires a non-negative integer, got "${args[maxRetriesIdx + 1]}"`);
+        }
+        opts.maxRetries = parsed;
+    }
+    const resumeIndex = args.indexOf('--resume');
+    if (resumeIndex !== -1 && args[resumeIndex + 1])
+        opts.session = args[resumeIndex + 1];
+    const qgConfigIndex = args.indexOf('--quality-gates-config');
+    if (qgConfigIndex !== -1 && args[qgConfigIndex + 1]) {
+        opts.qualityGatesConfigPath = args[qgConfigIndex + 1];
+    }
+    const qgOutIndex = args.indexOf('--quality-gates-out');
+    if (qgOutIndex !== -1 && args[qgOutIndex + 1]) {
+        opts.qualityGatesOutDir = args[qgOutIndex + 1];
+    }
+    const prIndex = args.indexOf('--pr');
+    if (prIndex !== -1 && args[prIndex + 1]) {
+        const mode = args[prIndex + 1];
+        if (mode !== 'auto' && mode !== 'review') {
+            throw new Error(`--pr requires "auto" or "review", got "${mode}"`);
+        }
+        opts.prMode = mode;
+    }
+    const targetIndex = args.indexOf('--target') !== -1
+        ? args.indexOf('--target')
+        : args.indexOf('--dir');
+    if (targetIndex !== -1 && args[targetIndex + 1]) {
+        opts.targetDir = args[targetIndex + 1];
+    }
+    if (args.includes('--owasp-report'))
+        opts.owaspReport = true;
+    const toolIndex = args.indexOf('--tool');
+    if (toolIndex !== -1 && args[toolIndex + 1]) {
+        opts.cliAgent = args[toolIndex + 1];
+    }
+    return opts;
+}

package/dist/src/cli/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * CLI command handlers – barrel re-export module.
+ *
+ * The actual handler implementations live in focused sub-modules under src/cli/.
+ * This file re-exports every public symbol so that existing consumers
+ * (cli.ts, tests, etc.) continue to work unchanged.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSwarmFlags = exports.showUsage = exports.handleAttestCommand = exports.handleAgentsCommand = exports.handleRecipeInfoCommand = exports.handleRecipesCommand = exports.handleUseCommand = exports.handleShareCommand = exports.handleTemplatesCommand = exports.runDemo = exports.handleDemoCommand = exports.installDemoDependencies = exports.handleReportCommand = exports.handleMetricsCommand = exports.handleAuditCommand = exports.handleGatesCommand = exports.handleStatusCommand = exports.showStatus = exports.handleRunCommand = exports.handleQuickCommand = exports.handleSwarmCommand = exports.handleBootstrapCommand = exports.writeCIOutputs = exports.executeSwarm = exports.validateAdapterSecrets = exports.handleExecuteCommand = exports.handlePlanCommand = exports.executePlan = exports.importPlanFromTranscript = exports.generatePlan = void 0;
+// ── Plan handlers ──────────────────────────────────────────────────────────
+var plan_handlers_1 = require("./plan-handlers");
+Object.defineProperty(exports, "generatePlan", { enumerable: true, get: function () { return plan_handlers_1.generatePlan; } });
+Object.defineProperty(exports, "importPlanFromTranscript", { enumerable: true, get: function () { return plan_handlers_1.importPlanFromTranscript; } });
+Object.defineProperty(exports, "executePlan", { enumerable: true, get: function () { return plan_handlers_1.executePlan; } });
+Object.defineProperty(exports, "handlePlanCommand", { enumerable: true, get: function () { return plan_handlers_1.handlePlanCommand; } });
+Object.defineProperty(exports, "handleExecuteCommand", { enumerable: true, get: function () { return plan_handlers_1.handleExecuteCommand; } });
+// ── Swarm / execution handlers ────────────────────────────────────────────
+var swarm_handlers_1 = require("./swarm-handlers");
+Object.defineProperty(exports, "validateAdapterSecrets", { enumerable: true, get: function () { return swarm_handlers_1.validateAdapterSecrets; } });
+Object.defineProperty(exports, "executeSwarm", { enumerable: true, get: function () { return swarm_handlers_1.executeSwarm; } });
+Object.defineProperty(exports, "writeCIOutputs", { enumerable: true, get: function () { return swarm_handlers_1.writeCIOutputs; } });
+Object.defineProperty(exports, "handleBootstrapCommand", { enumerable: true, get: function () { return swarm_handlers_1.handleBootstrapCommand; } });
+Object.defineProperty(exports, "handleSwarmCommand", { enumerable: true, get: function () { return swarm_handlers_1.handleSwarmCommand; } });
+Object.defineProperty(exports, "handleQuickCommand", { enumerable: true, get: function () { return swarm_handlers_1.handleQuickCommand; } });
+Object.defineProperty(exports, "handleRunCommand", { enumerable: true, get: function () { return swarm_handlers_1.handleRunCommand; } });
+// ── Status / reporting handlers ───────────────────────────────────────────
+var status_handlers_1 = require("./status-handlers");
+Object.defineProperty(exports, "showStatus", { enumerable: true, get: function () { return status_handlers_1.showStatus; } });
+Object.defineProperty(exports, "handleStatusCommand", { enumerable: true, get: function () { return status_handlers_1.handleStatusCommand; } });
+Object.defineProperty(exports, "handleGatesCommand", { enumerable: true, get: function () { return status_handlers_1.handleGatesCommand; } });
+Object.defineProperty(exports, "handleAuditCommand", { enumerable: true, get: function () { return status_handlers_1.handleAuditCommand; } });
+Object.defineProperty(exports, "handleMetricsCommand", { enumerable: true, get: function () { return status_handlers_1.handleMetricsCommand; } });
+Object.defineProperty(exports, "handleReportCommand", { enumerable: true, get: function () { return status_handlers_1.handleReportCommand; } });
+// ── Demo / template handlers ─────────────────────────────────────────────
+var demo_handlers_1 = require("./demo-handlers");
+Object.defineProperty(exports, "installDemoDependencies", { enumerable: true, get: function () { return demo_handlers_1.installDemoDependencies; } });
+Object.defineProperty(exports, "handleDemoCommand", { enumerable: true, get: function () { return demo_handlers_1.handleDemoCommand; } });
+Object.defineProperty(exports, "runDemo", { enumerable: true, get: function () { return demo_handlers_1.runDemo; } });
+Object.defineProperty(exports, "handleTemplatesCommand", { enumerable: true, get: function () { return demo_handlers_1.handleTemplatesCommand; } });
+// ── Share handlers ───────────────────────────────────────────────────────
+var share_handlers_1 = require("./share-handlers");
+Object.defineProperty(exports, "handleShareCommand", { enumerable: true, get: function () { return share_handlers_1.handleShareCommand; } });
+// ── Misc handlers (recipes, agents, use) ─────────────────────────────────
+var misc_handlers_1 = require("./misc-handlers");
+Object.defineProperty(exports, "handleUseCommand", { enumerable: true, get: function () { return misc_handlers_1.handleUseCommand; } });
+Object.defineProperty(exports, "handleRecipesCommand", { enumerable: true, get: function () { return misc_handlers_1.handleRecipesCommand; } });
+Object.defineProperty(exports, "handleRecipeInfoCommand", { enumerable: true, get: function () { return misc_handlers_1.handleRecipeInfoCommand; } });
+Object.defineProperty(exports, "handleAgentsCommand", { enumerable: true, get: function () { return misc_handlers_1.handleAgentsCommand; } });
+// ── Attestation handlers ─────────────────────────────────────────────────
+var attest_handlers_1 = require("./attest-handlers");
+Object.defineProperty(exports, "handleAttestCommand", { enumerable: true, get: function () { return attest_handlers_1.handleAttestCommand; } });
+// ── Already-split modules (re-export for convenience) ────────────────────
+var usage_1 = require("./usage");
+Object.defineProperty(exports, "showUsage", { enumerable: true, get: function () { return usage_1.showUsage; } });
+var flags_1 = require("./flags");
+Object.defineProperty(exports, "parseSwarmFlags", { enumerable: true, get: function () { return flags_1.parseSwarmFlags; } });

package/dist/src/cli/live-status.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Live status block: a fixed-position region pinned to the bottom of stdout
+ * that re-renders in place via ANSI cursor moves. Running steps each occupy
+ * one line (spinner, label, elapsed, current action). Static output (agent
+ * stream lines, completed-step summaries, banners) prints above the block;
+ * the block redraws after each insertion so it stays at the bottom.
+ *
+ * Non-TTY fallback: append a single line on each state transition. Pipes,
+ * CI logs, and NO_COLOR/CI envs degrade gracefully without ANSI escapes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveStatus = void 0;
+exports.getLiveStatus = getLiveStatus;
+exports._setLiveStatusForTest = _setLiveStatusForTest;
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const RENDER_INTERVAL_MS = 100;
+const ESC = '\x1b[';
+const HIDE_CURSOR = `${ESC}?25l`;
+const SHOW_CURSOR = `${ESC}?25h`;
+const CLEAR_LINE = `${ESC}2K`;
+const CURSOR_UP_ONE = `${ESC}1A`;
+class LiveStatus {
+    out;
+    tty;
+    color;
+    steps = new Map();
+    order = [];
+    renderedLines = 0;
+    spinnerFrame = 0;
+    renderTimer;
+    active = false;
+    constructor(opts = {}) {
+        this.out = opts.out ?? process.stdout;
+        const detectedTty = Boolean(this.out.isTTY) && !process.env.CI;
+        this.tty = opts.tty ?? detectedTty;
+        this.color = opts.color ?? (this.tty && !process.env.NO_COLOR);
+    }
+    start() {
+        if (this.active)
+            return;
+        this.active = true;
+        if (this.tty) {
+            this.out.write(HIDE_CURSOR);
+            this.renderTimer = setInterval(() => this.render(), RENDER_INTERVAL_MS);
+            this.renderTimer.unref?.();
+        }
+    }
+    stop() {
+        if (!this.active)
+            return;
+        this.active = false;
+        if (this.renderTimer) {
+            clearInterval(this.renderTimer);
+            this.renderTimer = undefined;
+        }
+        if (this.tty) {
+            this.clearLiveBlock();
+            this.out.write(SHOW_CURSOR);
+        }
+    }
+    addStep(id, label) {
+        if (!this.steps.has(id)) {
+            this.order.push(id);
+        }
+        this.steps.set(id, { id, label, startedAt: Date.now() });
+        if (!this.tty) {
+            this.out.write(`  ${this.dim('›')} ${label} ${this.dim('started')}\n`);
+        }
+        else {
+            this.render();
+        }
+    }
+    setAction(id, action) {
+        const step = this.steps.get(id);
+        if (!step)
+            return;
+        step.currentAction = action;
+    }
+    finishStep(id, state, summary) {
+        const step = this.steps.get(id);
+        if (!step)
+            return;
+        const elapsed = elapsedSeconds(step.startedAt);
+        const glyph = state === 'done' ? this.green('✓') : this.red('✗');
+        const tail = summary ? ` ${this.dim('·')} ${summary}` : '';
+        const line = `  ${glyph} ${step.label} ${this.dim(formatDuration(elapsed))}${tail}`;
+        this.printAbove(line);
+        this.steps.delete(id);
+        const idx = this.order.indexOf(id);
+        if (idx >= 0)
+            this.order.splice(idx, 1);
+    }
+    /** Print a line as static output above the live block. */
+    print(line) {
+        this.printAbove(line);
+    }
+    /** True when running in a real TTY where cursor moves work. */
+    isTTY() {
+        return this.tty;
+    }
+    printAbove(line) {
+        if (!this.tty) {
+            this.out.write(line + '\n');
+            return;
+        }
+        this.clearLiveBlock();
+        this.out.write(line + '\n');
+        this.render();
+    }
+    clearLiveBlock() {
+        if (this.renderedLines === 0)
+            return;
+        let buf = '';
+        for (let i = 0; i < this.renderedLines; i++) {
+            buf += CURSOR_UP_ONE + CLEAR_LINE;
+        }
+        this.out.write(buf);
+        this.renderedLines = 0;
+    }
+    render() {
+        if (!this.tty)
+            return;
+        this.clearLiveBlock();
+        const frame = SPINNER[this.spinnerFrame % SPINNER.length];
+        this.spinnerFrame++;
+        const lines = [];
+        for (const id of this.order) {
+            const step = this.steps.get(id);
+            if (!step)
+                continue;
+            const elapsed = elapsedSeconds(step.startedAt);
+            const action = step.currentAction
+                ? ` ${this.dim('·')} ${this.dim(truncate(step.currentAction, 56))}`
+                : '';
+            lines.push(`  ${this.cyan(frame)} ${step.label} ${this.dim(formatDuration(elapsed))}${action}`);
+        }
+        if (lines.length === 0)
+            return;
+        this.out.write(lines.join('\n') + '\n');
+        this.renderedLines = lines.length;
+    }
+    cyan(s) {
+        return this.color ? `${ESC}36m${s}${ESC}39m` : s;
+    }
+    green(s) {
+        return this.color ? `${ESC}32m${s}${ESC}39m` : s;
+    }
+    red(s) {
+        return this.color ? `${ESC}31m${s}${ESC}39m` : s;
+    }
+    dim(s) {
+        return this.color ? `${ESC}2m${s}${ESC}22m` : s;
+    }
+}
+exports.LiveStatus = LiveStatus;
+function elapsedSeconds(startedAt) {
+    return Math.max(0, Math.round((Date.now() - startedAt) / 1000));
+}
+function formatDuration(secs) {
+    if (secs < 60)
+        return `${secs}s`;
+    const m = Math.floor(secs / 60);
+    const s = secs % 60;
+    return s === 0 ? `${m}m` : `${m}m${s}s`;
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + '…';
+}
+let singleton;
+/**
+ * Returns the process-wide LiveStatus instance, creating one on first call.
+ * The instance is inert until start() is invoked, so importing this getter
+ * from code paths that never run a swarm has no side effect.
+ */
+function getLiveStatus() {
+    if (!singleton)
+        singleton = new LiveStatus();
+    return singleton;
+}
+/** Test hook: replace the singleton with an instance configured for capture. */
+function _setLiveStatusForTest(instance) {
+    singleton = instance;
+}