specrails-desktop 2.0.0

package/server/dist/spec-draft-parser.js

@@ -0,0 +1,133 @@
+"use strict";
+// Parses ` ```spec-draft ` fenced JSON blocks emitted by Claude during an
+// Explore Spec conversation. Each block carries a partial structured draft
+// that the app merges into the per-conversation latest draft state and
+// broadcasts to clients. Blocks are stripped from the chat content before it
+// reaches the WS so the user never sees raw JSON.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpecDraftBlocks = parseSpecDraftBlocks;
+exports.mergeDraft = mergeDraft;
+exports.applyBlocks = applyBlocks;
+const VALID_PRIORITIES = new Set(['low', 'medium', 'high', 'critical']);
+const FENCE_RE = /```spec-draft\s*\n([\s\S]*?)\n```/g;
+function coerceStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = [];
+    for (const item of value) {
+        if (typeof item === 'string')
+            out.push(item);
+    }
+    return out;
+}
+function validateBlock(parsed) {
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const obj = parsed;
+    const partial = {};
+    if (typeof obj.title === 'string')
+        partial.title = obj.title;
+    if (typeof obj.description === 'string')
+        partial.description = obj.description;
+    const labels = coerceStringArray(obj.labels);
+    if (labels)
+        partial.labels = labels;
+    const ac = coerceStringArray(obj.acceptanceCriteria);
+    if (ac)
+        partial.acceptanceCriteria = ac;
+    if (typeof obj.priority === 'string' && VALID_PRIORITIES.has(obj.priority)) {
+        partial.priority = obj.priority;
+    }
+    const chips = coerceStringArray(obj.chips) ?? [];
+    const ready = obj.ready === true;
+    return { partial, ready, chips };
+}
+/**
+ * Scan `text` for `spec-draft` fenced blocks. Returns the text with each
+ * block (including its fences) stripped, plus every successfully-parsed
+ * block in the order they appeared. Malformed JSON / non-object payloads
+ * are silently dropped (their fenced span is still stripped) — the parser
+ * never throws.
+ */
+function parseSpecDraftBlocks(text) {
+    if (!text || !text.includes('```spec-draft')) {
+        return { stripped: text ?? '', blocks: [] };
+    }
+    const blocks = [];
+    let stripped = '';
+    let cursor = 0;
+    FENCE_RE.lastIndex = 0;
+    let match;
+    while ((match = FENCE_RE.exec(text)) !== null) {
+        stripped += text.slice(cursor, match.index);
+        cursor = match.index + match[0].length;
+        let parsed;
+        try {
+            parsed = JSON.parse(match[1]);
+        }
+        catch {
+            // malformed; drop silently but still strip the fence
+            continue;
+        }
+        const block = validateBlock(parsed);
+        if (block)
+            blocks.push(block);
+    }
+    stripped += text.slice(cursor);
+    return { stripped, blocks };
+}
+/**
+ * Shallow-merge a parsed block into a draft. Empty strings and undefined
+ * are no-ops. Arrays replace (caller controls authority). Returns a new
+ * draft object — never mutates `prev`.
+ */
+function mergeDraft(prev, next) {
+    const out = { ...prev };
+    if (typeof next.title === 'string' && next.title !== '')
+        out.title = next.title;
+    if (typeof next.description === 'string' && next.description !== '')
+        out.description = next.description;
+    if (Array.isArray(next.labels))
+        out.labels = next.labels.slice();
+    if (Array.isArray(next.acceptanceCriteria))
+        out.acceptanceCriteria = next.acceptanceCriteria.slice();
+    if (next.priority && VALID_PRIORITIES.has(next.priority))
+        out.priority = next.priority;
+    return out;
+}
+/** Apply every block from a parse result to a conversation's draft state. */
+function applyBlocks(prev, blocks) {
+    const baseDraft = prev?.draft ?? {};
+    if (blocks.length === 0) {
+        return prev ?? { draft: baseDraft, ready: false, chips: [], lastChangedFields: [] };
+    }
+    let nextDraft = baseDraft;
+    let ready = prev?.ready ?? false;
+    let chips = prev?.chips ?? [];
+    const changed = new Set();
+    for (const block of blocks) {
+        const before = nextDraft;
+        nextDraft = mergeDraft(before, block.partial);
+        for (const key of ['title', 'description', 'labels', 'priority', 'acceptanceCriteria']) {
+            if (!shallowEqual(before[key], nextDraft[key]))
+                changed.add(key);
+        }
+        ready = block.ready;
+        if (block.chips.length > 0)
+            chips = block.chips.slice(0, 3);
+    }
+    return { draft: nextDraft, ready, chips, lastChangedFields: Array.from(changed) };
+}
+function shallowEqual(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+    return false;
+}

package/server/dist/spec-launcher-manager.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecLauncherManager = void 0;
+const readline_1 = require("readline");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const command_resolver_1 = require("./command-resolver");
+const cli_prompt_1 = require("./util/cli-prompt");
+// ─── SpecLauncherManager ──────────────────────────────────────────────────────
+class SpecLauncherManager {
+    _broadcast;
+    _cwd;
+    _activeProcesses;
+    _buffers;
+    constructor(broadcast, cwd) {
+        this._broadcast = broadcast;
+        this._cwd = cwd;
+        this._activeProcesses = new Map();
+        this._buffers = new Map();
+    }
+    isActive(launchId) {
+        return this._activeProcesses.has(launchId);
+    }
+    /**
+     * Tear down before the project is removed (M12). This manager holds no DB
+     * handle (its close handler only broadcasts), so it cannot crash the app — but
+     * an orphaned `/opsx:ff` child runs with --dangerously-skip-permissions against
+     * a removed project and keeps burning spend, so SIGTERM it. Idempotent.
+     */
+    shutdown() {
+        for (const child of this._activeProcesses.values()) {
+            if (child.pid) {
+                try {
+                    (0, tree_kill_1.default)(child.pid, 'SIGTERM');
+                }
+                catch { /* ignore */ }
+            }
+        }
+        this._activeProcesses.clear();
+        this._buffers.clear();
+    }
+    async launch(launchId, description) {
+        const rawCommand = `/opsx:ff ${description}`;
+        const prompt = (0, command_resolver_1.resolveCommand)(rawCommand, this._cwd);
+        if (prompt === rawCommand) {
+            this._broadcastError(launchId, 'This project does not have the /opsx:ff command installed. Run "npx specrails-core@latest" to install it.');
+            return;
+        }
+        const args = [
+            '--dangerously-skip-permissions',
+            '--tools', 'default',
+            '--output-format', 'stream-json',
+            '--verbose',
+            '-p', prompt,
+        ];
+        // spawnClaude reroutes multi-line argv values through stdin on Windows.
+        const child = (0, cli_prompt_1.spawnClaude)(args, {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: this._cwd,
+        });
+        this._activeProcesses.set(launchId, child);
+        this._buffers.set(launchId, '');
+        // Surface ENOENT (e.g. claude not on PATH) instead of crashing the app.
+        /* c8 ignore start -- spawn-failure path; exercised manually, not in CI */
+        child.on('error', (err) => {
+            console.error(`[SpecLauncherManager] spawn failed for ${launchId}: ${err.message}`);
+            this._activeProcesses.delete(launchId);
+            this._buffers.delete(launchId);
+            this._broadcast({
+                type: 'spec_launcher_error',
+                projectId: '',
+                launchId,
+                error: `Failed to launch claude: ${err.message}`,
+                timestamp: new Date().toISOString(),
+            });
+        });
+        /* c8 ignore stop */
+        // Capture last change ID from output (opsx:ff usually prints the change name)
+        let detectedChangeId = null;
+        const stdoutReader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+        stdoutReader.on('line', (line) => {
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch { /* skip non-JSON */ }
+            if (!parsed)
+                return;
+            const eventType = parsed.type;
+            if (eventType === 'assistant') {
+                const msg = parsed.message;
+                const blocks = msg?.content ?? [];
+                const texts = blocks
+                    .filter((c) => c.type === 'text')
+                    .map((c) => c.text ?? '');
+                const newText = texts.join('');
+                if (newText) {
+                    // Try to detect change ID from output (look for "openspec/changes/<id>" pattern)
+                    const changeMatch = newText.match(/openspec\/changes\/([^\s/]+)/);
+                    if (changeMatch)
+                        detectedChangeId = changeMatch[1];
+                    const prev = this._buffers.get(launchId) ?? '';
+                    this._buffers.set(launchId, prev + newText);
+                    this._broadcast({
+                        type: 'spec_launcher_stream',
+                        projectId: '',
+                        launchId,
+                        delta: newText,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                for (const block of blocks) {
+                    if (block.type === 'tool_use' && block.name) {
+                        this._broadcast({
+                            type: 'spec_launcher_stream',
+                            projectId: '',
+                            launchId,
+                            delta: `<!--tool:${block.name}-->`,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+        });
+        return new Promise((resolve) => {
+            child.on('close', (code) => {
+                const fullText = this._buffers.get(launchId) ?? '';
+                this._activeProcesses.delete(launchId);
+                this._buffers.delete(launchId);
+                if (code === 0) {
+                    // Also try to extract change ID from full text
+                    if (!detectedChangeId) {
+                        const match = fullText.match(/openspec\/changes\/([^\s/]+)/);
+                        if (match)
+                            detectedChangeId = match[1];
+                    }
+                    this._broadcast({
+                        type: 'spec_launcher_done',
+                        projectId: '',
+                        launchId,
+                        changeId: detectedChangeId,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                else {
+                    this._broadcastError(launchId, 'Spec generation failed');
+                }
+                resolve();
+            });
+        });
+    }
+    cancel(launchId) {
+        const child = this._activeProcesses.get(launchId);
+        if (child?.pid) {
+            (0, tree_kill_1.default)(child.pid, 'SIGTERM');
+        }
+        this._activeProcesses.delete(launchId);
+        this._buffers.delete(launchId);
+        this._broadcastError(launchId, 'cancelled');
+    }
+    _broadcastError(launchId, error) {
+        this._broadcast({
+            type: 'spec_launcher_error',
+            projectId: '',
+            launchId,
+            error,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
+exports.SpecLauncherManager = SpecLauncherManager;

package/server/dist/spec-models.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_DEFAULT_MODEL = exports.CODEX_MODELS = exports.CLAUDE_MODELS = void 0;
+exports.getModelsForProvider = getModelsForProvider;
+exports.isValidModelForProvider = isValidModelForProvider;
+exports.getProviderDefault = getProviderDefault;
+exports.CLAUDE_MODELS = [
+    { value: 'sonnet', label: 'Claude Sonnet' },
+    { value: 'opus', label: 'Claude Opus' },
+    { value: 'haiku', label: 'Claude Haiku' },
+];
+exports.CODEX_MODELS = [
+    { value: 'gpt-5.5', label: 'GPT-5.5' },
+    { value: 'gpt-5.4', label: 'GPT-5.4' },
+    { value: 'gpt-5.4-mini', label: 'GPT-5.4 Mini' },
+    { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
+];
+exports.PROVIDER_DEFAULT_MODEL = {
+    claude: 'sonnet',
+    codex: 'gpt-5.5',
+};
+function getModelsForProvider(provider) {
+    return provider === 'codex' ? exports.CODEX_MODELS : exports.CLAUDE_MODELS;
+}
+function isValidModelForProvider(model, provider) {
+    if (typeof model !== 'string' || model.length === 0)
+        return false;
+    return getModelsForProvider(provider).some((m) => m.value === model);
+}
+function getProviderDefault(provider) {
+    return exports.PROVIDER_DEFAULT_MODEL[provider];
+}

package/server/dist/specrails-tech-client.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * specrails-tech API v1 client.
+ *
+ * Typed HTTP client for the specrails-tech Rails application.
+ * Contract defined in docs/engineering/rfcs/RFC-002-specrails-tech-api-v1.md
+ *
+ * All methods return null on connection failure — callers receive a
+ * structured { connected: false } response rather than a thrown error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecrailsTechClient = void 0;
+exports.createSpecrailsTechClient = createSpecrailsTechClient;
+const DEFAULT_BASE_URL = 'http://localhost:3000';
+const REQUEST_TIMEOUT_MS = 5000;
+async function fetchJson(baseUrl, path) {
+    const url = `${baseUrl}${path}`;
+    let response;
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        response = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+    }
+    catch (err) {
+        const message = err instanceof Error && err.name === 'AbortError'
+            ? 'specrails-tech request timed out'
+            : 'specrails-tech is not running';
+        return { connected: false, error: message };
+    }
+    if (!response.ok) {
+        return {
+            connected: false,
+            error: `specrails-tech returned ${response.status}`,
+        };
+    }
+    try {
+        const data = (await response.json());
+        return { connected: true, data };
+    }
+    catch {
+        return { connected: false, error: 'specrails-tech returned invalid JSON' };
+    }
+}
+class SpecrailsTechClient {
+    baseUrl;
+    constructor(baseUrl = DEFAULT_BASE_URL) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    health() {
+        return fetchJson(this.baseUrl, '/api/v1/health');
+    }
+    async listAgents() {
+        const result = await fetchJson(this.baseUrl, '/api/v1/agents');
+        if (!result.connected)
+            return result;
+        return { connected: true, data: result.data.data };
+    }
+    async getAgent(slug) {
+        const result = await fetchJson(this.baseUrl, `/api/v1/agents/${encodeURIComponent(slug)}`);
+        if (!result.connected)
+            return result;
+        return { connected: true, data: result.data.data };
+    }
+    async listDocs() {
+        const result = await fetchJson(this.baseUrl, '/api/v1/docs');
+        if (!result.connected)
+            return result;
+        return { connected: true, data: result.data.data };
+    }
+    async getDoc(page) {
+        const result = await fetchJson(this.baseUrl, `/api/v1/docs/${encodeURIComponent(page)}`);
+        if (!result.connected)
+            return result;
+        return { connected: true, data: result.data.data };
+    }
+}
+exports.SpecrailsTechClient = SpecrailsTechClient;
+function createSpecrailsTechClient(baseUrl) {
+    const url = baseUrl ?? process.env.SPECRAILS_TECH_URL ?? DEFAULT_BASE_URL;
+    return new SpecrailsTechClient(url);
+}