specrails-desktop 2.0.0

package/server/dist/providers/codex-adapter.js

@@ -0,0 +1,264 @@
+"use strict";
+// Codex (OpenAI) adapter for codex CLI 0.128.0+.
+//
+// Stream format observed live (2026-05-17):
+//   {"type":"thread.started","thread_id":"<UUID>"}
+//   {"type":"turn.started"}
+//   {"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"..."}}
+//   {"type":"item.completed","item":{"id":"item_1","type":"function_call",
+//     "name":"shell","arguments":"..."}}
+//   {"type":"turn.completed","usage":{"input_tokens":N,"cached_input_tokens":N,
+//     "output_tokens":N,"reasoning_output_tokens":N}}
+//
+// Codex does not emit `total_cost_usd`; cost is estimated downstream via
+// server/pricing.ts. Codex does not honour Claude's OTEL env vars; signals are
+// synthesised by server/codex-otel-bridge.ts.
+//
+// Spec: openspec/specs/multi-provider-architecture/spec.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._CODEX_MIN_VERSION = exports.codexAdapter = void 0;
+exports._compareSemver = compareSemver;
+const child_process_1 = require("child_process");
+const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
+const CODEX_MIN_VERSION = '0.128.0';
+exports._CODEX_MIN_VERSION = CODEX_MIN_VERSION;
+const CODEX_MODELS = [
+    { value: 'gpt-5.5', label: 'GPT-5.5', default: true },
+    { 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' },
+];
+const SANDBOX_FLAGS = ['--sandbox', 'workspace-write'];
+const RAIL_SANDBOX_FLAGS = ['--sandbox', 'danger-full-access'];
+// `codex exec resume` does NOT accept `--sandbox` (the flag only exists on
+// `codex exec`); pass the policy as a `-c` config override instead so the
+// resumed session honours workspace-write even when the per-project
+// `.codex/config.toml` isn't on the spawn cwd (e.g. explore-cwd).
+const SANDBOX_RESUME_FLAGS = ['-c', 'sandbox_mode="workspace-write"'];
+const SKIP_GIT_CHECK = '--skip-git-repo-check';
+/** Fold system prompt into the user prompt for providers without --system-prompt. */
+function fold(systemPrompt, prompt) {
+    if (!systemPrompt)
+        return prompt;
+    return `${systemPrompt}\n\n---\n\n${prompt}`;
+}
+function buildCodexArgs(action, opts) {
+    const args = [];
+    switch (action) {
+        case 'chat-turn': {
+            // chat-turn (Explore) spawns codex from the app-managed explore-cwd,
+            // which already ships an AGENTS.md with the Explore stance. Folding the
+            // app's system prompt into the positional argv would double-inject the
+            // framing AND, because the user message in Explore is often very short
+            // ("quiero hacer un tetris"), the long system text dominates the prompt
+            // and codex responds to the system instructions instead of the user.
+            // Trust AGENTS.md and pass only the user prompt.
+            args.push('exec', '--json', ...SANDBOX_FLAGS, SKIP_GIT_CHECK);
+            args.push(opts.prompt);
+            args.push('--model', opts.model);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'spec-gen':
+        case 'agent-refine':
+        case 'auto-title':
+        case 'setup-enrich': {
+            args.push('exec', '--json', ...SANDBOX_FLAGS, SKIP_GIT_CHECK);
+            args.push(fold(opts.systemPrompt, opts.prompt));
+            args.push('--model', opts.model);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'chat-resume': {
+            if (!opts.sessionId) {
+                throw new Error(`${action} requires sessionId`);
+            }
+            // See chat-turn note: AGENTS.md in explore-cwd carries the Explore
+            // framing; the per-turn argv must stay user-text-only so codex doesn't
+            // mistake the system prompt for the user request.
+            args.push('exec', 'resume', '--json', ...SANDBOX_RESUME_FLAGS, SKIP_GIT_CHECK);
+            args.push(opts.sessionId);
+            args.push(opts.prompt);
+            args.push('--model', opts.model);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'setup-enrich-resume': {
+            if (!opts.sessionId) {
+                throw new Error(`${action} requires sessionId`);
+            }
+            args.push('exec', 'resume', '--json', ...SANDBOX_RESUME_FLAGS, SKIP_GIT_CHECK);
+            args.push(opts.sessionId);
+            args.push(fold(opts.systemPrompt, opts.prompt));
+            args.push('--model', opts.model);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+        case 'rail-job': {
+            // Rail jobs are headless implementation pipelines. They must run repo
+            // inspection, edits, tests, and git probes without interactive approval.
+            // On Windows, Codex's workspace-write sandbox can fail before the first
+            // shell command with `windows sandbox: spawn setup refresh`; full access
+            // matches the existing fully-autonomous rail contract.
+            args.push('exec', '--json', ...RAIL_SANDBOX_FLAGS, SKIP_GIT_CHECK);
+            args.push(fold(opts.systemPrompt, opts.prompt));
+            args.push('--model', opts.model);
+            if (opts.extraArgs)
+                args.push(...opts.extraArgs);
+            return args;
+        }
+    }
+}
+function parseCodexStreamLine(line) {
+    if (line.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const type = parsed.type;
+    if (!type)
+        return { kind: 'other', type: '<missing>', raw: parsed };
+    if (type === 'thread.started') {
+        const sid = parsed.thread_id;
+        if (sid)
+            return { kind: 'session-started', sessionId: sid };
+        return { kind: 'other', type, raw: parsed };
+    }
+    if (type === 'turn.completed') {
+        return { kind: 'result', payload: parsed };
+    }
+    if (type === 'item.completed') {
+        const item = parsed.item;
+        if (item?.type === 'agent_message') {
+            const text = item.text ?? '';
+            if (text)
+                return { kind: 'text-delta', text };
+            return { kind: 'other', type, raw: parsed };
+        }
+        if (item?.type === 'function_call' || item?.type === 'local_shell_call') {
+            const name = item.name ?? (item.type === 'local_shell_call' ? 'shell' : '<unnamed>');
+            const inputPreview = item.arguments ? item.arguments.slice(0, 200) : '';
+            return { kind: 'tool-use', name, inputPreview };
+        }
+        return { kind: 'other', type, raw: parsed };
+    }
+    return { kind: 'other', type, raw: parsed };
+}
+function extractCodexResult(events) {
+    let sessionId;
+    let resultPayload = null;
+    let turnCount = 0;
+    // First text-delta timestamp is unavailable from events (we'd need wall-clock
+    // tracking). duration_ms is left undefined and the manager-level wrapper
+    // synthesises it from the spawn-close timestamps if it wants to populate.
+    for (const ev of events) {
+        if (ev.kind === 'session-started')
+            sessionId = ev.sessionId;
+        else if (ev.kind === 'result') {
+            resultPayload = ev.payload;
+            turnCount += 1; // each turn.completed is one codex turn
+        }
+    }
+    if (!resultPayload) {
+        return { session_id: sessionId };
+    }
+    const usage = resultPayload.usage;
+    // OpenAI bills reasoning_output_tokens at the output rate, so we fold it
+    // into tokens_out for cost-estimation correctness.
+    const baseOut = usage?.output_tokens ?? 0;
+    const reasoning = usage?.reasoning_output_tokens ?? 0;
+    const tokensOut = baseOut + reasoning;
+    return {
+        tokens_in: usage?.input_tokens,
+        tokens_out: usage ? tokensOut : undefined,
+        tokens_cache_read: usage?.cached_input_tokens,
+        // Codex has no separate "cache creation" tier — left undefined.
+        tokens_cache_create: undefined,
+        // total_cost_usd intentionally absent — estimated via pricing.ts.
+        // Derive from the number of turn.completed events rather than hardcoding 1
+        // (a single `codex exec` normally emits exactly one, but don't assume it).
+        num_turns: turnCount || 1,
+        // Model on stream events is not present; manager-level wrapper passes
+        // the requested model in via the spawn args and stamps it on the row.
+        model: undefined,
+        duration_ms: undefined,
+        duration_api_ms: undefined,
+        session_id: sessionId,
+    };
+}
+function compareSemver(a, b) {
+    const aParts = a.split('.').map((n) => parseInt(n, 10));
+    const bParts = b.split('.').map((n) => parseInt(n, 10));
+    for (let i = 0; i < 3; i++) {
+        const av = aParts[i] ?? 0;
+        const bv = bParts[i] ?? 0;
+        if (av > bv)
+            return 1;
+        if (av < bv)
+            return -1;
+    }
+    return 0;
+}
+async function detectCodexInstalled() {
+    try {
+        (0, child_process_1.execSync)(`${WHICH_CMD} codex`, { stdio: 'ignore' });
+    }
+    catch {
+        return { installed: false, executable: false };
+    }
+    try {
+        const raw = (0, child_process_1.execSync)('codex --version', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: 3000,
+        }).trim();
+        const match = raw.match(/\d+\.\d+\.\d+/);
+        const version = match ? match[0] : raw;
+        const meetsMinimum = match ? compareSemver(version, CODEX_MIN_VERSION) >= 0 : false;
+        const result = {
+            installed: true,
+            executable: true,
+            version,
+            meetsMinimum,
+        };
+        if (!meetsMinimum) {
+            result.error = `codex ${version} is older than required ${CODEX_MIN_VERSION}. Upgrade with: brew upgrade codex (or follow https://developers.openai.com/codex).`;
+        }
+        return result;
+    }
+    catch {
+        return { installed: true, executable: false };
+    }
+}
+exports.codexAdapter = {
+    id: 'codex',
+    displayName: 'Codex CLI',
+    binary: 'codex',
+    minCliVersion: CODEX_MIN_VERSION,
+    projectDirName: '.codex',
+    instructionsFilename: 'AGENTS.md',
+    mcpRegistration: 'cli-add',
+    capabilities: {
+        nativeResume: true,
+        nativeStreamJson: true,
+        nativeCostUsd: false,
+        nativeOtelEnv: false,
+        profileEnvSupport: true,
+        systemPromptArg: false,
+    },
+    modelCatalog: () => CODEX_MODELS,
+    defaultModel: () => 'gpt-5.5',
+    buildArgs: buildCodexArgs,
+    parseStreamLine: parseCodexStreamLine,
+    extractResult: extractCodexResult,
+    baselineAgents: () => ['sr-architect', 'sr-developer', 'sr-reviewer'],
+    detectInstalled: detectCodexInstalled,
+};

package/server/dist/providers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+// Provider barrel. Importing this module registers every bundled adapter so
+// managers can resolve them via `getAdapter`. Adapters themselves are pure
+// const exports — testing an adapter in isolation does NOT side-effect the
+// registry. Production code MUST import this module (not the adapter files
+// directly) so the registration runs.
+//
+// Spec: openspec/specs/multi-provider-architecture/spec.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownProviderError = exports.codexAdapter = exports.claudeAdapter = exports.listAdapters = exports.hasAdapter = exports.getAdapter = void 0;
+const registry_1 = require("./registry");
+const claude_adapter_1 = require("./claude-adapter");
+Object.defineProperty(exports, "claudeAdapter", { enumerable: true, get: function () { return claude_adapter_1.claudeAdapter; } });
+const codex_adapter_1 = require("./codex-adapter");
+Object.defineProperty(exports, "codexAdapter", { enumerable: true, get: function () { return codex_adapter_1.codexAdapter; } });
+(0, registry_1.register)(claude_adapter_1.claudeAdapter);
+(0, registry_1.register)(codex_adapter_1.codexAdapter);
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "getAdapter", { enumerable: true, get: function () { return registry_2.getAdapter; } });
+Object.defineProperty(exports, "hasAdapter", { enumerable: true, get: function () { return registry_2.hasAdapter; } });
+Object.defineProperty(exports, "listAdapters", { enumerable: true, get: function () { return registry_2.listAdapters; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "UnknownProviderError", { enumerable: true, get: function () { return types_1.UnknownProviderError; } });

package/server/dist/providers/registry.js

@@ -0,0 +1,37 @@
+"use strict";
+// In-process registry of ProviderAdapter instances. Adapter modules call
+// `register(this)` on module load; managers look up by id via `getAdapter`.
+//
+// Spec: openspec/specs/multi-provider-architecture/spec.md
+//   - "Provider registry exposes lookup by id"
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+exports.getAdapter = getAdapter;
+exports.hasAdapter = hasAdapter;
+exports.listAdapters = listAdapters;
+exports._clearForTests = _clearForTests;
+const types_1 = require("./types");
+const _registry = new Map();
+function register(adapter) {
+    _registry.set(adapter.id, adapter);
+}
+function getAdapter(id) {
+    const adapter = _registry.get(id);
+    if (!adapter) {
+        throw new types_1.UnknownProviderError(id, Array.from(_registry.keys()));
+    }
+    return adapter;
+}
+function hasAdapter(id) {
+    return _registry.has(id);
+}
+function listAdapters() {
+    return Array.from(_registry.values());
+}
+/**
+ * Reset the registry. Test-only — production code MUST NOT call this.
+ * Exported separately so production paths cannot mistakenly import it.
+ */
+function _clearForTests() {
+    _registry.clear();
+}

package/server/dist/providers/types.js

@@ -0,0 +1,22 @@
+"use strict";
+// Provider adapter contract.
+//
+// Managers (chat, queue, agent-refine, setup, profile, plugin, explore-cwd,
+// result-event, project-router) consume this contract exclusively for
+// spawn-time decisions. Branching on `adapter.capabilities.*` is fine;
+// branching on `provider === 'claude'` is forbidden.
+//
+// Spec: openspec/specs/multi-provider-architecture/spec.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownProviderError = void 0;
+class UnknownProviderError extends Error {
+    unknownId;
+    registered;
+    constructor(unknownId, registered) {
+        super(`unknown provider '${unknownId}'. Registered providers: ${registered.length > 0 ? registered.join(', ') : '(none)'}`);
+        this.name = 'UnknownProviderError';
+        this.unknownId = unknownId;
+        this.registered = registered;
+    }
+}
+exports.UnknownProviderError = UnknownProviderError;