specrails-hub 1.1.0 → 1.1.1

package/README.md

@@ -1,6 +1,6 @@
 # specrails hub
 
-A local dashboard and CLI for managing all your [specrails](https://github.com/fjpulidop/specrails) projects from a single interface. Visualizes the AI pipeline phases (Architect, Developer, Reviewer, Ship), streams logs in real-time, and lets you launch commands from the browser or terminal.
+A local dashboard and CLI for managing all your [specrails-core](https://github.com/fjpulidop/specrails-core) projects from a single interface. Visualizes the AI pipeline phases (Architect, Developer, Reviewer, Ship), streams logs in real-time, and lets you launch commands from the browser or terminal.
 
 ## Features
 
@@ -16,12 +16,12 @@ A local dashboard and CLI for managing all your [specrails](https://github.com/f
 
 - Node.js 18+
 - `claude` CLI on your PATH ([Claude Code](https://claude.com/claude-code))
-- At least one project with specrails installed (`npx specrails`)
+- At least one project with specrails-core installed (`npx specrails-core`)
 
 ## Installation
 
 ```bash
-npm install -g @specrails/hub
+npm install -g specrails-hub
 ```
 
 ## Quick Start

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "specrails-hub",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "bin": {
-    "specrails-hub": "./cli/dist/specrails-hub.js"
+    "specrails-hub": "cli/dist/specrails-hub.js"
   },
   "files": [
     "cli/dist",

package/cli/dist/hub.js

@@ -1,910 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * specrails-hub — specrails CLI bridge
- *
- * Routes commands to the manager when running, or falls back to invoking
- * claude directly when the manager is not reachable.
- *
- * Usage:
- *   specrails-hub implement #42           → /sr:implement #42 (via manager or direct)
- *   specrails-hub "any raw prompt"        → raw prompt (no /sr: prefix)
- *   specrails-hub --status                → print manager state
- *   specrails-hub --jobs                  → print job history table
- *   specrails-hub --port 5000 <command>   → use port 5000 instead of 4200
- *   specrails-hub --help                  → print usage and exit 0
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArgs = parseArgs;
-exports.detectWebManager = detectWebManager;
-exports.formatDuration = formatDuration;
-exports.formatTokens = formatTokens;
-exports.printSummary = printSummary;
-const http_1 = __importDefault(require("http"));
-const child_process_1 = require("child_process");
-const child_process_2 = require("child_process");
-const readline_1 = require("readline");
-const ws_1 = __importDefault(require("ws"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const fs_1 = __importDefault(require("fs"));
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const DEFAULT_PORT = 4200;
-const DETECTION_TIMEOUT_MS = 500;
-const KNOWN_VERBS = new Set([
-    'implement',
-    'batch-implement',
-    'why',
-    'product-backlog',
-    'update-product-driven-backlog',
-    'refactor-recommender',
-    'health-check',
-    'compat-check',
-]);
-const EXIT_PATTERN = /\[process exited with code (\d+)/;
-// ---------------------------------------------------------------------------
-// ANSI helpers
-// ---------------------------------------------------------------------------
-const isTTY = process.stdout.isTTY === true;
-function ansi(code, text) {
-    if (!isTTY)
-        return text;
-    return `\x1b[${code}m${text}\x1b[0m`;
-}
-const dim = (t) => ansi('2', t);
-const red = (t) => ansi('31', t);
-const bold = (t) => ansi('1', t);
-const dimCyan = (t) => ansi('2;36', t);
-function hubPrefix() {
-    return dim('[specrails-hub]');
-}
-function hubLog(msg) {
-    process.stdout.write(`${hubPrefix()} ${msg}\n`);
-}
-function hubError(msg) {
-    process.stderr.write(`${hubPrefix()} ${red(`error: ${msg}`)}\n`);
-}
-function hubWarn(msg) {
-    process.stderr.write(`${hubPrefix()} ${dim(`warning: ${msg}`)}\n`);
-}
-const HUB_SUBCOMMANDS = new Set(['start', 'stop', 'status', 'add', 'remove', 'list']);
-function parseArgs(argv) {
-    // argv is process.argv.slice(2)
-    let port = DEFAULT_PORT;
-    const args = [...argv];
-    // Extract --port <n> from any position
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--port' && i + 1 < args.length) {
-            const parsed = parseInt(args[i + 1], 10);
-            if (!isNaN(parsed)) {
-                port = parsed;
-            }
-            args.splice(i, 2);
-            i--;
-        }
-    }
-    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-        return { mode: 'help' };
-    }
-    if (args[0] === '--status') {
-        return { mode: 'status', port };
-    }
-    if (args[0] === '--jobs') {
-        return { mode: 'jobs', port };
-    }
-    // Hub subcommands — top-level (no `hub` prefix needed)
-    // backward compat: `specrails-hub hub start` still works
-    if (args[0] === 'hub') {
-        return { mode: 'hub', subArgs: args.slice(1), port };
-    }
-    if (HUB_SUBCOMMANDS.has(args[0])) {
-        return { mode: 'hub', subArgs: args, port };
-    }
-    const first = args[0];
-    // Slash-prefixed command: pass through unchanged
-    if (first.startsWith('/')) {
-        const resolved = args.join(' ');
-        return { mode: 'raw', resolved, port };
-    }
-    // Known verb: inject /sr: prefix
-    if (KNOWN_VERBS.has(first)) {
-        const resolved = `/sr:${args.join(' ')}`;
-        return { mode: 'command', resolved, port };
-    }
-    // Unknown first token: treat as raw prompt
-    const resolved = args.join(' ');
-    return { mode: 'raw', resolved, port };
-}
-function printHelp() {
-    process.stdout.write(`
-${bold('specrails-hub')} — specrails CLI bridge
-
-${bold('Usage:')}
-  specrails-hub start                        Start the hub server
-  specrails-hub stop                         Stop the hub server
-  specrails-hub status                       Show hub status and registered projects
-  specrails-hub add <path>                   Register a project
-  specrails-hub remove <id>                  Unregister a project
-  specrails-hub list                         List all registered projects
-  specrails-hub implement #42                Run a known specrails verb (prepends /sr:)
-  specrails-hub batch-implement #40 #41      Known verbs: ${[...KNOWN_VERBS].join(', ')}
-  specrails-hub "any raw prompt"             Pass a raw prompt directly to claude
-  specrails-hub --jobs                       Print recent job history and exit
-  specrails-hub --port <n>                   Override default port (${DEFAULT_PORT})
-  specrails-hub --help                       Show this help text
-
-${bold('Execution paths:')}
-  Manager running → POST /api/spawn + stream logs via WebSocket
-  Manager not running → spawn claude directly with stream-json output
-`.trimStart());
-}
-function detectWebManager(port) {
-    const baseUrl = `http://127.0.0.1:${port}`;
-    return new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            req.destroy();
-            resolve({ running: false, baseUrl });
-        }, DETECTION_TIMEOUT_MS);
-        const req = http_1.default.get(`${baseUrl}/api/state`, { timeout: DETECTION_TIMEOUT_MS }, (res) => {
-            clearTimeout(timer);
-            res.resume(); // drain the response
-            if (res.statusCode !== undefined && res.statusCode >= 200 && res.statusCode < 300) {
-                resolve({ running: true, baseUrl });
-            }
-            else {
-                resolve({ running: false, baseUrl });
-            }
-        });
-        req.on('error', () => {
-            clearTimeout(timer);
-            resolve({ running: false, baseUrl });
-        });
-        req.on('timeout', () => {
-            req.destroy();
-            clearTimeout(timer);
-            resolve({ running: false, baseUrl });
-        });
-    });
-}
-// ---------------------------------------------------------------------------
-// HTTP helpers
-// ---------------------------------------------------------------------------
-function httpGet(url) {
-    return new Promise((resolve, reject) => {
-        const req = http_1.default.get(url, (res) => {
-            let body = '';
-            res.on('data', (chunk) => { body += chunk; });
-            res.on('end', () => resolve({ status: res.statusCode ?? 0, body }));
-        });
-        req.on('error', reject);
-    });
-}
-function httpPost(url, payload) {
-    return new Promise((resolve, reject) => {
-        const data = JSON.stringify(payload);
-        const urlObj = new URL(url);
-        const options = {
-            hostname: urlObj.hostname,
-            port: urlObj.port,
-            path: urlObj.pathname,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Content-Length': Buffer.byteLength(data),
-            },
-        };
-        const req = http_1.default.request(options, (res) => {
-            let body = '';
-            res.on('data', (chunk) => { body += chunk; });
-            res.on('end', () => resolve({ status: res.statusCode ?? 0, body }));
-        });
-        req.on('error', reject);
-        req.write(data);
-        req.end();
-    });
-}
-// ---------------------------------------------------------------------------
-// Duration formatting
-// ---------------------------------------------------------------------------
-function formatDuration(ms) {
-    const totalSeconds = Math.floor(ms / 1000);
-    if (totalSeconds < 60) {
-        return `${totalSeconds}s`;
-    }
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    return `${minutes}m ${seconds}s`;
-}
-// ---------------------------------------------------------------------------
-// Token formatting
-// ---------------------------------------------------------------------------
-function formatTokens(n) {
-    return new Intl.NumberFormat('en-US', { useGrouping: true })
-        .format(n)
-        .replace(/,/g, ' ');
-}
-function printSummary(data) {
-    const doneLabel = isTTY ? bold('[specrails-hub] done') : '[specrails-hub] done';
-    const durationPart = `duration: ${formatDuration(data.durationMs)}`;
-    const costPart = data.costUsd != null ? `  cost: $${data.costUsd.toFixed(2)}` : '';
-    const tokenPart = data.totalTokens != null ? `  tokens: ${formatTokens(data.totalTokens)}` : '';
-    const exitPart = `  exit: ${data.exitCode}`;
-    process.stdout.write(`${doneLabel}  ${durationPart}${costPart}${tokenPart}${exitPart}\n`);
-}
-async function resolveProjectFromCwd(baseUrl) {
-    try {
-        const cwd = process.cwd();
-        const res = await httpGet(`${baseUrl}/api/hub/resolve?path=${encodeURIComponent(cwd)}`);
-        if (res.status === 200) {
-            const data = JSON.parse(res.body);
-            return data.project ?? null;
-        }
-    }
-    catch {
-        // Hub endpoint not available — not in hub mode
-    }
-    return null;
-}
-async function runViaWebManager(command, baseUrl) {
-    // Detect hub mode: check if /api/hub/state is reachable
-    let spawnUrl = `${baseUrl}/api/spawn`;
-    let jobApiBase = `${baseUrl}/api`;
-    try {
-        const hubCheck = await httpGet(`${baseUrl}/api/hub/state`);
-        if (hubCheck.status === 200) {
-            // Hub mode: resolve project from CWD
-            const project = await resolveProjectFromCwd(baseUrl);
-            if (!project) {
-                hubError('hub is running but no project registered for the current directory.\n' +
-                    `  Run: specrails-hub hub add ${process.cwd()}`);
-                return 1;
-            }
-            spawnUrl = `${baseUrl}/api/projects/${project.id}/spawn`;
-            jobApiBase = `${baseUrl}/api/projects/${project.id}`;
-            hubLog(`project: ${project.name}`);
-        }
-    }
-    catch {
-        // Single-project mode — use default paths
-    }
-    // Spawn the job
-    let spawnRes;
-    try {
-        spawnRes = await httpPost(spawnUrl, { command });
-    }
-    catch (err) {
-        hubError('failed to connect to manager');
-        return 1;
-    }
-    if (spawnRes.status === 409) {
-        hubError('manager is busy (another job is running)');
-        return 1;
-    }
-    if (spawnRes.status >= 400) {
-        let errMsg = `spawn failed with HTTP ${spawnRes.status}`;
-        try {
-            const parsed = JSON.parse(spawnRes.body);
-            if (parsed.error)
-                errMsg = parsed.error;
-        }
-        catch { /* use default */ }
-        hubError(errMsg);
-        return 1;
-    }
-    let processId;
-    try {
-        const parsed = JSON.parse(spawnRes.body);
-        // Server returns jobId; processId is the legacy field name used in LogMessage
-        processId = (parsed.jobId ?? parsed.processId) ?? '';
-        if (!processId)
-            throw new Error('missing jobId');
-    }
-    catch {
-        hubError('invalid response from /api/spawn');
-        return 1;
-    }
-    const startTime = Date.now();
-    // Connect WebSocket and stream logs
-    const wsUrl = baseUrl.replace(/^http/, 'ws');
-    let exitCode = 1;
-    let resolved = false;
-    await new Promise((resolve) => {
-        const ws = new ws_1.default(wsUrl);
-        ws.on('message', (data) => {
-            let msg;
-            try {
-                msg = JSON.parse(data.toString());
-            }
-            catch {
-                return;
-            }
-            if (msg.type === 'init') {
-                // Replay only log lines from our processId
-                const initMsg = msg;
-                for (const logLine of initMsg.logBuffer) {
-                    if (logLine.processId === processId) {
-                        handleLogLine(logLine);
-                    }
-                }
-                return;
-            }
-            if (msg.type === 'log') {
-                const logMsg = msg;
-                if (logMsg.processId !== processId)
-                    return;
-                handleLogLine(logMsg);
-                return;
-            }
-            if (msg.type === 'phase') {
-                const phaseMsg = msg;
-                process.stdout.write(`  ${dimCyan(`→ [${phaseMsg.phase}] ${phaseMsg.state}`)}\n`);
-                return;
-            }
-        });
-        function handleLogLine(logMsg) {
-            if (resolved)
-                return;
-            // Check for exit signal
-            const match = EXIT_PATTERN.exec(logMsg.line);
-            if (match) {
-                exitCode = parseInt(match[1], 10);
-                resolved = true;
-                ws.close();
-                resolve();
-                return;
-            }
-            // Print to appropriate stream, preserving ANSI
-            if (logMsg.source === 'stderr') {
-                process.stderr.write(`${logMsg.line}\n`);
-            }
-            else {
-                process.stdout.write(`${logMsg.line}\n`);
-            }
-        }
-        ws.on('close', () => {
-            if (!resolved) {
-                hubWarn('lost connection to manager');
-                resolved = true;
-                resolve();
-            }
-        });
-        ws.on('error', (err) => {
-            if (!resolved) {
-                hubWarn(`WebSocket error: ${err.message}`);
-                resolved = true;
-                resolve();
-            }
-        });
-    });
-    const durationMs = Date.now() - startTime;
-    // Fetch job metadata for cost/tokens
-    let costUsd;
-    let totalTokens;
-    try {
-        const jobRes = await httpGet(`${jobApiBase}/jobs/${processId}`);
-        if (jobRes.status === 200) {
-            const parsed = JSON.parse(jobRes.body);
-            if (parsed.job) {
-                if (parsed.job.total_cost_usd != null)
-                    costUsd = parsed.job.total_cost_usd;
-                const tokensIn = parsed.job.tokens_in ?? 0;
-                const tokensOut = parsed.job.tokens_out ?? 0;
-                if (parsed.job.tokens_in != null || parsed.job.tokens_out != null) {
-                    totalTokens = tokensIn + tokensOut;
-                }
-                // Prefer server-side duration when available
-                if (parsed.job.duration_ms != null) {
-                    printSummary({ durationMs: parsed.job.duration_ms, costUsd, totalTokens, exitCode });
-                    return exitCode;
-                }
-            }
-        }
-    }
-    catch { /* fall through to duration-only summary */ }
-    printSummary({ durationMs, costUsd, totalTokens, exitCode });
-    return exitCode;
-}
-async function runDirect(command) {
-    const startTime = Date.now();
-    const args = [
-        '--dangerously-skip-permissions',
-        '-p',
-        ...command.trim().split(/\s+/),
-        '--output-format', 'stream-json',
-        '--verbose',
-    ];
-    let child;
-    try {
-        child = (0, child_process_1.spawn)('claude', args, {
-            env: process.env,
-            shell: false,
-        });
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === 'ENOENT') {
-            hubError('claude binary not found');
-        }
-        else {
-            hubError(`failed to spawn claude: ${err.message}`);
-        }
-        return 1;
-    }
-    let resultData;
-    // Stderr: pass through unchanged
-    child.stderr?.pipe(process.stderr);
-    // Stdout: parse NDJSON line by line
-    const rl = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
-    rl.on('line', (line) => {
-        if (!line.trim())
-            return;
-        let parsed = null;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            // Non-JSON line: print as-is
-            process.stdout.write(`${line}\n`);
-            return;
-        }
-        if (parsed.type === 'text') {
-            const content = parsed.content ?? '';
-            if (content)
-                process.stdout.write(`${content}\n`);
-        }
-        else if (parsed.type === 'result') {
-            resultData = parsed;
-        }
-        // All other types: silently ignore
-    });
-    const exitCode = await new Promise((resolve) => {
-        child.on('close', (code) => {
-            resolve(code ?? 1);
-        });
-        child.on('error', (err) => {
-            if (err.code === 'ENOENT') {
-                hubError('claude binary not found');
-            }
-            else {
-                hubError(`claude process error: ${err.message}`);
-            }
-            resolve(1);
-        });
-    });
-    const durationMs = Date.now() - startTime;
-    let costUsd;
-    let totalTokens;
-    if (resultData) {
-        if (resultData.cost_usd != null)
-            costUsd = resultData.cost_usd;
-        const tokensIn = resultData.input_tokens ?? 0;
-        const tokensOut = resultData.output_tokens ?? 0;
-        if (resultData.input_tokens != null || resultData.output_tokens != null) {
-            totalTokens = tokensIn + tokensOut;
-        }
-    }
-    printSummary({ durationMs, costUsd, totalTokens, exitCode });
-    return exitCode;
-}
-// ---------------------------------------------------------------------------
-// --status handler
-// ---------------------------------------------------------------------------
-async function handleStatus(port) {
-    const baseUrl = `http://127.0.0.1:${port}`;
-    const detection = await detectWebManager(port);
-    if (!detection.running) {
-        process.stdout.write(`manager: not running (${baseUrl})\n`);
-        return 1;
-    }
-    try {
-        const res = await httpGet(`${baseUrl}/api/state`);
-        if (res.status !== 200) {
-            process.stdout.write(`manager: not running (${baseUrl})\n`);
-            return 1;
-        }
-        const state = JSON.parse(res.body);
-        const version = state.version ? `  (v${state.version})` : '';
-        process.stdout.write(`manager: running${version}\n`);
-        process.stdout.write(`project:     ${state.projectName ?? 'unknown'}\n`);
-        process.stdout.write(`busy:        ${state.busy ? 'true' : 'false'}\n`);
-        if (state.phases) {
-            const phaseStr = Object.entries(state.phases)
-                .map(([phase, st]) => `${phase}=${st}`)
-                .join('  ');
-            process.stdout.write(`phases:      ${phaseStr}\n`);
-        }
-        return 0;
-    }
-    catch {
-        process.stdout.write(`manager: not running (${baseUrl})\n`);
-        return 1;
-    }
-}
-function formatJobDuration(ms) {
-    if (ms == null)
-        return '-';
-    return formatDuration(ms);
-}
-function formatJobStarted(isoStr) {
-    try {
-        const d = new Date(isoStr);
-        const year = d.getFullYear();
-        const month = String(d.getMonth() + 1).padStart(2, '0');
-        const day = String(d.getDate()).padStart(2, '0');
-        const hour = String(d.getHours()).padStart(2, '0');
-        const min = String(d.getMinutes()).padStart(2, '0');
-        return `${year}-${month}-${day} ${hour}:${min}`;
-    }
-    catch {
-        return isoStr.slice(0, 16);
-    }
-}
-async function handleJobs(port) {
-    const baseUrl = `http://127.0.0.1:${port}`;
-    const detection = await detectWebManager(port);
-    if (!detection.running) {
-        hubError(`manager is not running (${baseUrl})`);
-        return 1;
-    }
-    let res;
-    try {
-        res = await httpGet(`${baseUrl}/api/jobs`);
-    }
-    catch {
-        hubError('failed to fetch job list');
-        return 1;
-    }
-    if (res.status === 501 || res.status === 404) {
-        hubLog('jobs history requires manager with SQLite persistence (#57)');
-        return 1;
-    }
-    if (res.status !== 200) {
-        hubError(`unexpected response from /api/jobs: HTTP ${res.status}`);
-        return 1;
-    }
-    let data;
-    try {
-        data = JSON.parse(res.body);
-    }
-    catch {
-        hubError('invalid response from /api/jobs');
-        return 1;
-    }
-    if (!data.jobs || data.jobs.length === 0) {
-        hubLog('no jobs recorded yet');
-        return 0;
-    }
-    // Column widths
-    const idW = 8;
-    const cmdW = 30;
-    const startW = 18;
-    const durW = 8;
-    const exitW = 4;
-    const header = [
-        'ID'.padEnd(idW),
-        'COMMAND'.padEnd(cmdW),
-        'STARTED'.padEnd(startW),
-        'DURATION'.padEnd(durW),
-        'EXIT'.padEnd(exitW),
-    ].join('  ');
-    process.stdout.write(`${bold(header)}\n`);
-    for (const job of data.jobs) {
-        const idCell = job.id.slice(0, idW).padEnd(idW);
-        const cmdCell = job.command.slice(0, cmdW).padEnd(cmdW);
-        const startCell = formatJobStarted(job.started_at).padEnd(startW);
-        const durCell = formatJobDuration(job.duration_ms).padEnd(durW);
-        const exitCell = (job.exit_code ?? '-').toString().padEnd(exitW);
-        process.stdout.write(`${idCell}  ${cmdCell}  ${startCell}  ${durCell}  ${exitCell}\n`);
-    }
-    return 0;
-}
-// ---------------------------------------------------------------------------
-// Hub subcommand group
-// ---------------------------------------------------------------------------
-const HUB_PID_FILE = path_1.default.join(os_1.default.homedir(), '.specrails', 'manager.pid');
-function readPid() {
-    try {
-        const raw = fs_1.default.readFileSync(HUB_PID_FILE, 'utf-8').trim();
-        const pid = parseInt(raw, 10);
-        return isNaN(pid) ? null : pid;
-    }
-    catch {
-        return null;
-    }
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function hubServerPath() {
-    // cli/dist/hub.js → __dirname is cli/dist/ → go up two levels to package root
-    const base = path_1.default.resolve(__dirname, '..', '..');
-    // npm install: compiled server at dist/server/index.js
-    const compiled = path_1.default.join(base, 'dist', 'server', 'index.js');
-    // dev fallback: run TypeScript source directly via tsx
-    const devTs = path_1.default.join(base, 'server', 'index.ts');
-    if (fs_1.default.existsSync(compiled))
-        return compiled;
-    if (fs_1.default.existsSync(devTs))
-        return devTs;
-    return compiled;
-}
-async function hubStart(port) {
-    const pid = readPid();
-    if (pid !== null && isProcessRunning(pid)) {
-        hubLog(`hub already running (pid ${pid}) on port ${port}`);
-        return 0;
-    }
-    const serverPath = hubServerPath();
-    const isTs = serverPath.endsWith('.ts');
-    const args = isTs
-        ? ['tsx', serverPath, '--port', String(port)]
-        : ['node', serverPath, '--port', String(port)];
-    const child = (0, child_process_2.spawn)(args[0], args.slice(1), {
-        detached: true,
-        stdio: 'ignore',
-        env: { ...process.env },
-    });
-    child.unref();
-    // Poll until the hub is ready (up to 15 seconds)
-    const deadline = Date.now() + 15_000;
-    const pollInterval = 500;
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    while (Date.now() < deadline) {
-        const detection = await detectWebManager(port);
-        if (detection.running) {
-            hubLog(`hub started on http://127.0.0.1:${port}`);
-            return 0;
-        }
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-    hubError('hub failed to start (check logs)');
-    return 1;
-}
-async function hubStop() {
-    const pid = readPid();
-    if (pid === null) {
-        hubLog('hub is not running (no pid file)');
-        return 0;
-    }
-    if (!isProcessRunning(pid)) {
-        hubLog('hub is not running (stale pid file)');
-        try {
-            fs_1.default.unlinkSync(HUB_PID_FILE);
-        }
-        catch { /* ignore */ }
-        return 0;
-    }
-    try {
-        process.kill(pid, 'SIGTERM');
-        hubLog(`hub stopped (pid ${pid})`);
-        return 0;
-    }
-    catch (err) {
-        hubError(`failed to stop hub: ${err.message}`);
-        return 1;
-    }
-}
-async function hubStatus(port) {
-    const pid = readPid();
-    const detection = await detectWebManager(port);
-    if (!detection.running) {
-        process.stdout.write(`hub: not running\n`);
-        return 1;
-    }
-    try {
-        const res = await httpGet(`${detection.baseUrl}/api/hub/state`);
-        const state = JSON.parse(res.body);
-        process.stdout.write(`hub: running (pid ${pid ?? '?'}) on ${detection.baseUrl}\n`);
-        process.stdout.write(`projects: ${state.projectCount ?? 0}\n`);
-        if (state.projects) {
-            for (const p of state.projects) {
-                process.stdout.write(`  - ${p.name}\n`);
-            }
-        }
-        return 0;
-    }
-    catch {
-        process.stdout.write(`hub: running on ${detection.baseUrl}\n`);
-        return 0;
-    }
-}
-async function hubAdd(projectPath, port) {
-    const detection = await detectWebManager(port);
-    if (!detection.running) {
-        hubError('hub is not running. Start it first with: specrails-hub start');
-        return 1;
-    }
-    try {
-        const res = await httpPost(`${detection.baseUrl}/api/hub/projects`, {
-            path: path_1.default.resolve(projectPath),
-        });
-        if (res.status === 201) {
-            const data = JSON.parse(res.body);
-            hubLog(`added project: ${data.project?.name ?? projectPath}`);
-            return 0;
-        }
-        else if (res.status === 409) {
-            hubLog('project already registered');
-            return 0;
-        }
-        else {
-            let errMsg = `HTTP ${res.status}`;
-            try {
-                errMsg = JSON.parse(res.body).error ?? errMsg;
-            }
-            catch { /* use default */ }
-            hubError(`failed to add project: ${errMsg}`);
-            return 1;
-        }
-    }
-    catch (err) {
-        hubError(`failed to connect to hub: ${err.message}`);
-        return 1;
-    }
-}
-async function hubRemove(projectId, port) {
-    const detection = await detectWebManager(port);
-    if (!detection.running) {
-        hubError('hub is not running');
-        return 1;
-    }
-    try {
-        const deleteRes = await new Promise((resolve, reject) => {
-            const urlObj = new URL(`${detection.baseUrl}/api/hub/projects/${projectId}`);
-            const options = {
-                hostname: urlObj.hostname,
-                port: urlObj.port,
-                path: urlObj.pathname,
-                method: 'DELETE',
-            };
-            const req = http_1.default.request(options, (res) => {
-                let body = '';
-                res.on('data', (chunk) => { body += chunk; });
-                res.on('end', () => resolve({ status: res.statusCode ?? 0, body }));
-            });
-            req.on('error', reject);
-            req.end();
-        });
-        if (deleteRes.status === 200) {
-            hubLog(`project removed`);
-            return 0;
-        }
-        else {
-            hubError(`failed to remove project: HTTP ${deleteRes.status}`);
-            return 1;
-        }
-    }
-    catch (err) {
-        hubError(`failed to connect to hub: ${err.message}`);
-        return 1;
-    }
-}
-async function hubList(port) {
-    const detection = await detectWebManager(port);
-    if (!detection.running) {
-        hubError('hub is not running');
-        return 1;
-    }
-    try {
-        const res = await httpGet(`${detection.baseUrl}/api/hub/projects`);
-        const data = JSON.parse(res.body);
-        if (!data.projects || data.projects.length === 0) {
-            hubLog('no projects registered');
-            return 0;
-        }
-        const idW = 36;
-        const nameW = 24;
-        process.stdout.write(`${bold('ID'.padEnd(idW))}  ${bold('NAME'.padEnd(nameW))}  ${bold('PATH')}\n`);
-        for (const p of data.projects) {
-            process.stdout.write(`${p.id.padEnd(idW)}  ${p.name.padEnd(nameW)}  ${p.path}\n`);
-        }
-        return 0;
-    }
-    catch (err) {
-        hubError(`failed to fetch projects: ${err.message}`);
-        return 1;
-    }
-}
-async function handleHub(subArgs, port) {
-    const sub = subArgs[0];
-    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
-        process.stdout.write(`
-${bold('specrails-hub')} — manage the specrails hub (multi-project mode)
-
-${bold('Usage:')}
-  specrails-hub start              Start the hub server
-  specrails-hub stop               Stop the hub server
-  specrails-hub status             Show hub status and registered projects
-  specrails-hub add <path>         Register a project by path
-  specrails-hub remove <id>        Unregister a project by ID
-  specrails-hub list               List all registered projects
-`.trimStart());
-        return 0;
-    }
-    if (sub === 'start') {
-        return hubStart(port);
-    }
-    if (sub === 'stop') {
-        return hubStop();
-    }
-    if (sub === 'status') {
-        return hubStatus(port);
-    }
-    if (sub === 'add') {
-        const projectPath = subArgs[1];
-        if (!projectPath) {
-            hubError('usage: specrails-hub add <path>');
-            return 1;
-        }
-        return hubAdd(projectPath, port);
-    }
-    if (sub === 'remove') {
-        const projectId = subArgs[1];
-        if (!projectId) {
-            hubError('usage: specrails-hub remove <id>');
-            return 1;
-        }
-        return hubRemove(projectId, port);
-    }
-    if (sub === 'list') {
-        return hubList(port);
-    }
-    hubError(`unknown hub subcommand: ${sub}`);
-    return 1;
-}
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-async function main() {
-    const argv = process.argv.slice(2);
-    const parsed = parseArgs(argv);
-    if (parsed.mode === 'help') {
-        printHelp();
-        process.exit(0);
-    }
-    if (parsed.mode === 'status') {
-        const code = await handleStatus(parsed.port);
-        process.exit(code);
-    }
-    if (parsed.mode === 'jobs') {
-        const code = await handleJobs(parsed.port);
-        process.exit(code);
-    }
-    if (parsed.mode === 'hub') {
-        const code = await handleHub(parsed.subArgs, parsed.port);
-        process.exit(code);
-    }
-    // Command or raw: resolve command string
-    const command = parsed.resolved;
-    const port = parsed.port;
-    hubLog(`running: ${command}`);
-    const detection = await detectWebManager(port);
-    let exitCode;
-    if (detection.running) {
-        hubLog(`routing via manager at ${detection.baseUrl}`);
-        exitCode = await runViaWebManager(command, detection.baseUrl);
-    }
-    else {
-        hubLog('manager not running — invoking claude directly');
-        exitCode = await runDirect(command);
-    }
-    process.exit(exitCode);
-}
-// Only run main() when this file is executed directly (not when imported in tests)
-if (require.main === module) {
-    main().catch((err) => {
-        hubError(err.message ?? String(err));
-        process.exit(1);
-    });
-}