specrails-desktop 2.54.0 → 2.55.1

package/cli/dist/args.js

@@ -0,0 +1,80 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_VERBS = exports.DEFAULT_PORT = void 0;
+exports.parseArgs = parseArgs;
+exports.DEFAULT_PORT = 4200;
+exports.KNOWN_VERBS = new Set([
+    'implement',
+    'batch-implement',
+    'why',
+    'get-backlog-specs',
+    'auto-propose-backlog-specs',
+    'propose-spec',
+    'refactor-recommender',
+    'health-check',
+    'compat-check',
+    'enrich',
+]);
+function parseArgs(argv) {
+    // argv is process.argv.slice(2)
+    let port = exports.DEFAULT_PORT;
+    let projectOverride;
+    const args = [...argv];
+    // Extract --port <n> and --project <name|path> 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--;
+        }
+        else if (args[i] === '--project' && i + 1 < args.length) {
+            projectOverride = args[i + 1];
+            args.splice(i, 2);
+            i--;
+        }
+    }
+    if (args[0] === '--version' || args[0] === '-v') {
+        return { mode: 'version' };
+    }
+    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 };
+    }
+    if (args[0] === 'desktop') {
+        return { mode: 'desktop', subArgs: args.slice(1), port };
+    }
+    // Allow server-management subcommands directly without the 'desktop' prefix:
+    //   specrails-desktop start  →  specrails-desktop desktop start
+    //   specrails-desktop stop   →  specrails-desktop desktop stop
+    //   specrails-desktop add    →  specrails-desktop desktop add
+    //   etc.
+    const DESKTOP_SUBCOMMANDS = new Set(['start', 'stop', 'status', 'add', 'remove', 'list']);
+    if (DESKTOP_SUBCOMMANDS.has(args[0])) {
+        return { mode: 'desktop', 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, projectOverride };
+    }
+    // Known verb: inject /specrails: prefix
+    if (exports.KNOWN_VERBS.has(first)) {
+        const resolved = `/specrails:${args.join(' ')}`;
+        return { mode: 'command', resolved, port, projectOverride };
+    }
+    // Unknown first token: treat as raw prompt
+    const resolved = args.join(' ');
+    return { mode: 'raw', resolved, port, projectOverride };
+}

package/cli/dist/desktop-client.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_REQUEST_TIMEOUT_MS = exports.DETECTION_TIMEOUT_MS = void 0;
+exports.detectWebManager = detectWebManager;
+exports.loadDesktopToken = loadDesktopToken;
+exports.requestTimeoutError = requestTimeoutError;
+exports.httpGet = httpGet;
+exports.httpPost = httpPost;
+const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+exports.DETECTION_TIMEOUT_MS = 500;
+exports.HTTP_REQUEST_TIMEOUT_MS = 15_000;
+function detectWebManager(port) {
+    const baseUrl = `http://127.0.0.1:${port}`;
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            req.destroy();
+            resolve({ running: false, baseUrl });
+        }, exports.DETECTION_TIMEOUT_MS);
+        const req = http_1.default.get(`${baseUrl}/api/health`, { timeout: exports.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 loadDesktopToken() {
+    const candidates = [
+        path_1.default.join(os_1.default.homedir(), '.specrails', 'desktop.token'),
+        // Legacy fallback: pre-rename installs keep the token at hub.token until the
+        // server migrates it on next startup. Compat only — do not extend.
+        path_1.default.join(os_1.default.homedir(), '.specrails', 'hub.token'),
+    ];
+    for (const tokenPath of candidates) {
+        try {
+            const t = fs_1.default.readFileSync(tokenPath, 'utf-8').trim();
+            if (t.length >= 32)
+                return t;
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+function requestTimeoutError(url, timeoutMs) {
+    return new Error(`Request to ${url} timed out after ${timeoutMs}ms`);
+}
+function httpGet(url, timeoutMs = exports.HTTP_REQUEST_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const token = loadDesktopToken();
+        const parsed = new URL(url);
+        const headers = {};
+        if (token)
+            headers['Authorization'] = `Bearer ${token}`;
+        const options = {
+            hostname: parsed.hostname,
+            port: parsed.port,
+            path: parsed.pathname + parsed.search,
+            headers,
+        };
+        const req = http_1.default.get(options, (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => resolve({ status: res.statusCode ?? 0, body }));
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(requestTimeoutError(url, timeoutMs));
+        });
+        req.on('error', reject);
+    });
+}
+function httpPost(url, payload, timeoutMs = exports.HTTP_REQUEST_TIMEOUT_MS) {
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify(payload);
+        const urlObj = new URL(url);
+        const token = loadDesktopToken();
+        const headers = {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(data),
+        };
+        if (token)
+            headers['Authorization'] = `Bearer ${token}`;
+        const options = {
+            hostname: urlObj.hostname,
+            port: urlObj.port,
+            path: urlObj.pathname,
+            method: 'POST',
+            headers,
+        };
+        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.setTimeout(timeoutMs, () => {
+            req.destroy(requestTimeoutError(url, timeoutMs));
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}

package/cli/dist/desktop-control.js

@@ -0,0 +1,339 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DESKTOP_LOG_FILE = exports.DESKTOP_PID_FILE = void 0;
+exports.isPortInUse = isPortInUse;
+exports.readPid = readPid;
+exports.isProcessRunning = isProcessRunning;
+exports.desktopServerPath = desktopServerPath;
+exports.desktopStart = desktopStart;
+exports.desktopStop = desktopStop;
+exports.desktopStatus = desktopStatus;
+exports.desktopAdd = desktopAdd;
+exports.desktopRemove = desktopRemove;
+exports.desktopList = desktopList;
+exports.handleDesktop = handleDesktop;
+const http_1 = __importDefault(require("http"));
+const net_1 = __importDefault(require("net"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const win_spawn_1 = require("./win-spawn");
+const fs_1 = __importDefault(require("fs"));
+const output_1 = require("./output");
+const desktop_client_1 = require("./desktop-client");
+// ---------------------------------------------------------------------------
+// Server-management subcommand group
+// ---------------------------------------------------------------------------
+exports.DESKTOP_PID_FILE = path_1.default.join(os_1.default.homedir(), '.specrails', 'manager.pid');
+exports.DESKTOP_LOG_FILE = path_1.default.join(os_1.default.homedir(), '.specrails', 'desktop.log');
+function isPortInUse(port) {
+    return new Promise((resolve) => {
+        const srv = net_1.default.createServer();
+        srv.once('error', (err) => {
+            resolve(err.code === 'EADDRINUSE');
+        });
+        srv.once('listening', () => {
+            srv.close();
+            resolve(false);
+        });
+        srv.listen(port, '127.0.0.1');
+    });
+}
+function readPid() {
+    try {
+        const raw = fs_1.default.readFileSync(exports.DESKTOP_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 desktopServerPath() {
+    // __dirname differs by runtime:
+    //   compiled (npm install): <root>/cli/dist/  → need ../../server/dist/index.js
+    //   tsx dev:                <root>/cli/        → need ../server/dist/index.js
+    // Try both, compiled path first.
+    const fromDist = path_1.default.resolve(__dirname, '..', '..', 'server', 'dist', 'index.js');
+    const fromSrc = path_1.default.resolve(__dirname, '..', 'server', 'dist', 'index.js');
+    const devTs = path_1.default.resolve(__dirname, '..', 'server', 'index.ts');
+    if (fs_1.default.existsSync(fromDist))
+        return fromDist;
+    if (fs_1.default.existsSync(fromSrc))
+        return fromSrc;
+    if (fs_1.default.existsSync(devTs))
+        return devTs;
+    return fromDist;
+}
+async function desktopStart(port) {
+    const pid = readPid();
+    if (pid !== null && isProcessRunning(pid)) {
+        (0, output_1.cliLog)(`server already running (pid ${pid}) on port ${port}`);
+        return 0;
+    }
+    // Check if port is already in use by another process
+    const portBusy = await isPortInUse(port);
+    if (portBusy) {
+        (0, output_1.cliError)(`port ${port} is already in use by another process`);
+        (0, output_1.cliError)(`if a previous server is stale, run: specrails-desktop stop`);
+        (0, output_1.cliError)(`or use a different port: specrails-desktop --port <port> start`);
+        return 1;
+    }
+    const serverPath = desktopServerPath();
+    const isTs = serverPath.endsWith('.ts');
+    const args = isTs
+        ? ['tsx', serverPath, '--port', String(port)]
+        : ['node', serverPath, '--port', String(port)];
+    // Ensure log dir exists and open log file for server output
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(exports.DESKTOP_LOG_FILE), { recursive: true });
+    }
+    catch { /* ignore */ }
+    let logFd;
+    try {
+        logFd = fs_1.default.openSync(exports.DESKTOP_LOG_FILE, 'a');
+    }
+    catch { /* ignore — fall back to silent */ }
+    const stdio = [
+        'ignore',
+        logFd ?? 'ignore',
+        logFd ?? 'ignore',
+    ];
+    // spawnCli so a dev `tsx`(.cmd) launcher resolves on Windows and the env is
+    // SystemRoot-backfilled; for the packaged `node` path cross-spawn spawns the
+    // .exe directly (no cmd.exe wrapper), keeping `detached` clean.
+    const child = (0, win_spawn_1.spawnCli)(args[0], args.slice(1), {
+        detached: true,
+        stdio,
+        env: { ...process.env },
+    });
+    if (logFd !== undefined) {
+        try {
+            fs_1.default.closeSync(logFd);
+        }
+        catch { /* ignore */ }
+    }
+    child.unref();
+    // Poll until the server is ready (up to 15 seconds, checking every 300ms)
+    const pollTimeoutMs = 15000;
+    const pollIntervalMs = 300;
+    const startPoll = Date.now();
+    while (Date.now() - startPoll < pollTimeoutMs) {
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        const detection = await (0, desktop_client_1.detectWebManager)(port);
+        if (detection.running) {
+            (0, output_1.cliLog)(`server started on http://127.0.0.1:${port}`);
+            return 0;
+        }
+    }
+    (0, output_1.cliError)(`server failed to start — logs: ${exports.DESKTOP_LOG_FILE}`);
+    return 1;
+}
+async function desktopStop() {
+    const pid = readPid();
+    if (pid === null) {
+        (0, output_1.cliLog)('server is not running (no pid file)');
+        return 0;
+    }
+    if (!isProcessRunning(pid)) {
+        (0, output_1.cliLog)('server is not running (stale pid file)');
+        try {
+            fs_1.default.unlinkSync(exports.DESKTOP_PID_FILE);
+        }
+        catch { /* ignore */ }
+        return 0;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        (0, output_1.cliLog)(`server stopped (pid ${pid})`);
+        return 0;
+    }
+    catch (err) {
+        (0, output_1.cliError)(`failed to stop server: ${err.message}`);
+        return 1;
+    }
+}
+async function desktopStatus(port) {
+    const pid = readPid();
+    const detection = await (0, desktop_client_1.detectWebManager)(port);
+    if (!detection.running) {
+        process.stdout.write(`server: not running\n`);
+        return 1;
+    }
+    try {
+        const res = await (0, desktop_client_1.httpGet)(`${detection.baseUrl}/api/state`);
+        const state = JSON.parse(res.body);
+        process.stdout.write(`server: 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(`server: running on ${detection.baseUrl}\n`);
+        return 0;
+    }
+}
+async function desktopAdd(projectPath, port) {
+    const detection = await (0, desktop_client_1.detectWebManager)(port);
+    if (!detection.running) {
+        (0, output_1.cliError)('server is not running. Start it first with: specrails-desktop start');
+        return 1;
+    }
+    try {
+        const res = await (0, desktop_client_1.httpPost)(`${detection.baseUrl}/api/projects`, {
+            path: path_1.default.resolve(projectPath),
+        });
+        if (res.status === 201) {
+            const data = JSON.parse(res.body);
+            (0, output_1.cliLog)(`added project: ${data.project?.name ?? projectPath}`);
+            return 0;
+        }
+        else if (res.status === 409) {
+            (0, output_1.cliLog)('project already registered');
+            return 0;
+        }
+        else {
+            let errMsg = `HTTP ${res.status}`;
+            try {
+                errMsg = JSON.parse(res.body).error ?? errMsg;
+            }
+            catch { /* use default */ }
+            (0, output_1.cliError)(`failed to add project: ${errMsg}`);
+            return 1;
+        }
+    }
+    catch (err) {
+        (0, output_1.cliError)(`failed to connect to server: ${err.message}`);
+        return 1;
+    }
+}
+async function desktopRemove(projectId, port) {
+    const detection = await (0, desktop_client_1.detectWebManager)(port);
+    if (!detection.running) {
+        (0, output_1.cliError)('server is not running');
+        return 1;
+    }
+    try {
+        const deleteRes = await new Promise((resolve, reject) => {
+            const urlObj = new URL(`${detection.baseUrl}/api/projects/${projectId}`);
+            const token = (0, desktop_client_1.loadDesktopToken)();
+            const headers = {};
+            if (token)
+                headers['Authorization'] = `Bearer ${token}`;
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port,
+                path: urlObj.pathname,
+                method: 'DELETE',
+                headers,
+            };
+            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) {
+            (0, output_1.cliLog)(`project removed`);
+            return 0;
+        }
+        else {
+            (0, output_1.cliError)(`failed to remove project: HTTP ${deleteRes.status}`);
+            return 1;
+        }
+    }
+    catch (err) {
+        (0, output_1.cliError)(`failed to connect to server: ${err.message}`);
+        return 1;
+    }
+}
+async function desktopList(port) {
+    const detection = await (0, desktop_client_1.detectWebManager)(port);
+    if (!detection.running) {
+        (0, output_1.cliError)('server is not running');
+        return 1;
+    }
+    try {
+        const res = await (0, desktop_client_1.httpGet)(`${detection.baseUrl}/api/projects`);
+        const data = JSON.parse(res.body);
+        if (!data.projects || data.projects.length === 0) {
+            (0, output_1.cliLog)('no projects registered');
+            return 0;
+        }
+        const idW = 36;
+        const nameW = 24;
+        process.stdout.write(`${(0, output_1.bold)('ID'.padEnd(idW))}  ${(0, output_1.bold)('NAME'.padEnd(nameW))}  ${(0, output_1.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) {
+        (0, output_1.cliError)(`failed to fetch projects: ${err.message}`);
+        return 1;
+    }
+}
+async function handleDesktop(subArgs, port) {
+    const sub = subArgs[0];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        process.stdout.write(`
+${(0, output_1.bold)('specrails-desktop')} — server management
+
+${(0, output_1.bold)('Usage:')}
+  specrails-desktop start                  Start the Specrails server
+  specrails-desktop stop                   Stop the Specrails server
+  specrails-desktop status                 Show server status and registered projects
+  specrails-desktop add <path>             Register a project by path
+  specrails-desktop remove <id>            Unregister a project by ID
+  specrails-desktop list                   List all registered projects
+`.trimStart());
+        return 0;
+    }
+    if (sub === 'start') {
+        return desktopStart(port);
+    }
+    if (sub === 'stop') {
+        return desktopStop();
+    }
+    if (sub === 'status') {
+        return desktopStatus(port);
+    }
+    if (sub === 'add') {
+        const projectPath = subArgs[1];
+        if (!projectPath) {
+            (0, output_1.cliError)('usage: specrails-desktop add <path>');
+            return 1;
+        }
+        return desktopAdd(projectPath, port);
+    }
+    if (sub === 'remove') {
+        const projectId = subArgs[1];
+        if (!projectId) {
+            (0, output_1.cliError)('usage: specrails-desktop remove <id>');
+            return 1;
+        }
+        return desktopRemove(projectId, port);
+    }
+    if (sub === 'list') {
+        return desktopList(port);
+    }
+    (0, output_1.cliError)(`unknown subcommand: ${sub}`);
+    return 1;
+}

package/cli/dist/format.js

@@ -0,0 +1,45 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Duration formatting
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDuration = formatDuration;
+exports.formatTokens = formatTokens;
+exports.formatJobDuration = formatJobDuration;
+exports.formatJobStarted = formatJobStarted;
+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 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);
+    }
+}

package/cli/dist/help.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersion = getVersion;
+exports.printVersion = printVersion;
+exports.printHelp = printHelp;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const output_1 = require("./output");
+const args_1 = require("./args");
+function getVersion() {
+    for (const rel of ['../package.json', '../../package.json']) {
+        try {
+            const pkgPath = path_1.default.join(__dirname, rel);
+            const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+            if (typeof pkg.version === 'string')
+                return pkg.version;
+        }
+        catch {
+            // try next
+        }
+    }
+    return 'unknown';
+}
+function printVersion() {
+    process.stdout.write(`specrails-desktop v${getVersion()}\n`);
+}
+function printHelp() {
+    const version = getVersion();
+    process.stdout.write(`
+${(0, output_1.bold)(`specrails-desktop v${version}`)} — specrails CLI bridge
+
+${(0, output_1.bold)('Project Required:')}
+  Every command runs in the context of a project registered for the current
+  directory. Register your project once before running any commands:
+
+    ${(0, output_1.dim)('# Register your project (run once per project):')}
+    specrails-desktop add .
+
+    ${(0, output_1.dim)('# Then run commands from that directory:')}
+    specrails-desktop implement #42
+
+${(0, output_1.bold)('Usage:')}
+  specrails-desktop implement #42                Run a known specrails verb (prepends /specrails:)
+  specrails-desktop batch-implement #40 #41      Batch implementation across issues
+  specrails-desktop why                          Explain recent changes
+  specrails-desktop get-backlog-specs            View prioritized spec backlog
+  specrails-desktop auto-propose-backlog-specs   Generate new spec ideas
+  specrails-desktop propose-spec                 Explore an idea and produce a spec
+  specrails-desktop refactor-recommender        Find refactoring opportunities
+  specrails-desktop health-check                Run codebase health check
+  specrails-desktop compat-check                Check for breaking API changes
+  specrails-desktop "any raw prompt"             Pass a raw prompt directly to claude
+  specrails-desktop --status                     Print manager status and exit
+  specrails-desktop --jobs                       Print recent job history and exit
+  specrails-desktop start|stop|add|remove|list  Manage the server
+  specrails-desktop --project <name|path>        Override project (default: current directory)
+  specrails-desktop --port <n>                   Override default port (${args_1.DEFAULT_PORT})
+  specrails-desktop --version, -v               Print version and exit
+  specrails-desktop --help, -h                  Show this help text
+
+${(0, output_1.bold)('Execution paths:')}
+  Manager running → POST /api/spawn + stream logs via WebSocket
+  Manager not running → spawn claude directly with stream-json output
+`.trimStart());
+}