swarm-orchestrator 7.0.0-alpha.0

package/dist/src/adapters/index.js

@@ -0,0 +1,44 @@
+"use strict";
+// Resolves adapter name to concrete AgentAdapter instance.
+// Central registry; add new adapters here.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRestrictedEnv = void 0;
+exports.defaultModelForAdapter = defaultModelForAdapter;
+exports.resolveAdapter = resolveAdapter;
+const copilot_adapter_1 = require("./copilot-adapter");
+const claude_code_adapter_1 = require("./claude-code-adapter");
+const codex_adapter_1 = require("./codex-adapter");
+const claude_code_teams_1 = require("./claude-code-teams");
+var agent_adapter_1 = require("./agent-adapter");
+Object.defineProperty(exports, "buildRestrictedEnv", { enumerable: true, get: function () { return agent_adapter_1.buildRestrictedEnv; } });
+const ADAPTER_REGISTRY = {
+    'copilot': () => new copilot_adapter_1.CopilotAdapter(),
+    'claude-code': () => new claude_code_adapter_1.ClaudeCodeAdapter(),
+    'codex': () => new codex_adapter_1.CodexAdapter(),
+    'claude-code-teams': () => new claude_code_teams_1.ClaudeCodeTeamsAdapter(),
+};
+// Each adapter's underlying tool has a different default model.
+// Used for cost estimation and reporting when the user hasn't specified --model.
+const DEFAULT_MODELS = {
+    'copilot': 'claude-sonnet-4',
+    'claude-code': 'claude-sonnet-4',
+    'codex': 'gpt-5.4',
+    'claude-code-teams': 'claude-opus-4',
+};
+const AVAILABLE_NAMES = Object.keys(ADAPTER_REGISTRY);
+/**
+ * Returns the default model name for a given adapter.
+ * Falls back to the adapter's known default rather than assuming claude-sonnet-4.
+ */
+function defaultModelForAdapter(adapterName) {
+    if (!adapterName)
+        return DEFAULT_MODELS['copilot'];
+    return DEFAULT_MODELS[adapterName] ?? DEFAULT_MODELS['copilot'];
+}
+function resolveAdapter(name) {
+    const factory = ADAPTER_REGISTRY[name];
+    if (!factory) {
+        throw new Error(`Unknown agent adapter "${name}". Available adapters: ${AVAILABLE_NAMES.join(', ')}`);
+    }
+    return factory();
+}

package/dist/src/adapters/persistent-session.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentInteractiveSession = void 0;
+const child_process_1 = require("child_process");
+const DEFAULT_END_TOKEN_PREFIX = 'SWARM_TURN_DONE';
+const DEFAULT_TURN_TIMEOUT_MS = 600_000;
+/**
+ * Keeps one CLI process alive and feeds prompts over stdin.
+ *
+ * The child must echo the requested end token on stdout when a turn is done.
+ * If it exits, stalls, or never emits the marker, callers can fall back to the
+ * adapter's regular cold-start path.
+ */
+class PersistentInteractiveSession {
+    config;
+    proc;
+    pending;
+    stdoutBuffer = '';
+    stderrBuffer = '';
+    unavailableReason;
+    turnCounter = 0;
+    endTokenPrefix;
+    constructor(config) {
+        this.config = config;
+        this.endTokenPrefix = config.endTokenPrefix ?? DEFAULT_END_TOKEN_PREFIX;
+    }
+    get unavailable() {
+        return this.unavailableReason !== undefined;
+    }
+    get reason() {
+        return this.unavailableReason;
+    }
+    async send(prompt, timeoutMs = DEFAULT_TURN_TIMEOUT_MS) {
+        if (this.unavailableReason) {
+            return this.failedResult(this.unavailableReason, 0);
+        }
+        if (this.pending) {
+            return this.failedResult('persistent session already has an active turn', 0);
+        }
+        const startedAt = Date.now();
+        const proc = this.ensureStarted();
+        if (!proc || this.unavailableReason) {
+            return this.failedResult(this.unavailableReason ?? 'persistent session failed to start', Date.now() - startedAt);
+        }
+        const token = `${this.endTokenPrefix}:${Date.now()}:${++this.turnCounter}`;
+        const framedPrompt = [
+            prompt,
+            '',
+            'When this turn is fully complete, print this exact marker on its own line:',
+            token,
+            '',
+        ].join('\n');
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                const pending = this.pending;
+                if (!pending || pending.token !== token)
+                    return;
+                this.pending = undefined;
+                this.markUnavailable(`persistent turn timed out waiting for ${token}`);
+                resolve({
+                    stdout: pending.stdout,
+                    stderr: appendLine(pending.stderr, `Timed out waiting for end-of-turn marker ${token}`),
+                    exitCode: 1,
+                    durationMs: Date.now() - pending.startedAt,
+                });
+            }, timeoutMs);
+            this.pending = {
+                token,
+                startedAt,
+                stdout: '',
+                stderr: '',
+                resolve,
+                timeout,
+            };
+            try {
+                if (!proc.stdin)
+                    throw new Error('persistent process stdin is unavailable');
+                proc.stdin.write(framedPrompt);
+                proc.stdin.write('\n');
+            }
+            catch (err) {
+                clearTimeout(timeout);
+                this.pending = undefined;
+                this.markUnavailable(err instanceof Error ? err.message : String(err));
+                resolve(this.failedResult(this.unavailableReason ?? 'stdin write failed', Date.now() - startedAt));
+            }
+        });
+    }
+    async shutdown() {
+        if (!this.proc)
+            return;
+        const proc = this.proc;
+        this.proc = undefined;
+        try {
+            proc.stdin?.end();
+        }
+        catch {
+            // Process may already be closed.
+        }
+        try {
+            proc.kill('SIGTERM');
+        }
+        catch {
+            // Process may already be closed.
+        }
+    }
+    ensureStarted() {
+        if (this.proc && !this.proc.killed)
+            return this.proc;
+        const spawnOpts = {
+            cwd: this.config.cwd,
+            env: {
+                ...process.env,
+                ...this.config.env,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        };
+        let proc;
+        try {
+            proc = (0, child_process_1.spawn)(this.config.command, this.config.args, spawnOpts);
+            this.proc = proc;
+        }
+        catch (err) {
+            this.markUnavailable(err instanceof Error ? err.message : String(err));
+            return undefined;
+        }
+        proc.stdout?.on('data', (data) => {
+            this.handleOutput(data.toString(), 'stdout');
+        });
+        proc.stderr?.on('data', (data) => {
+            this.handleOutput(data.toString(), 'stderr');
+        });
+        proc.on('close', (code) => {
+            this.markUnavailable(`persistent process exited with code ${code ?? 1}`);
+        });
+        proc.on('error', (err) => {
+            this.markUnavailable(err.message);
+        });
+        return proc;
+    }
+    handleOutput(text, stream) {
+        const pending = this.pending;
+        if (pending) {
+            if (stream === 'stdout')
+                pending.stdout += text;
+            else
+                pending.stderr += text;
+        }
+        const buffer = stream === 'stdout'
+            ? this.stdoutBuffer + text
+            : this.stderrBuffer + text;
+        const lines = buffer.split('\n');
+        const remaining = lines.pop() ?? '';
+        if (stream === 'stdout')
+            this.stdoutBuffer = remaining;
+        else
+            this.stderrBuffer = remaining;
+        for (const line of lines) {
+            this.config.onLine?.(line, stream);
+            this.maybeFinishTurn(line);
+        }
+    }
+    maybeFinishTurn(line) {
+        const pending = this.pending;
+        if (!pending || !line.includes(pending.token))
+            return;
+        clearTimeout(pending.timeout);
+        this.pending = undefined;
+        const stdout = pending.stdout.replace(pending.token, '').trimEnd();
+        pending.resolve({
+            stdout,
+            stderr: pending.stderr,
+            exitCode: 0,
+            durationMs: Date.now() - pending.startedAt,
+        });
+    }
+    markUnavailable(reason) {
+        this.unavailableReason = reason;
+        if (this.pending) {
+            const pending = this.pending;
+            clearTimeout(pending.timeout);
+            this.pending = undefined;
+            pending.resolve({
+                stdout: pending.stdout,
+                stderr: appendLine(pending.stderr, reason),
+                exitCode: 1,
+                durationMs: Date.now() - pending.startedAt,
+            });
+        }
+        try {
+            this.proc?.kill('SIGTERM');
+        }
+        catch {
+            // Already gone.
+        }
+    }
+    failedResult(reason, durationMs) {
+        return { stdout: '', stderr: reason, exitCode: 1, durationMs };
+    }
+}
+exports.PersistentInteractiveSession = PersistentInteractiveSession;
+function appendLine(base, line) {
+    return base ? `${base}\n${line}` : line;
+}

package/dist/src/adapters/process-supervisor.js

@@ -0,0 +1,199 @@
+"use strict";
+// Shared subprocess lifecycle management: stall detection, heartbeat,
+// graceful shutdown. Extracted from SessionExecutor.runCommand() so that
+// all adapters (copilot, claude-code, claude-code-teams) get identical
+// reliability guarantees.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supervisedSpawn = supervisedSpawn;
+const child_process_1 = require("child_process");
+const defaults_1 = require("../defaults");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)('process-supervisor');
+// Maximum silence before killing a stalled subprocess.
+// Agent CLIs can go quiet during extended tool-use or thinking phases,
+// so this needs headroom beyond typical inference latency.
+const DEFAULT_STALL_TIMEOUT_MS = defaults_1.DEFAULT_COMMAND_TIMEOUT_MS * 2 + 60_000; // 5 minutes
+// How often to check for stalls (ms)
+const STALL_CHECK_INTERVAL_MS = defaults_1.DEFAULT_HEARTBEAT_INTERVAL_MS * 2;
+// Grace period after SIGTERM before escalating to SIGKILL (ms)
+const KILL_GRACE_MS = defaults_1.DEFAULT_SIGKILL_DELAY_MS;
+// Only show heartbeat during quiet periods longer than this (ms)
+const HEARTBEAT_QUIET_THRESHOLD_MS = defaults_1.DEFAULT_HEARTBEAT_INTERVAL_MS * 3;
+// Heartbeat display interval (ms)
+const HEARTBEAT_INTERVAL_MS = defaults_1.DEFAULT_HEARTBEAT_INTERVAL_MS * 3;
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Spawn a child process with stall detection, heartbeat logging, and
+ * line-buffered output. Returns a promise that resolves when the process
+ * exits or is killed due to inactivity.
+ */
+function supervisedSpawn(opts) {
+    const stallTimeoutMs = opts.stallTimeoutMs ?? DEFAULT_STALL_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        const stdinMode = opts.stdinMode ?? 'pipe';
+        // process.env is merged in first so callers that pass partial env overrides
+        // (e.g. buildRestrictedEnv) still inherit PATH, locale, keyring vars, and
+        // OAuth state the agent CLI needs at runtime. opts.env is spread last so
+        // explicit values, including `undefined` to scrub a key, win over the
+        // inherited base.
+        const spawnOpts = {
+            cwd: opts.cwd,
+            env: {
+                ...process.env,
+                ...opts.env,
+            },
+            stdio: [stdinMode, 'pipe', 'pipe'],
+        };
+        const proc = (0, child_process_1.spawn)(opts.command, opts.args, spawnOpts);
+        // Close piped stdin so the subprocess never blocks waiting for interactive input.
+        // When stdinMode is 'ignore' there is no proc.stdin to end.
+        if (proc.stdin) {
+            if (opts.stdinData) {
+                proc.stdin.write(opts.stdinData);
+            }
+            proc.stdin.end();
+        }
+        let stdout = '';
+        let stderr = '';
+        let resolved = false;
+        let killed = false;
+        // Line buffers prevent mid-word breaks in streamed output
+        let stdoutBuffer = '';
+        let stderrBuffer = '';
+        let lineCount = 0;
+        let lastOutputTime = Date.now();
+        const startTime = Date.now();
+        let heartbeatInterval = null;
+        let stallCheckInterval = null;
+        let heartbeatCount = 0;
+        const cleanup = () => {
+            if (heartbeatInterval)
+                clearInterval(heartbeatInterval);
+            if (stallCheckInterval)
+                clearInterval(stallCheckInterval);
+        };
+        const finish = (result) => {
+            if (resolved)
+                return;
+            resolved = true;
+            cleanup();
+            resolve(result);
+        };
+        // Stall detection: kill subprocess if no output for stallTimeoutMs
+        stallCheckInterval = setInterval(() => {
+            const silentMs = Date.now() - lastOutputTime;
+            if (silentMs >= stallTimeoutMs) {
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                const stallSec = Math.round(silentMs / 1000);
+                if (opts.logPrefix) {
+                    logger.info(`${opts.logPrefix} ⚠ STALL DETECTED: no output for ${stallSec}s ` +
+                        `(total ${elapsed}s, ${lineCount} lines). Killing process.`);
+                }
+                killed = true;
+                killGracefully(proc);
+                finish({
+                    stdout,
+                    stderr: stderr + `\nProcess killed after ${stallSec}s of no output (stall timeout)`,
+                    exitCode: 1
+                });
+            }
+        }, STALL_CHECK_INTERVAL_MS);
+        // Heartbeat: show progress during quiet periods
+        if (opts.logPrefix) {
+            heartbeatInterval = setInterval(() => {
+                const silentMs = Date.now() - lastOutputTime;
+                if (silentMs < HEARTBEAT_QUIET_THRESHOLD_MS)
+                    return;
+                const elapsed = Math.round((Date.now() - startTime) / 1000);
+                const frame = SPINNER_FRAMES[heartbeatCount % SPINNER_FRAMES.length];
+                heartbeatCount++;
+                const mins = Math.floor(elapsed / 60);
+                const secs = elapsed % 60;
+                const timeStr = mins > 0 ? `${mins}m${secs}s` : `${secs}s`;
+                logger.info(`${opts.logPrefix} ${frame} ${timeStr} elapsed | ${lineCount} lines`);
+            }, HEARTBEAT_INTERVAL_MS);
+        }
+        const processLines = (buffer, newData, stream) => {
+            buffer += newData;
+            const lines = buffer.split('\n');
+            // Keep last (possibly incomplete) line in buffer
+            const remaining = lines.pop() || '';
+            for (const line of lines) {
+                if (line.trim()) {
+                    lineCount++;
+                    if (opts.onLine)
+                        opts.onLine(line, stream);
+                    if (opts.logPrefix && !killed) {
+                        if (stream === 'stderr') {
+                            logger.error(`${opts.logPrefix} ${line}`);
+                        }
+                        else {
+                            logger.info(`${opts.logPrefix} ${line}`);
+                        }
+                    }
+                }
+            }
+            return remaining;
+        };
+        if (proc.stdout) {
+            proc.stdout.on('data', (data) => {
+                const text = data.toString();
+                stdout += text;
+                lastOutputTime = Date.now();
+                stdoutBuffer = processLines(stdoutBuffer, text, 'stdout');
+            });
+        }
+        if (proc.stderr) {
+            proc.stderr.on('data', (data) => {
+                const text = data.toString();
+                stderr += text;
+                lastOutputTime = Date.now();
+                stderrBuffer = processLines(stderrBuffer, text, 'stderr');
+            });
+        }
+        proc.on('close', (code) => {
+            // Flush remaining buffered content
+            if (opts.logPrefix && !killed) {
+                if (stdoutBuffer.trim()) {
+                    lineCount++;
+                    logger.info(`${opts.logPrefix} ${stdoutBuffer}`);
+                }
+                if (stderrBuffer.trim()) {
+                    lineCount++;
+                    logger.error(`${opts.logPrefix} ${stderrBuffer}`);
+                }
+            }
+            finish({ stdout, stderr, exitCode: code ?? 0 });
+        });
+        proc.on('error', (err) => {
+            // Flush buffers on error too
+            if (opts.logPrefix && !killed) {
+                if (stdoutBuffer.trim()) {
+                    logger.info(`${opts.logPrefix} ${stdoutBuffer}`);
+                }
+                if (stderrBuffer.trim()) {
+                    logger.error(`${opts.logPrefix} ${stderrBuffer}`);
+                }
+            }
+            finish({
+                stdout,
+                stderr: stderr + '\n' + err.message,
+                exitCode: 1
+            });
+        });
+    });
+}
+// SIGTERM first, then SIGKILL after a grace period if the process
+// hasn't exited. Matches the shutdown behavior from SessionExecutor.
+function killGracefully(proc) {
+    try {
+        proc.kill('SIGTERM');
+    }
+    catch { /* already dead */ }
+    setTimeout(() => {
+        try {
+            proc.kill('SIGKILL');
+        }
+        catch { /* already dead */ }
+    }, KILL_GRACE_MS);
+}