specrails-desktop 2.55.0 → 2.56.0

package/cli/dist/output.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dimCyan = exports.bold = exports.red = exports.dim = exports.isTTY = void 0;
+exports.ansi = ansi;
+exports.cliPrefix = cliPrefix;
+exports.cliLog = cliLog;
+exports.cliError = cliError;
+exports.cliWarn = cliWarn;
+exports.printSummary = printSummary;
+const format_1 = require("./format");
+// ---------------------------------------------------------------------------
+// ANSI helpers
+// ---------------------------------------------------------------------------
+exports.isTTY = process.stdout.isTTY === true;
+function ansi(code, text) {
+    if (!exports.isTTY)
+        return text;
+    return `\x1b[${code}m${text}\x1b[0m`;
+}
+const dim = (t) => ansi('2', t);
+exports.dim = dim;
+const red = (t) => ansi('31', t);
+exports.red = red;
+const bold = (t) => ansi('1', t);
+exports.bold = bold;
+const dimCyan = (t) => ansi('2;36', t);
+exports.dimCyan = dimCyan;
+function cliPrefix() {
+    return (0, exports.dim)('[specrails-desktop]');
+}
+function cliLog(msg) {
+    process.stdout.write(`${cliPrefix()} ${msg}\n`);
+}
+function cliError(msg) {
+    process.stderr.write(`${cliPrefix()} ${(0, exports.red)(`error: ${msg}`)}\n`);
+}
+function cliWarn(msg) {
+    process.stderr.write(`${cliPrefix()} ${(0, exports.dim)(`warning: ${msg}`)}\n`);
+}
+function printSummary(data) {
+    const doneLabel = exports.isTTY ? (0, exports.bold)('[specrails-desktop] done') : '[specrails-desktop] done';
+    const durationPart = `duration: ${(0, format_1.formatDuration)(data.durationMs)}`;
+    const costPart = data.costUsd != null ? `  cost: $${data.costUsd.toFixed(2)}` : '';
+    const tokenPart = data.totalTokens != null ? `  tokens: ${(0, format_1.formatTokens)(data.totalTokens)}` : '';
+    const exitPart = `  exit: ${data.exitCode}`;
+    process.stdout.write(`${doneLabel}  ${durationPart}${costPart}${tokenPart}${exitPart}\n`);
+}

package/cli/dist/run-command.js

@@ -0,0 +1,340 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXIT_PATTERN = void 0;
+exports.resolveProjectFromCwd = resolveProjectFromCwd;
+exports.runViaWebManager = runViaWebManager;
+exports.runDirect = runDirect;
+const readline_1 = require("readline");
+const ws_1 = __importDefault(require("ws"));
+const path_1 = __importDefault(require("path"));
+const win_spawn_1 = require("./win-spawn");
+const desktop_client_1 = require("./desktop-client");
+const output_1 = require("./output");
+exports.EXIT_PATTERN = /\[process exited with code (\d+)/;
+async function resolveProjectFromCwd(baseUrl, projectOverride) {
+    try {
+        // --project flag: resolve by path (absolute/relative) or by name
+        if (projectOverride) {
+            // Path vs name: POSIX absolute (`/…`), relative (`./…`), OR a Windows
+            // absolute (`C:\…` / `C:/…`) or any path containing a separator. Without
+            // the drive-letter/backslash cases `--project C:\repo` was mis-read as a
+            // project NAME on Windows and never matched.
+            const isPathLike = path_1.default.isAbsolute(projectOverride) ||
+                projectOverride.startsWith('.') ||
+                /^[A-Za-z]:[\\/]/.test(projectOverride) ||
+                projectOverride.includes('/') ||
+                projectOverride.includes('\\');
+            if (isPathLike) {
+                const res = await (0, desktop_client_1.httpGet)(`${baseUrl}/api/resolve?path=${encodeURIComponent(projectOverride)}`);
+                if (res.status === 200) {
+                    const data = JSON.parse(res.body);
+                    return data.project ?? null;
+                }
+            }
+            else {
+                // Resolve by name: fetch all projects and match. Names are NOT unique
+                // (two repos with the same basename register the same name), so a bare
+                // first-match `find` would silently mis-route. Auto-pick only on a
+                // unique match; on collision, error out listing the candidates.
+                const res = await (0, desktop_client_1.httpGet)(`${baseUrl}/api/projects`);
+                if (res.status === 200) {
+                    const data = JSON.parse(res.body);
+                    const matches = (data.projects ?? []).filter((p) => p.name.toLowerCase() === projectOverride.toLowerCase());
+                    if (matches.length > 1) {
+                        (0, output_1.cliError)(`--project "${projectOverride}" is ambiguous (${matches.length} projects share this name):`);
+                        for (const m of matches) {
+                            (0, output_1.cliError)(`  ${m.id}  ${m.path}`);
+                        }
+                        (0, output_1.cliError)('disambiguate with --project <path> instead of the name');
+                        return null;
+                    }
+                    return matches[0] ?? null;
+                }
+            }
+            return null;
+        }
+        // Default: resolve from CWD
+        const cwd = process.cwd();
+        const res = await (0, desktop_client_1.httpGet)(`${baseUrl}/api/resolve?path=${encodeURIComponent(cwd)}`);
+        if (res.status === 200) {
+            const data = JSON.parse(res.body);
+            return data.project ?? null;
+        }
+    }
+    catch {
+        // Resolve endpoint not available — not in Super mode
+    }
+    return null;
+}
+async function runViaWebManager(command, baseUrl, projectOverride) {
+    // Detect Super mode: check if /api/state is reachable
+    let spawnUrl = `${baseUrl}/api/spawn`;
+    let jobApiBase = `${baseUrl}/api`;
+    try {
+        const superCheck = await (0, desktop_client_1.httpGet)(`${baseUrl}/api/state`);
+        if (superCheck.status === 200) {
+            // Super mode: resolve project from CWD or --project override
+            const project = await resolveProjectFromCwd(baseUrl, projectOverride);
+            if (!project) {
+                const hint = projectOverride
+                    ? `no project found matching: ${projectOverride}`
+                    : `no project registered for the current directory.\n  Run: specrails-desktop add ${process.cwd()}`;
+                (0, output_1.cliError)(`server is running but ${hint}`);
+                return 1;
+            }
+            spawnUrl = `${baseUrl}/api/projects/${project.id}/spawn`;
+            jobApiBase = `${baseUrl}/api/projects/${project.id}`;
+            (0, output_1.cliLog)(`project: ${project.name}`);
+        }
+    }
+    catch {
+        // Single-project mode — use default paths
+    }
+    // Spawn the job
+    let spawnRes;
+    try {
+        spawnRes = await (0, desktop_client_1.httpPost)(spawnUrl, { command });
+    }
+    catch (err) {
+        (0, output_1.cliError)('failed to connect to manager');
+        return 1;
+    }
+    if (spawnRes.status === 409) {
+        (0, output_1.cliError)('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 */ }
+        (0, output_1.cliError)(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 {
+        (0, output_1.cliError)('invalid response from /api/spawn');
+        return 1;
+    }
+    const startTime = Date.now();
+    // Connect WebSocket and stream logs
+    const wsUrl = baseUrl.replace(/^http/, 'ws');
+    const token = (0, desktop_client_1.loadDesktopToken)();
+    let exitCode = 1;
+    let resolved = false;
+    await new Promise((resolve) => {
+        const ws = new ws_1.default(wsUrl, {
+            headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+        });
+        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(`  ${(0, output_1.dimCyan)(`→ [${phaseMsg.phase}] ${phaseMsg.state}`)}\n`);
+                return;
+            }
+        });
+        function handleLogLine(logMsg) {
+            if (resolved)
+                return;
+            // Check for exit signal
+            const match = exports.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) {
+                (0, output_1.cliWarn)('lost connection to manager');
+                resolved = true;
+                resolve();
+            }
+        });
+        ws.on('error', (err) => {
+            if (!resolved) {
+                (0, output_1.cliWarn)(`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 (0, desktop_client_1.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) {
+                    (0, output_1.printSummary)({ durationMs: parsed.job.duration_ms, costUsd, totalTokens, exitCode });
+                    return exitCode;
+                }
+            }
+        }
+    }
+    catch { /* fall through to duration-only summary */ }
+    (0, output_1.printSummary)({ durationMs, costUsd, totalTokens, exitCode });
+    return exitCode;
+}
+async function runDirect(command) {
+    const startTime = Date.now();
+    const args = [
+        '--dangerously-skip-permissions',
+        // `-p` takes a SINGLE operand — the whole prompt. Splitting on whitespace
+        // (the old `...command.trim().split(/\s+/)`) shattered multi-word prompts
+        // into stray positionals and lost quoting/whitespace. Pass it intact.
+        '-p',
+        command.trim(),
+        '--output-format', 'stream-json',
+        '--verbose',
+    ];
+    let child;
+    try {
+        // Windows: `claude` is `claude.cmd`; spawnCli routes through cross-spawn so
+        // the shim resolves and multi-line args survive (raw `spawn(shell:false)`
+        // threw ENOENT/EINVAL on Windows even with claude installed).
+        child = (0, win_spawn_1.spawnCli)('claude', args, {
+            env: process.env,
+            shell: false,
+        });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            (0, output_1.cliError)('claude binary not found');
+        }
+        else {
+            (0, output_1.cliError)(`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 === 'assistant') {
+            // Real claude emits assistant text as `type:'assistant'` with
+            // `message.content[]` `{type:'text', text}` blocks (mirror
+            // parseClaudeStreamLine). The legacy `type:'text'`/`content` shape is
+            // kept as a fallback for older/synthetic streams.
+            const msg = parsed.message;
+            const text = (msg?.content ?? [])
+                .filter((b) => b.type === 'text')
+                .map((b) => b.text ?? '')
+                .join('');
+            if (text)
+                process.stdout.write(`${text}\n`);
+        }
+        else if (parsed.type === 'text') {
+            const content = parsed.content ?? '';
+            if (content)
+                process.stdout.write(`${content}\n`);
+        }
+        else if (parsed.type === 'result') {
+            resultData = parsed;
+            // The `result` event also carries the final answer text on `result`.
+            if (resultData.result)
+                process.stdout.write(`${resultData.result}\n`);
+        }
+        // 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') {
+                (0, output_1.cliError)('claude binary not found');
+            }
+            else {
+                (0, output_1.cliError)(`claude process error: ${err.message}`);
+            }
+            resolve(1);
+        });
+    });
+    const durationMs = Date.now() - startTime;
+    let costUsd;
+    let totalTokens;
+    if (resultData) {
+        if (resultData.total_cost_usd != null)
+            costUsd = resultData.total_cost_usd;
+        const usage = resultData.usage;
+        const tokensIn = usage?.input_tokens ?? 0;
+        const tokensOut = usage?.output_tokens ?? 0;
+        if (usage?.input_tokens != null || usage?.output_tokens != null) {
+            totalTokens = tokensIn + tokensOut;
+        }
+    }
+    (0, output_1.printSummary)({ durationMs, costUsd, totalTokens, exitCode });
+    return exitCode;
+}