@shepai/cli 1.149.0 → 1.149.1-pr468.4c60284

package/dist/packages/core/src/infrastructure/services/agents/common/executors/codex-cli-executor.service.js

@@ -0,0 +1,506 @@
+/**
+ * Codex CLI Executor Service
+ *
+ * Infrastructure implementation of IAgentExecutor for the OpenAI Codex CLI agent.
+ * Executes prompts via the `codex` CLI subprocess with JSONL output format.
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { getCurrentPhase, getLogPrefix } from '../../feature-agent/log-context.js';
+/** Features supported by Codex CLI */
+const SUPPORTED_FEATURES = new Set(['session-resume', 'streaming', 'structured-output']);
+/**
+ * Fatal stderr patterns indicating API-level failures even when exit code is 0.
+ * Codex CLI may exit 0 after encountering auth or rate-limit errors.
+ */
+const FATAL_STDERR_PATTERNS = [
+    /authentication.*failed/i,
+    /rate.?limit/i,
+    /quota.*exceeded/i,
+    /invalid.*api.?key/i,
+    /RESOURCE_EXHAUSTED/i,
+];
+/**
+ * Executor service for OpenAI Codex CLI agent.
+ * Uses subprocess spawning to interact with the `codex` CLI.
+ */
+export class CodexCliExecutorService {
+    spawn;
+    authConfig;
+    agentType = 'codex-cli';
+    /** When true, suppresses debug logging (set per-call via options.silent) */
+    silent = false;
+    constructor(spawn, authConfig) {
+        this.spawn = spawn;
+        this.authConfig = authConfig;
+    }
+    /** Debug logging — writes to stdout so it appears in the worker log file */
+    log(message) {
+        if (this.silent)
+            return;
+        const ts = new Date().toISOString();
+        process.stdout.write(`[${ts}] ${getCurrentPhase()}${getLogPrefix()}${message}\n`);
+    }
+    supportsFeature(feature) {
+        return SUPPORTED_FEATURES.has(feature);
+    }
+    async execute(prompt, options) {
+        this.silent = options?.silent ?? false;
+        const isResume = !!options?.resumeSession;
+        let tempSchemaPath;
+        try {
+            if (options?.outputSchema) {
+                tempSchemaPath = path.join(os.tmpdir(), `codex-schema-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+                fs.writeFileSync(tempSchemaPath, JSON.stringify(options.outputSchema));
+            }
+            const args = this.buildArgs(prompt, options, tempSchemaPath);
+            const spawnOpts = this.buildSpawnOptions(options);
+            this.log(`Spawning: codex ${args.map((a) => (a.length > 80 ? `${a.slice(0, 77)}...` : a)).join(' ')}`);
+            this.log(`Spawn cwd: ${spawnOpts.cwd ?? '(inherited)'}`);
+            const proc = this.spawn('codex', args, spawnOpts);
+            this.log(`Subprocess PID: ${proc.pid ?? 'undefined (spawn may have failed)'}`);
+            this.log(`Prompt length: ${prompt.length} chars${isResume ? ' (positional arg for resume)' : ' (piped via stdin)'}`);
+            // For initial executions, pipe the prompt via stdin.
+            // For resume, the prompt is already in the CLI args.
+            if (!isResume && proc.stdin) {
+                proc.stdin.write(prompt);
+                proc.stdin.end();
+            }
+            return await new Promise((resolve, reject) => {
+                let lineBuffer = '';
+                let stderr = '';
+                let timedOut = false;
+                let timeoutId;
+                // State accumulated from JSONL events
+                let resultText = '';
+                let sessionId;
+                let usage;
+                if (options?.timeout) {
+                    timeoutId = setTimeout(() => {
+                        timedOut = true;
+                        proc.kill();
+                    }, options.timeout);
+                }
+                const processLine = (line) => {
+                    try {
+                        const parsed = JSON.parse(line);
+                        const type = parsed.type;
+                        if (type === 'thread.started' && parsed.thread_id) {
+                            sessionId = parsed.thread_id;
+                        }
+                        else if (type === 'item.completed' && parsed.item?.type === 'agent_message') {
+                            // Accumulate response text from completed agent messages
+                            const content = parsed.item.content;
+                            if (Array.isArray(content)) {
+                                for (const block of content) {
+                                    if (block.type === 'text' && block.text) {
+                                        resultText += block.text;
+                                    }
+                                }
+                            }
+                            else if (typeof content === 'string') {
+                                resultText += content;
+                            }
+                        }
+                        else if (type === 'turn.completed' && parsed.usage) {
+                            usage = this.extractUsage(parsed.usage);
+                        }
+                    }
+                    catch {
+                        // Malformed JSON line — skip gracefully
+                    }
+                };
+                proc.stdout?.on('data', (chunk) => {
+                    lineBuffer += chunk.toString();
+                    const lines = lineBuffer.split('\n');
+                    lineBuffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (trimmed)
+                            processLine(trimmed);
+                    }
+                });
+                proc.stderr?.on('data', (chunk) => {
+                    const data = chunk.toString();
+                    stderr += data;
+                    this.log(`stderr: ${data.trimEnd()}`);
+                });
+                proc.on('error', (error) => {
+                    this.log(`Process error event: ${error.message}`);
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    if (error.code === 'ENOENT') {
+                        reject(new Error('Codex CLI ("codex") not found. Please install it: npm i -g @openai/codex'));
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+                proc.on('close', (code) => {
+                    // Flush remaining buffer
+                    if (lineBuffer.trim())
+                        processLine(lineBuffer.trim());
+                    this.log(`Process closed with code ${code}, result=${resultText.length} chars`);
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    if (timedOut) {
+                        reject(new Error('Agent execution timed out'));
+                        return;
+                    }
+                    if (code !== 0 && code !== null) {
+                        const message = stderr.trim()
+                            ? `Process exited with code ${code}: ${stderr.trim()}`
+                            : `Process exited with code ${code}`;
+                        reject(new Error(message));
+                        return;
+                    }
+                    // Codex CLI may exit 0 despite fatal API errors.
+                    // Check stderr for known fatal patterns before trusting the output.
+                    const fatalError = this.detectFatalStderrError(stderr);
+                    if (fatalError) {
+                        reject(new Error(fatalError));
+                        return;
+                    }
+                    if (!resultText && !sessionId) {
+                        reject(new Error(`Empty response from Codex CLI. stderr: ${stderr.slice(0, 300)}`));
+                        return;
+                    }
+                    const result = { result: resultText };
+                    if (sessionId)
+                        result.sessionId = sessionId;
+                    if (usage)
+                        result.usage = usage;
+                    resolve(result);
+                });
+            });
+        }
+        finally {
+            // Clean up temp schema file
+            if (tempSchemaPath) {
+                try {
+                    fs.unlinkSync(tempSchemaPath);
+                }
+                catch {
+                    // Best effort cleanup
+                }
+            }
+        }
+    }
+    async *executeStream(prompt, options) {
+        this.silent = options?.silent ?? false;
+        const isResume = !!options?.resumeSession;
+        let tempSchemaPath;
+        try {
+            if (options?.outputSchema) {
+                tempSchemaPath = path.join(os.tmpdir(), `codex-schema-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+                fs.writeFileSync(tempSchemaPath, JSON.stringify(options.outputSchema));
+            }
+            const args = this.buildArgs(prompt, options, tempSchemaPath);
+            const spawnOpts = this.buildSpawnOptions(options);
+            const proc = this.spawn('codex', args, spawnOpts);
+            // For initial executions, pipe the prompt via stdin.
+            // For resume, the prompt is already in the CLI args.
+            if (!isResume && proc.stdin) {
+                proc.stdin.write(prompt);
+                proc.stdin.end();
+            }
+            let lineBuffer = '';
+            let stderr = '';
+            let timedOut = false;
+            let timeoutId;
+            // State accumulated across events
+            let resultText = '';
+            const queue = [];
+            let resolve = null;
+            let spawnError = null;
+            function enqueue(event) {
+                queue.push(event);
+                if (resolve) {
+                    resolve();
+                    resolve = null;
+                }
+            }
+            function waitForItem() {
+                if (queue.length > 0)
+                    return Promise.resolve();
+                return new Promise((r) => {
+                    resolve = r;
+                });
+            }
+            if (options?.timeout) {
+                timeoutId = setTimeout(() => {
+                    timedOut = true;
+                    proc.kill();
+                    enqueue({ type: 'error', content: 'Agent execution timed out', timestamp: new Date() });
+                    enqueue(null);
+                }, options.timeout);
+            }
+            const processStreamLine = (line) => {
+                try {
+                    const parsed = JSON.parse(line);
+                    const type = parsed.type;
+                    if (type === 'thread.started') {
+                        // Internal state — no event yielded (thread_id tracked for logging)
+                        return;
+                    }
+                    if (type === 'item.started' && parsed.item?.type === 'agent_message') {
+                        enqueue({ type: 'progress', content: '', timestamp: new Date() });
+                        return;
+                    }
+                    if (type === 'item.updated' && parsed.item?.type === 'agent_message') {
+                        const delta = this.extractDeltaText(parsed);
+                        if (delta) {
+                            enqueue({ type: 'progress', content: delta, timestamp: new Date() });
+                        }
+                        return;
+                    }
+                    if (type === 'item.completed' && parsed.item?.type === 'agent_message') {
+                        const text = this.extractItemText(parsed);
+                        if (text)
+                            resultText += text;
+                        return;
+                    }
+                    if (type === 'item.started' && parsed.item?.type === 'command_execution') {
+                        const cmd = parsed.item.command ?? parsed.item.name ?? 'command';
+                        enqueue({ type: 'progress', content: `Running: ${cmd}`, timestamp: new Date() });
+                        return;
+                    }
+                    if (type === 'item.completed' && parsed.item?.type === 'command_execution') {
+                        const exitCode = parsed.item.exit_code ?? '';
+                        enqueue({
+                            type: 'progress',
+                            content: `Command completed (exit ${exitCode})`,
+                            timestamp: new Date(),
+                        });
+                        return;
+                    }
+                    if (type === 'item.started' && parsed.item?.type === 'file_change') {
+                        enqueue({ type: 'progress', content: 'Modifying files', timestamp: new Date() });
+                        return;
+                    }
+                    if (type === 'item.completed' && parsed.item?.type === 'file_change') {
+                        const file = parsed.item.file ?? parsed.item.path ?? '';
+                        enqueue({
+                            type: 'progress',
+                            content: file ? `Modified: ${file}` : 'File change completed',
+                            timestamp: new Date(),
+                        });
+                        return;
+                    }
+                    if (type === 'turn.completed') {
+                        // Yield final result event
+                        enqueue({
+                            type: 'result',
+                            content: resultText,
+                            timestamp: new Date(),
+                        });
+                        return;
+                    }
+                    if (type === 'turn.failed') {
+                        const msg = parsed.error?.message ?? parsed.message ?? 'Turn failed';
+                        enqueue({ type: 'error', content: msg, timestamp: new Date() });
+                        return;
+                    }
+                    if (type === 'error') {
+                        const msg = parsed.message ?? parsed.error ?? 'Unknown error';
+                        enqueue({ type: 'error', content: msg, timestamp: new Date() });
+                        return;
+                    }
+                    // Unknown event type — skip gracefully
+                }
+                catch {
+                    // Non-JSON line — emit as raw progress
+                    enqueue({ type: 'progress', content: line, timestamp: new Date() });
+                }
+            };
+            proc.stdout?.on('data', (chunk) => {
+                lineBuffer += chunk.toString();
+                const lines = lineBuffer.split('\n');
+                lineBuffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    processStreamLine(trimmed);
+                }
+            });
+            proc.stderr?.on('data', (chunk) => {
+                stderr += chunk.toString();
+            });
+            proc.on('error', (err) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                spawnError = err;
+                enqueue(null);
+            });
+            proc.on('close', (code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (timedOut)
+                    return; // already handled by timeout callback
+                if (lineBuffer.trim()) {
+                    processStreamLine(lineBuffer.trim());
+                }
+                if (code !== 0 && code !== null) {
+                    const msg = stderr.trim()
+                        ? `Process exited with code ${code}: ${stderr.trim()}`
+                        : `Process exited with code ${code}`;
+                    enqueue({ type: 'error', content: msg, timestamp: new Date() });
+                }
+                else {
+                    // Check for fatal stderr patterns on exit 0
+                    const fatalError = this.detectFatalStderrError(stderr);
+                    if (fatalError) {
+                        enqueue({ type: 'error', content: fatalError, timestamp: new Date() });
+                    }
+                }
+                enqueue(null);
+            });
+            // Yield events as they arrive
+            while (true) {
+                await waitForItem();
+                const item = queue.shift();
+                if (item === null || item === undefined) {
+                    if (spawnError !== null) {
+                        yield {
+                            type: 'error',
+                            content: spawnError.message,
+                            timestamp: new Date(),
+                        };
+                    }
+                    return;
+                }
+                yield item;
+            }
+        }
+        finally {
+            // Clean up temp schema file
+            if (tempSchemaPath) {
+                try {
+                    fs.unlinkSync(tempSchemaPath);
+                }
+                catch {
+                    // Best effort cleanup
+                }
+            }
+        }
+    }
+    /**
+     * Build CLI arguments for codex exec.
+     *
+     * For initial execution: `codex exec - --json --sandbox danger-full-access ...`
+     * For resume: `codex exec resume <threadId> "prompt" --json --sandbox danger-full-access ...`
+     */
+    buildArgs(prompt, options, tempSchemaPath) {
+        const baseFlags = [
+            '--json',
+            '--sandbox',
+            'danger-full-access',
+            '--skip-git-repo-check',
+            '--color',
+            'never',
+        ];
+        if (options?.model)
+            baseFlags.push('--model', options.model);
+        if (options?.cwd)
+            baseFlags.push('--cd', options.cwd);
+        if (tempSchemaPath)
+            baseFlags.push('--output-schema', tempSchemaPath);
+        if (options?.resumeSession) {
+            // Resume mode: codex exec resume <threadId> "prompt" [flags]
+            return ['exec', 'resume', options.resumeSession, prompt, ...baseFlags];
+        }
+        // Initial execution: codex exec - [flags]
+        // The `-` indicates prompt is piped via stdin
+        return ['exec', '-', ...baseFlags];
+    }
+    buildSpawnOptions(_options) {
+        const spawnOpts = {};
+        // Explicitly pipe stdio so streams are available even when parent disconnects
+        spawnOpts.stdio = ['pipe', 'pipe', 'pipe'];
+        // On Windows: windowsHide=true to prevent blank console windows.
+        // Codex CLI is a native Rust binary, so shell=true is NOT needed.
+        if (process.platform === 'win32') {
+            spawnOpts.windowsHide = true;
+        }
+        // Strip CLAUDECODE env var to prevent "nested session" error when shep
+        // is invoked from within a Claude Code session.
+        const { CLAUDECODE: _, ...cleanEnv } = process.env;
+        // Inject CODEX_API_KEY when using token auth
+        if (this.authConfig?.authMethod === 'token' && this.authConfig.token) {
+            spawnOpts.env = { ...cleanEnv, CODEX_API_KEY: this.authConfig.token };
+        }
+        else {
+            spawnOpts.env = cleanEnv;
+        }
+        return spawnOpts;
+    }
+    /**
+     * Extract token usage from Codex CLI turn.completed usage object.
+     */
+    extractUsage(usageObj) {
+        if (usageObj.input_tokens === undefined && usageObj.output_tokens === undefined) {
+            return undefined;
+        }
+        return {
+            inputTokens: usageObj.input_tokens ?? 0,
+            outputTokens: usageObj.output_tokens ?? 0,
+        };
+    }
+    /**
+     * Extract delta text from an item.updated event.
+     */
+    extractDeltaText(parsed) {
+        const item = parsed.item;
+        if (!item)
+            return undefined;
+        const content = item.content;
+        if (Array.isArray(content)) {
+            for (const block of content) {
+                if (block.type === 'text' && block.text)
+                    return block.text;
+            }
+        }
+        if (typeof item.delta === 'string')
+            return item.delta;
+        return undefined;
+    }
+    /**
+     * Extract final text from an item.completed event.
+     */
+    extractItemText(parsed) {
+        const item = parsed.item;
+        if (!item)
+            return undefined;
+        const content = item.content;
+        if (Array.isArray(content)) {
+            const parts = [];
+            for (const block of content) {
+                if (block.type === 'text' && block.text)
+                    parts.push(block.text);
+            }
+            return parts.length > 0 ? parts.join('') : undefined;
+        }
+        if (typeof content === 'string')
+            return content;
+        return undefined;
+    }
+    /**
+     * Check stderr for patterns indicating fatal API errors.
+     * Returns an error message if fatal patterns are found, null otherwise.
+     */
+    detectFatalStderrError(stderr) {
+        for (const pattern of FATAL_STDERR_PATTERNS) {
+            if (pattern.test(stderr)) {
+                const lines = stderr.split('\n').filter((l) => l.trim());
+                const summary = lines.slice(0, 3).join(' | ').slice(0, 300);
+                return `Codex CLI exited 0 but fatal error detected in stderr: ${summary}`;
+            }
+        }
+        return null;
+    }
+}

package/dist/src/presentation/tui/prompts/agent-select.prompt.d.ts

@@ -8,8 +8,8 @@ import { AgentType } from '../../../../packages/core/src/domain/generated/output
 /**
  * Creates the @inquirer/select configuration for selecting an AI coding agent.
  *
- * Only Claude Code is currently available. Other agents are shown as
- * disabled with a "Coming Soon" badge.
+ * Active agents are selectable. Agents not yet implemented are shown
+ * as disabled with a "Coming Soon" badge.
  */
 export declare function createAgentSelectConfig(): {
     readonly message: "Select your AI coding agent";
@@ -21,6 +21,10 @@ export declare function createAgentSelectConfig(): {
         readonly name: "Gemini CLI";
         readonly value: AgentType.GeminiCli;
         readonly description: "Google Gemini CLI";
+    }, {
+        readonly name: "Codex CLI";
+        readonly value: AgentType.CodexCli;
+        readonly description: "OpenAI's Codex CLI terminal agent (GPT models)";
     }, {
         readonly name: "Cursor";
         readonly value: AgentType.Cursor;

package/dist/src/presentation/tui/prompts/agent-select.prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-select.prompt.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/tui/prompts/agent-select.prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD;;;;;GAKG;AACH,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqCtC"}
+{"version":3,"file":"agent-select.prompt.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/tui/prompts/agent-select.prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD;;;;;GAKG;AACH,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CtC"}

package/dist/src/presentation/tui/prompts/agent-select.prompt.js

@@ -9,8 +9,8 @@ import { shepTheme } from '../themes/shep.theme.js';
 /**
  * Creates the @inquirer/select configuration for selecting an AI coding agent.
  *
- * Only Claude Code is currently available. Other agents are shown as
- * disabled with a "Coming Soon" badge.
+ * Active agents are selectable. Agents not yet implemented are shown
+ * as disabled with a "Coming Soon" badge.
  */
 export function createAgentSelectConfig() {
     return {
@@ -26,6 +26,11 @@ export function createAgentSelectConfig() {
                 value: AgentType.GeminiCli,
                 description: 'Google Gemini CLI',
             },
+            {
+                name: 'Codex CLI',
+                value: AgentType.CodexCli,
+                description: "OpenAI's Codex CLI terminal agent (GPT models)",
+            },
             {
                 name: 'Cursor',
                 value: AgentType.Cursor,

package/dist/src/presentation/web/app/actions/get-all-agent-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-all-agent-models.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/get-all-agent-models.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAiBD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CA+BpE"}
+{"version":3,"file":"get-all-agent-models.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/get-all-agent-models.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAmBD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CA+BpE"}

package/dist/src/presentation/web/app/actions/get-all-agent-models.js

@@ -3,6 +3,7 @@ import { resolve } from '../../lib/server-container.js';
 import { getModelMeta } from '../../lib/model-metadata.js';
 const AGENT_LABELS = {
     'claude-code': 'Claude Code',
+    'codex-cli': 'Codex CLI',
     cursor: 'Cursor CLI',
     'gemini-cli': 'Gemini CLI',
     dev: 'Demo',
@@ -10,8 +11,9 @@ const AGENT_LABELS = {
 /** Sort weight — higher = further down. Demo always last. */
 const AGENT_ORDER = {
     'claude-code': 0,
-    cursor: 1,
-    'gemini-cli': 2,
+    'codex-cli': 1,
+    cursor: 2,
+    'gemini-cli': 3,
     dev: 99,
 };
 export async function getAllAgentModels() {

package/dist/src/presentation/web/components/common/control-center-drawer/feature-drawer-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature-drawer-client.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/control-center-drawer/feature-drawer-client.tsx"],"names":[],"mappings":"AAuCA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAK/D,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,UAAU,CAAC;IACjB,8FAA8F;IAC9F,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,wBAAgB,mBAAmB,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,wBAAwB,2CAyoB1F"}
+{"version":3,"file":"feature-drawer-client.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/control-center-drawer/feature-drawer-client.tsx"],"names":[],"mappings":"AAuCA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAK/D,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,UAAU,CAAC;IACjB,8FAA8F;IAC9F,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,wBAAgB,mBAAmB,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,wBAAwB,2CA4oB1F"}

package/dist/src/presentation/web/components/common/control-center-drawer/feature-drawer-client.js

@@ -333,8 +333,11 @@ export function FeatureDrawerClient({ view: initialView, urlTab }) {
         }
         : null;
     const featureActions = useFeatureActions(featureActionsInput);
-    // Branch sync status — only when the feature flag is on and the feature has a branch
-    const syncFeatureId = featureFlags.gitRebaseSync && featureNode?.branch ? featureNode.featureId : null;
+    // Branch sync status — only when the feature flag is on, the feature has a branch,
+    // and the repository has a remote (no remote = no sync needed)
+    const syncFeatureId = featureFlags.gitRebaseSync && featureNode?.branch && featureNode?.remoteUrl
+        ? featureNode.featureId
+        : null;
     const { data: syncData, loading: syncLoading, error: syncError, refresh: refreshSync, } = useBranchSyncStatus(syncFeatureId);
     // Auto-refresh sync status after a successful rebase
     const prevRebaseLoadingRef = useRef(featureActions.rebaseLoading);
@@ -383,7 +386,7 @@ export function FeatureDrawerClient({ view: initialView, urlTab }) {
             ...(featureNode.state === 'error' && { onRetry: handleRetry }),
             ...(featureNode.state === 'pending' && { onStart: handleStart }),
         };
-        body = (_jsx(FeatureDrawerTabs, { featureNode: enrichedNode, featureId: featureNode.featureId, initialTab: view.initialTab, urlTab: urlTab, sseEvents: events, prdData: prdData, prdSelections: prdSelections, onPrdSelect: (qId, oId) => setPrdSelections((prev) => ({ ...prev, [qId]: oId })), onPrdApprove: handlePrdApprove, onPrdReject: handlePrdReject, isPrdLoading: isLoadingPrd, techData: techData, onTechApprove: handleTechApprove, onTechReject: handleTechReject, isTechLoading: isLoadingTech, productData: isLoadingTechProduct ? null : techProductData, mergeData: mergeData, onMergeApprove: handleMergeApprove, onMergeReject: handleMergeReject, isMergeLoading: isLoadingMerge, syncStatus: featureFlags.gitRebaseSync ? syncData : undefined, syncLoading: syncLoading, syncError: syncError, onRefreshSync: featureFlags.gitRebaseSync ? refreshSync : undefined, onRebaseOnMain: featureFlags.gitRebaseSync ? featureActions.rebaseOnMain : undefined, rebaseLoading: featureActions.rebaseLoading, rebaseError: featureActions.rebaseError, isRejecting: isRejecting, chatInput: chatInput, onChatInputChange: setChatInput }));
+        body = (_jsx(FeatureDrawerTabs, { featureNode: enrichedNode, featureId: featureNode.featureId, initialTab: view.initialTab, urlTab: urlTab, sseEvents: events, prdData: prdData, prdSelections: prdSelections, onPrdSelect: (qId, oId) => setPrdSelections((prev) => ({ ...prev, [qId]: oId })), onPrdApprove: handlePrdApprove, onPrdReject: handlePrdReject, isPrdLoading: isLoadingPrd, techData: techData, onTechApprove: handleTechApprove, onTechReject: handleTechReject, isTechLoading: isLoadingTech, productData: isLoadingTechProduct ? null : techProductData, mergeData: mergeData, onMergeApprove: handleMergeApprove, onMergeReject: handleMergeReject, isMergeLoading: isLoadingMerge, syncStatus: syncFeatureId ? syncData : undefined, syncLoading: syncLoading, syncError: syncError, onRefreshSync: syncFeatureId ? refreshSync : undefined, onRebaseOnMain: syncFeatureId ? featureActions.rebaseOnMain : undefined, rebaseLoading: featureActions.rebaseLoading, rebaseError: featureActions.rebaseError, isRejecting: isRejecting, chatInput: chatInput, onChatInputChange: setChatInput }));
     }
     return (_jsx(BaseDrawer, { open: isOpen, onClose: attemptClose, size: "md", modal: false, header: header, "data-testid": view.type === 'feature' ? 'feature-drawer' : 'repository-drawer', children: body }));
 }

package/dist/src/presentation/web/components/common/feature-node/agent-type-icons.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentType, SVGProps } from 'react';
 /** Agent type values mirroring the TypeSpec AgentType enum. */
-export type AgentTypeValue = 'claude-code' | 'cursor' | 'gemini-cli' | 'aider' | 'continue' | 'dev';
+export type AgentTypeValue = 'claude-code' | 'codex-cli' | 'cursor' | 'gemini-cli' | 'aider' | 'continue' | 'dev';
 type IconProps = SVGProps<SVGSVGElement> & {
     className?: string;
 };

package/dist/src/presentation/web/components/common/feature-node/agent-type-icons.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-type-icons.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/agent-type-icons.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAIrD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,QAAQ,GAAG,YAAY,GAAG,OAAO,GAAG,UAAU,GAAG,KAAK,CAAC;AAEpG,KAAK,SAAS,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAmBlE,6DAA6D;AAC7D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,2CAOhD;AA2DD,6CAA6C;AAC7C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAO1D,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAK7E"}
+{"version":3,"file":"agent-type-icons.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/agent-type-icons.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAIrD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GACtB,aAAa,GACb,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,OAAO,GACP,UAAU,GACV,KAAK,CAAC;AAEV,KAAK,SAAS,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAmBlE,6DAA6D;AAC7D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,2CAOhD;AA4DD,6CAA6C;AAC7C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAQ1D,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAK7E"}

package/dist/src/presentation/web/components/common/feature-node/agent-type-icons.js

@@ -20,6 +20,7 @@ function DevAgentIcon({ className, ...props }) {
 DevAgentIcon.displayName = 'DevAgentIcon';
 const agentTypeIconMap = {
     'claude-code': createBrandIcon('/icons/agents/claude-ai-icon.svg', 'Claude Code'),
+    'codex-cli': createBrandIcon('/icons/agents/openai.svg', 'Codex CLI'),
     cursor: createBrandIcon('/icons/agents/cursor.jpeg', 'Cursor'),
     'gemini-cli': createBrandIcon('/icons/agents/gemini-cli.jpeg', 'Gemini CLI'),
     aider: createBrandIcon('/icons/agents/aider.png', 'Aider'),
@@ -29,6 +30,7 @@ const agentTypeIconMap = {
 /** Human-readable labels for agent types. */
 export const agentTypeLabels = {
     'claude-code': 'Claude Code',
+    'codex-cli': 'Codex CLI',
     cursor: 'Cursor',
     'gemini-cli': 'Gemini CLI',
     aider: 'Aider',

package/dist/src/presentation/web/components/common/feature-node/agent-type-icons.stories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-type-icons.stories.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/agent-type-icons.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAyCvD,QAAA,MAAM,IAAI,EAAE,IAIX,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC;AAEtB,eAAO,MAAM,QAAQ,EAAE,KAEtB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,KAExB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,KAExB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAa1B,CAAC"}
+{"version":3,"file":"agent-type-icons.stories.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/agent-type-icons.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AA0CvD,QAAA,MAAM,IAAI,EAAE,IAIX,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC;AAEtB,eAAO,MAAM,QAAQ,EAAE,KAEtB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,KAExB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,KAExB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,KAa1B,CAAC"}

package/dist/src/presentation/web/components/common/feature-node/agent-type-icons.stories.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { getAgentTypeIcon, DefaultAgentIcon } from './agent-type-icons.js';
 const allAgentTypes = [
     { type: 'claude-code', label: 'Claude Code' },
+    { type: 'codex-cli', label: 'Codex CLI' },
     { type: 'cursor', label: 'Cursor' },
     { type: 'gemini-cli', label: 'Gemini CLI' },
     { type: 'aider', label: 'Aider' },