specrails-desktop 2.0.0

package/server/dist/mobile/mobile-ws.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileWsBridge = void 0;
+const mobile_event_bus_1 = require("./mobile-event-bus");
+const mobile_redact_1 = require("./mobile-redact");
+// The gateway's WS fan-out. Subscribes ONCE to the in-process event bus and
+// pushes a mobile-shaped, redacted, per-subscription-filtered stream to each
+// attached socket. The raw /ws firehose (stream-json payloads, 256 KB
+// scrollbacks) is never forwarded verbatim.
+const OPEN = 1;
+const INBOUND_MAX_BYTES = 4096;
+const INBOUND_MAX_PER_MIN = 30;
+const HEARTBEAT_MS = 30_000;
+const LOG_FLUSH_MS = 250;
+const LOG_LINE_MAX = 2048;
+const LOG_BATCH_MAX = 60;
+function topicFor(type) {
+    switch (type) {
+        case 'queue': return 'queue';
+        case 'phase': return 'phase';
+        case 'ticket_created':
+        case 'ticket_updated':
+        case 'ticket_deleted':
+        case 'spec_gen_stream':
+        case 'spec_gen_done':
+        case 'spec_gen_error': return 'tickets';
+        case 'rail.job_started':
+        case 'rail.job_stopped':
+        case 'rail.job_completed':
+        case 'rail.updated': return 'rails';
+        case 'spending.invalidated': return 'spending';
+        case 'chat_stream':
+        case 'chat_done':
+        case 'chat_error':
+        case 'chat_title_update':
+        case 'chat_command_proposal':
+        case 'spec_draft.update': return 'chat';
+        case 'cost_alert':
+        case 'daily_budget_exceeded':
+        case 'desktop_daily_budget_exceeded': return 'alerts';
+        case 'log':
+        case 'event': return 'jobtail';
+        case 'desktop.projects':
+        case 'desktop.project_added':
+        case 'desktop.project_removed': return 'hub'; // mobile-app v1 wire compat — topic name frozen
+        default: return null;
+    }
+}
+// ─── Mobile wire compat ───────────────────────────────────────────────────────
+// mobile-app v1 wire compat — do not rename: the phone app (v1.0.0, in App
+// Review) matches these exact legacy `type` strings (and the legacy budget
+// payload field names). The internal broadcast types were renamed `desktop.*`
+// in the Specrails Desktop rebrand; this outbound boundary translates them
+// back before anything reaches a mobile socket.
+const LEGACY_WIRE_TYPES = {
+    'desktop.projects': 'hub.projects',
+    'desktop.project_added': 'hub.project_added',
+    'desktop.project_removed': 'hub.project_removed',
+    desktop_daily_budget_exceeded: 'hub_daily_budget_exceeded',
+};
+function toMobileWire(msg) {
+    const legacyType = LEGACY_WIRE_TYPES[msg.type];
+    if (!legacyType)
+        return msg;
+    const out = { ...msg, type: legacyType };
+    if (msg.type === 'desktop_daily_budget_exceeded') {
+        // mobile-app v1 wire compat — restore the legacy payload field names.
+        if ('desktopDailySpend' in out) {
+            out.hubDailySpend = out.desktopDailySpend;
+            delete out.desktopDailySpend;
+        }
+        if ('desktopBudget' in out) {
+            out.hubBudget = out.desktopBudget;
+            delete out.desktopBudget;
+        }
+    }
+    return out;
+}
+class MobileWsBridge {
+    _socks = new Set();
+    _unsub = null;
+    _flush = null;
+    _hb = null;
+    _clock;
+    constructor(opts = {}) {
+        this._clock = opts.clock ?? (() => Date.now());
+    }
+    start() {
+        if (this._unsub)
+            return;
+        this._unsub = (0, mobile_event_bus_1.getMobileEventBus)().onMessage((msg) => this.dispatch(msg));
+        this._flush = setInterval(() => this.flushLogs(), LOG_FLUSH_MS);
+        this._hb = setInterval(() => this.heartbeat(), HEARTBEAT_MS);
+        // Don't keep the event loop alive purely for these timers.
+        this._flush.unref?.();
+        this._hb.unref?.();
+    }
+    stop() {
+        if (this._unsub) {
+            this._unsub();
+            this._unsub = null;
+        }
+        if (this._flush) {
+            clearInterval(this._flush);
+            this._flush = null;
+        }
+        if (this._hb) {
+            clearInterval(this._hb);
+            this._hb = null;
+        }
+        for (const s of this._socks) {
+            try {
+                s.ws.close(1001, 'gateway stopping');
+            }
+            catch { /* ignore */ }
+        }
+        this._socks.clear();
+    }
+    get socketCount() {
+        return this._socks.size;
+    }
+    /** Register a freshly-upgraded socket for an authenticated device. */
+    attach(ws, deviceId) {
+        const state = {
+            ws, deviceId,
+            projects: new Set(), topics: new Set(), watchedJob: null,
+            inbound: [], alive: true,
+            logBuf: new Map(), logDropped: new Map(),
+        };
+        this._socks.add(state);
+        ws.on('message', (...args) => this.onInbound(state, args[0]));
+        ws.on('pong', () => { state.alive = true; });
+        ws.on('close', () => { this._socks.delete(state); });
+        ws.on('error', () => { this._socks.delete(state); });
+    }
+    /** Close every socket belonging to a (just-revoked) device. */
+    closeForDevice(deviceId) {
+        for (const s of this._socks) {
+            if (s.deviceId === deviceId) {
+                try {
+                    s.ws.close(4401, 'revoked');
+                }
+                catch { /* ignore */ }
+                this._socks.delete(s);
+            }
+        }
+    }
+    onInbound(state, raw) {
+        const text = typeof raw === 'string' ? raw : Buffer.isBuffer(raw) ? raw.toString('utf8') : '';
+        if (Buffer.byteLength(text) > INBOUND_MAX_BYTES) {
+            try {
+                state.ws.close(1009, 'message too large');
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        const now = this._clock();
+        state.inbound = state.inbound.filter((t) => now - t < 60_000);
+        state.inbound.push(now);
+        if (state.inbound.length > INBOUND_MAX_PER_MIN) {
+            try {
+                state.ws.close(1008, 'rate limit');
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        let msg;
+        try {
+            msg = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        switch (msg.type) {
+            case 'subscribe': {
+                const projects = Array.isArray(msg.projects) ? msg.projects.filter((x) => typeof x === 'string') : [];
+                const topics = Array.isArray(msg.topics) ? msg.topics.filter((x) => typeof x === 'string') : [];
+                state.projects = new Set(projects);
+                state.topics = new Set(topics);
+                break;
+            }
+            case 'watch_job': {
+                if (typeof msg.projectId === 'string' && typeof msg.jobId === 'string') {
+                    state.watchedJob = { projectId: msg.projectId, jobId: msg.jobId };
+                }
+                break;
+            }
+            case 'unwatch_job':
+                state.watchedJob = null;
+                break;
+        }
+    }
+    /** Fan a single bus message out to matching sockets. */
+    dispatch(msg) {
+        const topic = topicFor(msg.type);
+        if (!topic)
+            return;
+        for (const s of this._socks) {
+            if (topic === 'hub') {
+                // App-level (project registry): always forward, but translate to the
+                // legacy mobile wire types and redact (the projects payload carries `path`).
+                this.send(s, (0, mobile_redact_1.redact)(toMobileWire(msg)));
+                continue;
+            }
+            const projectId = msg.projectId;
+            if (!projectId || !s.projects.has(projectId))
+                continue;
+            if (topic === 'jobtail') {
+                if (!s.watchedJob || s.watchedJob.projectId !== projectId)
+                    continue;
+                const jobId = msg.jobId
+                    ?? msg.processId;
+                if (jobId !== s.watchedJob.jobId)
+                    continue;
+                if (msg.type === 'log') {
+                    this.bufferLog(s, s.watchedJob.jobId, msg.line);
+                }
+                else if (msg.type === 'event') {
+                    this.send(s, { type: 'job_event', projectId, jobId, eventType: msg.event_type });
+                }
+                continue;
+            }
+            if (s.topics.has(topic)) {
+                this.send(s, (0, mobile_redact_1.redact)(toMobileWire(msg)));
+            }
+        }
+    }
+    bufferLog(s, jobId, line) {
+        const buf = s.logBuf.get(jobId) ?? [];
+        if (buf.length >= LOG_BATCH_MAX) {
+            s.logDropped.set(jobId, (s.logDropped.get(jobId) ?? 0) + 1);
+            return;
+        }
+        buf.push(line.length > LOG_LINE_MAX ? line.slice(0, LOG_LINE_MAX) + '…' : line);
+        s.logBuf.set(jobId, buf);
+    }
+    flushLogs() {
+        for (const s of this._socks) {
+            for (const [jobId, lines] of s.logBuf) {
+                if (lines.length === 0)
+                    continue;
+                const dropped = s.logDropped.get(jobId) ?? 0;
+                this.send(s, { type: 'log_batch', jobId, lines, dropped });
+            }
+            s.logBuf.clear();
+            s.logDropped.clear();
+        }
+    }
+    heartbeat() {
+        for (const s of this._socks) {
+            if (!s.alive) {
+                try {
+                    s.ws.terminate();
+                }
+                catch { /* ignore */ }
+                this._socks.delete(s);
+                continue;
+            }
+            s.alive = false;
+            try {
+                s.ws.ping();
+            }
+            catch { /* ignore */ }
+        }
+    }
+    send(s, obj) {
+        if (s.ws.readyState !== OPEN)
+            return;
+        try {
+            s.ws.send(JSON.stringify(obj));
+        }
+        catch { /* ignore */ }
+    }
+}
+exports.MobileWsBridge = MobileWsBridge;

package/server/dist/path-resolver.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBundledRuntimePath = resolveBundledRuntimePath;
+exports.resolveStartupPath = resolveStartupPath;
+exports.parseLoginShellOutput = parseLoginShellOutput;
+exports.augmentPathFromLoginShell = augmentPathFromLoginShell;
+exports.getPathDiagnostic = getPathDiagnostic;
+exports.__resetPathResolverForTest = __resetPathResolverForTest;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const PATH_BEGIN = '__SRH_PATH_BEGIN__';
+const PATH_END = '__SRH_PATH_END__';
+const LOGIN_SHELL_TIMEOUT_MS = 1500;
+let diagnostic = {
+    pathSegments: [],
+    pathSources: [],
+    loginShellStatus: 'skipped',
+};
+let warnedLoginShell = false;
+/**
+ * True once `resolveStartupPath()` has actually prepended at least one bundled
+ * runtime dir that exists on disk. Gates the login-shell no-op: when a desktop
+ * build ships no runtimes (e.g. Windows ARM64, or a partial CI extraction) the
+ * bundle is NOT active, so we fall back to system discovery + login-shell
+ * augmentation instead of going dark.
+ */
+let bundledRuntimesActive = false;
+function fileExists(p) {
+    try {
+        return fs_1.default.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the bin directory for each bundled tool family from the actual binary
+ * FILE (not just the directory), returning the dir to prepend or `null`. Keeping
+ * this file-level and symmetric with setup-prerequisites means "bundle active"
+ * means the same thing in both modules.
+ */
+function resolveBundledBinDirs(runtimesPath) {
+    const isWin = process.platform === 'win32';
+    const nodeBinDir = isWin
+        ? (fileExists(path_1.default.join(runtimesPath, 'node', 'node.exe')) ? path_1.default.join(runtimesPath, 'node') : null)
+        : (fileExists(path_1.default.join(runtimesPath, 'node', 'bin', 'node')) ? path_1.default.join(runtimesPath, 'node', 'bin') : null);
+    let gitBinDir = null;
+    if (isWin) {
+        // PortableGit ships the real binary at git/cmd/git.exe with a redirector at git/bin/git.exe.
+        if (fileExists(path_1.default.join(runtimesPath, 'git', 'cmd', 'git.exe')))
+            gitBinDir = path_1.default.join(runtimesPath, 'git', 'cmd');
+        else if (fileExists(path_1.default.join(runtimesPath, 'git', 'bin', 'git.exe')))
+            gitBinDir = path_1.default.join(runtimesPath, 'git', 'bin');
+    }
+    else if (fileExists(path_1.default.join(runtimesPath, 'git', 'bin', 'git'))) {
+        gitBinDir = path_1.default.join(runtimesPath, 'git', 'bin');
+    }
+    return { nodeBinDir, gitBinDir };
+}
+function getDelimiter() {
+    return process.platform === 'win32' ? ';' : ':';
+}
+function splitPath(value) {
+    if (!value)
+        return [];
+    return value.split(getDelimiter()).filter((s) => s.length > 0);
+}
+function joinPath(segments) {
+    return segments.join(getDelimiter());
+}
+function fastPathDirectories() {
+    if (process.platform === 'darwin') {
+        return ['/opt/homebrew/bin', '/opt/homebrew/sbin', '/usr/local/bin', '/usr/local/sbin'];
+    }
+    if (process.platform === 'linux') {
+        return ['/usr/local/bin', '/usr/local/sbin', path_1.default.join(os_1.default.homedir(), '.local/bin')];
+    }
+    return [];
+}
+/**
+ * Returns the absolute path to the bundled runtimes directory.
+ * Only valid when SPECRAILS_IS_DESKTOP=1 and SPECRAILS_BUNDLED_RUNTIMES_PATH is set.
+ * Throws if the env var is missing.
+ */
+function resolveBundledRuntimePath() {
+    const p = process.env.SPECRAILS_BUNDLED_RUNTIMES_PATH;
+    if (!p) {
+        throw new Error('[path-resolver] resolveBundledRuntimePath() called but SPECRAILS_BUNDLED_RUNTIMES_PATH is not set');
+    }
+    return p;
+}
+/**
+ * Synchronously prepend well-known package-manager bin directories to
+ * `process.env.PATH` if they are missing. No-op on Windows.
+ *
+ * Records the resulting segments and their sources for diagnostic reporting.
+ */
+function resolveStartupPath() {
+    // Desktop mode: bundled runtimes win when present. We existence-gate every
+    // candidate dir so a runtimes-less or partially-extracted build degrades to
+    // normal system PATH discovery instead of prepending dead dirs and disabling
+    // all fallback (which would dead-end Add Project with "corrupted-bundle").
+    if (process.env.SPECRAILS_IS_DESKTOP === '1') {
+        const runtimesPath = process.env.SPECRAILS_BUNDLED_RUNTIMES_PATH;
+        if (runtimesPath) {
+            const { nodeBinDir, gitBinDir } = resolveBundledBinDirs(runtimesPath);
+            // Activate the bundle only when BOTH node and git are present. A partial
+            // bundle (one tool present, the other missing — a botched extraction) is
+            // treated as NOT active so the full system fallback (fast-path + login-shell)
+            // runs for every tool. Otherwise the missing tool would fall through to a
+            // system probe against an un-augmented PATH and be wrongly reported missing.
+            if (nodeBinDir && gitBinDir) {
+                const inherited = splitPath(process.env.PATH);
+                const inheritedSet = new Set(inherited);
+                const toAdd = [nodeBinDir, gitBinDir].filter((d) => !inheritedSet.has(d));
+                const merged = [...toAdd, ...inherited];
+                process.env.PATH = joinPath(merged);
+                bundledRuntimesActive = true;
+                diagnostic = {
+                    pathSegments: merged,
+                    pathSources: [
+                        ...toAdd.map(() => 'bundled'),
+                        ...inherited.map(() => 'inherited'),
+                    ],
+                    loginShellStatus: 'skipped',
+                };
+                return;
+            }
+            // Bundle absent or incomplete → fall through to system PATH discovery below
+            // so system node/git still resolve (graceful fallback).
+        }
+        // No runtimes path, or no/partial bundle present: fall through (do NOT return).
+    }
+    const inherited = splitPath(process.env.PATH);
+    const inheritedSet = new Set(inherited);
+    if (process.platform === 'win32') {
+        diagnostic = {
+            pathSegments: inherited,
+            pathSources: inherited.map(() => 'inherited'),
+            loginShellStatus: 'skipped',
+        };
+        return;
+    }
+    const toPrepend = [];
+    for (const dir of fastPathDirectories()) {
+        if (!inheritedSet.has(dir)) {
+            toPrepend.push(dir);
+            inheritedSet.add(dir);
+        }
+    }
+    const merged = [...toPrepend, ...inherited];
+    process.env.PATH = joinPath(merged);
+    diagnostic = {
+        pathSegments: merged,
+        pathSources: [
+            ...toPrepend.map(() => 'fast-path'),
+            ...inherited.map(() => 'inherited'),
+        ],
+        loginShellStatus: 'skipped',
+    };
+}
+/**
+ * Parse stdout from the login-shell probe. Returns the PATH between sentinel
+ * markers, or `null` if the markers are not present.
+ */
+function parseLoginShellOutput(stdout) {
+    const begin = stdout.indexOf(PATH_BEGIN);
+    if (begin === -1)
+        return null;
+    const start = begin + PATH_BEGIN.length;
+    const end = stdout.indexOf(PATH_END, start);
+    if (end === -1)
+        return null;
+    return stdout.slice(start, end);
+}
+/**
+ * Spawn the user's login shell once and merge any additional PATH segments
+ * it exposes (Volta/nvm/fnm/asdf shims) into `process.env.PATH`. Async,
+ * fire-and-forget — must not block startup.
+ *
+ * No-op on Windows and in test environments.
+ */
+async function augmentPathFromLoginShell(opts = {}) {
+    if (process.platform === 'win32') {
+        diagnostic.loginShellStatus = 'skipped';
+        return;
+    }
+    if (process.env.NODE_ENV === 'test' || process.env.VITEST === 'true') {
+        diagnostic.loginShellStatus = 'skipped';
+        return;
+    }
+    // Desktop mode WITH an active bundle: login-shell augmentation must never run
+    // — it could prepend system node/git dirs ahead of bundled ones. But when the
+    // bundle is absent (runtimes-less build → system fallback), we DO want
+    // login-shell augmentation so nvm/volta/fnm shims are discovered.
+    if (process.env.SPECRAILS_IS_DESKTOP === '1' && bundledRuntimesActive) {
+        diagnostic.loginShellStatus = 'skipped';
+        return;
+    }
+    const spawnFn = opts.spawnFn ?? child_process_1.spawn;
+    const timeoutMs = opts.timeoutMs ?? LOGIN_SHELL_TIMEOUT_MS;
+    const shell = process.env.SHELL || '/bin/sh';
+    const command = `printf "${PATH_BEGIN}%s${PATH_END}" "$PATH"`;
+    const status = await new Promise((resolve) => {
+        let child;
+        try {
+            child = spawnFn(shell, ['-l', '-i', '-c', command], { stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch {
+            resolve('error');
+            return;
+        }
+        let stdout = '';
+        let timedOut = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* ignore */ }
+        }, timeoutMs);
+        child.stdout?.on('data', (chunk) => { stdout += chunk.toString('utf-8'); });
+        child.stderr?.on('data', () => { });
+        const finish = (s) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(s);
+        };
+        child.on('error', () => finish('error'));
+        child.on('close', (code) => {
+            if (timedOut) {
+                finish('timeout');
+                return;
+            }
+            if (code !== 0) {
+                finish('error');
+                return;
+            }
+            const parsed = parseLoginShellOutput(stdout);
+            if (parsed === null) {
+                finish('error');
+                return;
+            }
+            mergeLoginShellPath(parsed);
+            finish('ok');
+        });
+    });
+    diagnostic.loginShellStatus = status;
+    if (status !== 'ok' && !warnedLoginShell) {
+        warnedLoginShell = true;
+        console.warn(`[path-resolver] login-shell merge ${status}; using fast-path PATH only`);
+    }
+}
+function mergeLoginShellPath(rawPath) {
+    const current = splitPath(process.env.PATH);
+    const currentSet = new Set(current);
+    const incoming = splitPath(rawPath);
+    const additions = [];
+    for (const dir of incoming) {
+        if (!currentSet.has(dir)) {
+            additions.push(dir);
+            currentSet.add(dir);
+        }
+    }
+    if (additions.length === 0)
+        return;
+    const merged = [...additions, ...current];
+    process.env.PATH = joinPath(merged);
+    diagnostic = {
+        pathSegments: merged,
+        pathSources: [
+            ...additions.map(() => 'login-shell'),
+            ...diagnostic.pathSources,
+        ],
+        loginShellStatus: diagnostic.loginShellStatus,
+    };
+}
+function getPathDiagnostic() {
+    return {
+        pathSegments: [...diagnostic.pathSegments],
+        pathSources: [...diagnostic.pathSources],
+        loginShellStatus: diagnostic.loginShellStatus,
+    };
+}
+/** Test-only helper to reset module state. */
+function __resetPathResolverForTest() {
+    diagnostic = { pathSegments: [], pathSources: [], loginShellStatus: 'skipped' };
+    warnedLoginShell = false;
+    bundledRuntimesActive = false;
+}