specrails-desktop 2.0.0

package/server/dist/terminal-marks-store.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKS_PER_SESSION_CAP = void 0;
+exports.appendMark = appendMark;
+exports.listMarks = listMarks;
+exports.deleteForSession = deleteForSession;
+exports.pruneSessionFifo = pruneSessionFifo;
+exports.markOpenAsKilled = markOpenAsKilled;
+exports.getOpenMark = getOpenMark;
+exports.closeOpenMark = closeOpenMark;
+exports.getMark = getMark;
+exports.MARKS_PER_SESSION_CAP = 1000;
+function appendMark(db, input) {
+    const insert = db.prepare(`
+    INSERT INTO terminal_command_marks (session_id, started_at, finished_at, exit_code, command, cwd)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    const tx = db.transaction((row) => {
+        const result = insert.run(row.sessionId, row.startedAt, row.finishedAt ?? null, row.exitCode ?? null, row.command ?? null, row.cwd ?? null);
+        pruneSessionFifo(db, row.sessionId, exports.MARKS_PER_SESSION_CAP);
+        return result.lastInsertRowid;
+    });
+    const id = tx(input);
+    return {
+        id,
+        sessionId: input.sessionId,
+        startedAt: input.startedAt,
+        finishedAt: input.finishedAt ?? null,
+        exitCode: input.exitCode ?? null,
+        command: input.command ?? null,
+        cwd: input.cwd ?? null,
+    };
+}
+function rowToMark(r) {
+    return {
+        id: r.id,
+        sessionId: r.session_id,
+        startedAt: r.started_at,
+        finishedAt: r.finished_at,
+        exitCode: r.exit_code,
+        command: r.command,
+        cwd: r.cwd,
+    };
+}
+function listMarks(db, sessionId, opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 100, 1), 1000);
+    if (typeof opts.before === 'number') {
+        const rows = db.prepare(`
+      SELECT * FROM terminal_command_marks
+      WHERE session_id = ? AND started_at < ?
+      ORDER BY started_at DESC, id DESC LIMIT ?
+    `).all(sessionId, opts.before, limit);
+        return rows.map(rowToMark);
+    }
+    const rows = db.prepare(`
+    SELECT * FROM terminal_command_marks
+    WHERE session_id = ?
+    ORDER BY started_at DESC, id DESC LIMIT ?
+  `).all(sessionId, limit);
+    return rows.map(rowToMark);
+}
+function deleteForSession(db, sessionId) {
+    db.prepare('DELETE FROM terminal_command_marks WHERE session_id = ?').run(sessionId);
+}
+function pruneSessionFifo(db, sessionId, cap = exports.MARKS_PER_SESSION_CAP) {
+    const countRow = db.prepare('SELECT COUNT(*) AS c FROM terminal_command_marks WHERE session_id = ?').get(sessionId);
+    if (countRow.c <= cap)
+        return;
+    const excess = countRow.c - cap;
+    // Delete oldest excess rows for this session.
+    db.prepare(`
+    DELETE FROM terminal_command_marks
+    WHERE id IN (
+      SELECT id FROM terminal_command_marks
+      WHERE session_id = ?
+      ORDER BY started_at ASC, id ASC
+      LIMIT ?
+    )
+  `).run(sessionId, excess);
+}
+/**
+ * Mark all open (finished_at IS NULL) marks for a session as killed —
+ * called when the session exits without a clean post-exec.
+ */
+function markOpenAsKilled(db, sessionId, killedAt) {
+    const result = db.prepare(`
+    UPDATE terminal_command_marks
+    SET finished_at = ?, exit_code = NULL
+    WHERE session_id = ? AND finished_at IS NULL
+  `).run(killedAt, sessionId);
+    return result.changes;
+}
+function getOpenMark(db, sessionId) {
+    const row = db.prepare(`
+    SELECT * FROM terminal_command_marks
+    WHERE session_id = ? AND finished_at IS NULL
+    ORDER BY started_at DESC, id DESC LIMIT 1
+  `).get(sessionId);
+    return row ? rowToMark(row) : null;
+}
+function closeOpenMark(db, sessionId, finishedAt, exitCode, command, cwd) {
+    const open = getOpenMark(db, sessionId);
+    if (!open)
+        return null;
+    db.prepare(`
+    UPDATE terminal_command_marks
+    SET finished_at = ?, exit_code = ?,
+        command = COALESCE(?, command),
+        cwd     = COALESCE(?, cwd)
+    WHERE id = ?
+  `).run(finishedAt, exitCode, command ?? null, cwd ?? null, open.id);
+    return getMark(db, open.id);
+}
+function getMark(db, id) {
+    const row = db.prepare('SELECT * FROM terminal_command_marks WHERE id = ?').get(id);
+    return row ? rowToMark(row) : null;
+}

package/server/dist/terminal-osc-parser.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Streaming OSC sequence parser for shell-integration marks.
+ *
+ * Recognises:
+ *   ESC ] 133 ; A             ST   → prompt-start
+ *   ESC ] 133 ; B             ST   → prompt-end (input start)
+ *   ESC ] 133 ; C             ST   → pre-exec
+ *   ESC ] 133 ; D [; <code>]  ST   → post-exec (with optional exit code)
+ *   ESC ] 1337 ; CurrentDir=… ST   → cwd
+ *   ESC ] 1337 ; File=…       ST   → (observed but produces no mark; left for image addon)
+ *
+ * Where ESC = 0x1B, ST = either BEL (0x07) or ESC \ (0x1B 0x5C).
+ *
+ * Invariants:
+ *   - The byte stream is never modified. The parser is observe-only.
+ *   - Malformed or truncated sequences are tolerated; parser state is bounded.
+ *   - Sequence body length is capped (8 KB) to bound memory under adversarial input.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OscParser = void 0;
+const ESC = 0x1b;
+const BEL = 0x07;
+const BACKSLASH = 0x5c;
+const MAX_BODY_BYTES = 8 * 1024;
+class OscParser {
+    state = 'normal';
+    body = [];
+    reset() {
+        this.state = 'normal';
+        this.body = [];
+    }
+    feed(chunk) {
+        const out = [];
+        for (let i = 0; i < chunk.length; i++) {
+            const b = chunk[i];
+            switch (this.state) {
+                case 'normal':
+                    if (b === ESC)
+                        this.state = 'esc';
+                    break;
+                case 'esc':
+                    if (b === 0x5d /* ']' */) {
+                        this.state = 'osc-body';
+                        this.body = [];
+                    }
+                    else {
+                        this.state = 'normal';
+                    }
+                    break;
+                case 'osc-body':
+                    if (b === BEL) {
+                        this.flush(out);
+                        this.state = 'normal';
+                    }
+                    else if (b === ESC) {
+                        this.state = 'st-pending';
+                    }
+                    else {
+                        if (this.body.length < MAX_BODY_BYTES) {
+                            this.body.push(b);
+                        }
+                        else {
+                            // Body too large — discard sequence and reset.
+                            this.body = [];
+                            this.state = 'normal';
+                        }
+                    }
+                    break;
+                case 'st-pending':
+                    if (b === BACKSLASH) {
+                        this.flush(out);
+                        this.state = 'normal';
+                    }
+                    else if (b === ESC) {
+                        // Two ESCs in a row inside an OSC body — restart from this ESC.
+                        this.body = [];
+                        this.state = 'esc';
+                    }
+                    else {
+                        // Not a real ST. Append the previous ESC and this byte to the body.
+                        if (this.body.length + 2 <= MAX_BODY_BYTES) {
+                            this.body.push(ESC);
+                            this.body.push(b);
+                            this.state = 'osc-body';
+                        }
+                        else {
+                            this.body = [];
+                            this.state = 'normal';
+                        }
+                    }
+                    break;
+            }
+        }
+        return out;
+    }
+    flush(out) {
+        const ev = parseOscBody(this.body);
+        if (ev)
+            out.push(ev);
+        this.body = [];
+    }
+}
+exports.OscParser = OscParser;
+function bytesToString(bytes) {
+    // Fast ASCII path; OSC payloads are ASCII or UTF-8. Use TextDecoder for safety.
+    return new TextDecoder('utf-8', { fatal: false }).decode(Uint8Array.from(bytes));
+}
+function parseOscBody(bytes) {
+    if (bytes.length === 0)
+        return null;
+    // Find the first ';' separator. The code prefix before ';' tells us 133 vs 1337.
+    const semicolon = bytes.indexOf(0x3b /* ';' */);
+    if (semicolon === -1)
+        return null;
+    const codeStr = bytesToString(bytes.slice(0, semicolon));
+    const rest = bytesToString(bytes.slice(semicolon + 1));
+    if (codeStr === '133')
+        return parse133(rest);
+    if (codeStr === '1337')
+        return parse1337(rest);
+    return null;
+}
+function parse133(rest) {
+    if (rest.length === 0)
+        return null;
+    const subcode = rest[0];
+    switch (subcode) {
+        case 'A': return { kind: 'prompt-start' };
+        case 'B': return { kind: 'prompt-end' };
+        case 'C': return { kind: 'pre-exec' };
+        case 'D': {
+            const tail = rest.slice(1); // "" or ";<code>" or ";<code>;..."
+            if (tail.length === 0)
+                return { kind: 'post-exec' };
+            if (tail[0] !== ';')
+                return null;
+            const codeStr = tail.slice(1).split(';')[0];
+            if (codeStr.length === 0)
+                return { kind: 'post-exec' };
+            const n = Number(codeStr);
+            if (!Number.isFinite(n) || !Number.isInteger(n))
+                return { kind: 'post-exec' };
+            return { kind: 'post-exec', exitCode: n };
+        }
+        default: return null;
+    }
+}
+function parse1337(rest) {
+    // Only CurrentDir=… surfaces a mark; File=… is left for the image addon.
+    const eq = rest.indexOf('=');
+    if (eq === -1)
+        return null;
+    const key = rest.slice(0, eq);
+    const value = rest.slice(eq + 1);
+    if (key === 'CurrentDir')
+        return { kind: 'cwd', payload: value };
+    return null;
+}

package/server/dist/terminal-settings.js

@@ -0,0 +1,282 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalSettingsValidationError = exports.TERMINAL_DEFAULTS = exports.TERMINAL_SETTINGS_KEYS = void 0;
+exports.defaultQuickScript = defaultQuickScript;
+exports.validateField = validateField;
+exports.validatePartial = validatePartial;
+exports.getDesktopTerminalSettings = getDesktopTerminalSettings;
+exports.patchDesktopTerminalSettings = patchDesktopTerminalSettings;
+exports.getProjectOverride = getProjectOverride;
+exports.patchProjectOverride = patchProjectOverride;
+exports.resolveTerminalSettings = resolveTerminalSettings;
+const os_1 = __importDefault(require("os"));
+function defaultUsername() {
+    try {
+        return os_1.default.userInfo().username || 'friend';
+    }
+    catch {
+        return 'friend';
+    }
+}
+function defaultQuickScript() {
+    return `echo "Wake up, ${defaultUsername()} (edit this snippet in settings to help your local development)"`;
+}
+exports.TERMINAL_SETTINGS_KEYS = [
+    'fontFamily',
+    'fontSize',
+    'renderMode',
+    'copyOnSelect',
+    'shellIntegrationEnabled',
+    'notifyOnCompletion',
+    'imageRendering',
+    'longCommandThresholdMs',
+    'browserShortcutUrl',
+    'quickScript',
+];
+exports.TERMINAL_DEFAULTS = {
+    fontFamily: "'DM Mono', 'JetBrains Mono', ui-monospace, Menlo, monospace",
+    fontSize: 12,
+    renderMode: 'auto',
+    copyOnSelect: false,
+    shellIntegrationEnabled: true,
+    notifyOnCompletion: true,
+    imageRendering: true,
+    longCommandThresholdMs: 60_000,
+    browserShortcutUrl: 'https://specrails.dev',
+    quickScript: defaultQuickScript(),
+};
+const FONT_SIZE_MIN = 8;
+const FONT_SIZE_MAX = 32;
+const LONG_COMMAND_THRESHOLD_MIN_MS = 1_000;
+class TerminalSettingsValidationError extends Error {
+    field;
+    constructor(field, message) {
+        super(message);
+        this.field = field;
+        this.name = 'TerminalSettingsValidationError';
+    }
+}
+exports.TerminalSettingsValidationError = TerminalSettingsValidationError;
+// ─── Codec: TEXT row value ⇄ typed field ──────────────────────────────────────
+function encode(field, value) {
+    switch (field) {
+        case 'fontFamily':
+        case 'renderMode':
+        case 'browserShortcutUrl':
+        case 'quickScript':
+            if (typeof value !== 'string')
+                throw new TerminalSettingsValidationError(field, `${field} must be a string`);
+            return value;
+        case 'fontSize':
+        case 'longCommandThresholdMs':
+            if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value)) {
+                throw new TerminalSettingsValidationError(field, `${field} must be an integer`);
+            }
+            return String(value);
+        case 'copyOnSelect':
+        case 'shellIntegrationEnabled':
+        case 'notifyOnCompletion':
+        case 'imageRendering':
+            if (typeof value !== 'boolean')
+                throw new TerminalSettingsValidationError(field, `${field} must be a boolean`);
+            return value ? 'true' : 'false';
+    }
+}
+function decode(field, raw) {
+    switch (field) {
+        case 'fontFamily':
+        case 'browserShortcutUrl':
+        case 'quickScript':
+            return raw;
+        case 'renderMode': {
+            if (raw !== 'auto' && raw !== 'canvas' && raw !== 'webgl') {
+                return exports.TERMINAL_DEFAULTS.renderMode;
+            }
+            return raw;
+        }
+        case 'fontSize':
+        case 'longCommandThresholdMs': {
+            const n = Number(raw);
+            return (Number.isFinite(n) && Number.isInteger(n)
+                ? n
+                : exports.TERMINAL_DEFAULTS[field]);
+        }
+        case 'copyOnSelect':
+        case 'shellIntegrationEnabled':
+        case 'notifyOnCompletion':
+        case 'imageRendering':
+            return (raw === 'true');
+    }
+    // Unreachable; satisfies TS.
+    return exports.TERMINAL_DEFAULTS[field];
+}
+// ─── Validation (apply BEFORE encode) ─────────────────────────────────────────
+function validateField(field, value) {
+    switch (field) {
+        case 'fontFamily': {
+            const v = value;
+            if (typeof v !== 'string' || v.trim().length === 0) {
+                throw new TerminalSettingsValidationError(field, 'fontFamily must be a non-empty string');
+            }
+            return;
+        }
+        case 'fontSize': {
+            const n = value;
+            if (typeof n !== 'number' || !Number.isInteger(n) || n < FONT_SIZE_MIN || n > FONT_SIZE_MAX) {
+                throw new TerminalSettingsValidationError(field, `fontSize must be an integer in [${FONT_SIZE_MIN}, ${FONT_SIZE_MAX}]`);
+            }
+            return;
+        }
+        case 'renderMode': {
+            const v = value;
+            if (v !== 'auto' && v !== 'canvas' && v !== 'webgl') {
+                throw new TerminalSettingsValidationError(field, 'renderMode must be one of "auto", "canvas", "webgl"');
+            }
+            return;
+        }
+        case 'copyOnSelect':
+        case 'shellIntegrationEnabled':
+        case 'notifyOnCompletion':
+        case 'imageRendering': {
+            if (typeof value !== 'boolean') {
+                throw new TerminalSettingsValidationError(field, `${field} must be a boolean`);
+            }
+            return;
+        }
+        case 'longCommandThresholdMs': {
+            const n = value;
+            if (typeof n !== 'number' || !Number.isInteger(n) || n < LONG_COMMAND_THRESHOLD_MIN_MS) {
+                throw new TerminalSettingsValidationError(field, `longCommandThresholdMs must be an integer ≥ ${LONG_COMMAND_THRESHOLD_MIN_MS}`);
+            }
+            return;
+        }
+        case 'browserShortcutUrl': {
+            const v = value;
+            if (typeof v !== 'string' || v.trim().length === 0) {
+                throw new TerminalSettingsValidationError(field, 'browserShortcutUrl must be a non-empty string');
+            }
+            // Allow http(s) URLs only — no file://, no javascript:, etc.
+            if (!/^https?:\/\//i.test(v.trim())) {
+                throw new TerminalSettingsValidationError(field, 'browserShortcutUrl must start with http:// or https://');
+            }
+            return;
+        }
+        case 'quickScript': {
+            const v = value;
+            if (typeof v !== 'string') {
+                throw new TerminalSettingsValidationError(field, 'quickScript must be a string');
+            }
+            // Empty strings allowed (user disabling the shortcut). Cap to avoid abuse.
+            if (v.length > 8192) {
+                throw new TerminalSettingsValidationError(field, 'quickScript exceeds 8KB cap');
+            }
+            return;
+        }
+    }
+}
+function validatePartial(patch) {
+    const out = {};
+    for (const key of Object.keys(patch)) {
+        if (!exports.TERMINAL_SETTINGS_KEYS.includes(key)) {
+            throw new TerminalSettingsValidationError(key, `unknown setting: ${key}`);
+        }
+        const field = key;
+        const value = patch[key];
+        if (value === null)
+            continue; // null = clear (override layer); not validated here
+        validateField(field, value);
+        out[field] = value;
+    }
+    return out;
+}
+// ─── App-level access (desktop.sqlite, table: desktop_settings) ───────────────────────
+const DESKTOP_KEY_PREFIX = 'terminal.';
+function desktopKey(field) {
+    return `${DESKTOP_KEY_PREFIX}${field}`;
+}
+function getDesktopTerminalSettings(desktopDb) {
+    const rows = desktopDb
+        .prepare('SELECT key, value FROM desktop_settings WHERE key LIKE ?')
+        .all(`${DESKTOP_KEY_PREFIX}%`);
+    const map = new Map(rows.map((r) => [r.key, r.value]));
+    const out = {};
+    for (const field of exports.TERMINAL_SETTINGS_KEYS) {
+        const raw = map.get(desktopKey(field));
+        out[field] = (raw !== undefined ? decode(field, raw) : exports.TERMINAL_DEFAULTS[field]);
+    }
+    return out;
+}
+function patchDesktopTerminalSettings(desktopDb, patch) {
+    const valid = validatePartial(patch);
+    const upsert = desktopDb.prepare('INSERT OR REPLACE INTO desktop_settings (key, value) VALUES (?, ?)');
+    const tx = desktopDb.transaction((entries) => {
+        for (const [k, v] of entries)
+            upsert.run(k, v);
+    });
+    const entries = [];
+    for (const field of Object.keys(valid)) {
+        entries.push([desktopKey(field), encode(field, valid[field])]);
+    }
+    if (entries.length > 0)
+        tx(entries);
+    return getDesktopTerminalSettings(desktopDb);
+}
+// ─── Per-project override (jobs.sqlite, table: terminal_settings_override) ────
+function getProjectOverride(projectDb) {
+    const rows = projectDb
+        .prepare('SELECT key, value FROM terminal_settings_override WHERE key LIKE ?')
+        .all(`${DESKTOP_KEY_PREFIX}%`);
+    const out = {};
+    for (const r of rows) {
+        const field = r.key.slice(DESKTOP_KEY_PREFIX.length);
+        if (!exports.TERMINAL_SETTINGS_KEYS.includes(field))
+            continue;
+        out[field] = decode(field, r.value);
+    }
+    return out;
+}
+function patchProjectOverride(projectDb, patch) {
+    // Validate non-null entries; null entries are deletes and don't go through validateField.
+    const setEntries = [];
+    const deleteKeys = [];
+    for (const key of Object.keys(patch)) {
+        if (!exports.TERMINAL_SETTINGS_KEYS.includes(key)) {
+            throw new TerminalSettingsValidationError(key, `unknown setting: ${key}`);
+        }
+        const field = key;
+        const value = patch[key];
+        if (value === null) {
+            deleteKeys.push(desktopKey(field));
+            continue;
+        }
+        validateField(field, value);
+        setEntries.push([desktopKey(field), encode(field, value)]);
+    }
+    const upsert = projectDb.prepare('INSERT OR REPLACE INTO terminal_settings_override (key, value) VALUES (?, ?)');
+    const del = projectDb.prepare('DELETE FROM terminal_settings_override WHERE key = ?');
+    const tx = projectDb.transaction(() => {
+        for (const [k, v] of setEntries)
+            upsert.run(k, v);
+        for (const k of deleteKeys)
+            del.run(k);
+    });
+    tx();
+    return getProjectOverride(projectDb);
+}
+// ─── Resolution: project override → app default → built-in ────────────────────
+function resolveTerminalSettings(desktopDb, projectDb) {
+    const desktop = getDesktopTerminalSettings(desktopDb);
+    if (!projectDb)
+        return desktop;
+    const override = getProjectOverride(projectDb);
+    const out = { ...desktop };
+    for (const field of Object.keys(override)) {
+        const v = override[field];
+        if (v !== undefined)
+            out[field] = v;
+    }
+    return out;
+}