@mseep/claudian 2.0.25

package/src/providers/codex/normalization/codexToolNormalization.ts

@@ -0,0 +1,390 @@
+/**
+ * Shared Codex tool normalization layer.
+ *
+ * Used by both CodexChatRuntime (live streaming) and CodexHistoryStore (history reload)
+ * to ensure tool identity parity between live and restored conversations.
+ */
+
+// ---------------------------------------------------------------------------
+// Tool name normalization
+// ---------------------------------------------------------------------------
+
+const TOOL_NAME_MAP: Record<string, string> = {
+  command_execution: 'Bash',
+  shell_command: 'Bash',
+  shell: 'Bash',
+  exec_command: 'Bash',
+  update_plan: 'TodoWrite',
+  request_user_input: 'AskUserQuestion',
+  view_image: 'Read',
+  web_search: 'WebSearch',
+  web_search_call: 'WebSearch',
+  file_change: 'apply_patch',
+};
+
+/** Native Codex tools that should NOT be remapped. */
+const NATIVE_TOOLS = new Set([
+  'apply_patch',
+  'write_stdin',
+  'spawn_agent',
+  'send_input',
+  'wait',
+  'wait_agent',
+  'resume_agent',
+  'close_agent',
+]);
+
+export function normalizeCodexToolName(rawName: string | undefined): string {
+  if (!rawName) return 'tool';
+  if (NATIVE_TOOLS.has(rawName)) return rawName;
+  return TOOL_NAME_MAP[rawName] ?? rawName;
+}
+
+// ---------------------------------------------------------------------------
+// Tool input normalization
+// ---------------------------------------------------------------------------
+
+export function normalizeCodexToolInput(
+  rawName: string | undefined,
+  input: Record<string, unknown>,
+): Record<string, unknown> {
+  switch (rawName) {
+    case 'command_execution':
+    case 'shell_command':
+    case 'shell':
+    case 'exec_command':
+      return { command: normalizeCommandValue(input.command ?? input.cmd ?? '') };
+
+    case 'update_plan':
+      return { todos: normalizeUpdatePlanTodos(input) };
+
+    case 'request_user_input':
+      return { questions: normalizeQuestions(input) };
+
+    case 'view_image':
+      return {
+        ...input,
+        file_path: stringifyCodexValue(input.path ?? input.file_path),
+      };
+
+    case 'web_search':
+    case 'web_search_call':
+      return normalizeWebSearchInput(input);
+
+    case 'apply_patch':
+      return normalizeApplyPatchInput(input);
+
+    default:
+      return input;
+  }
+}
+
+function normalizeUpdatePlanTodos(input: Record<string, unknown>): Array<Record<string, unknown>> {
+  const plan = input.plan;
+  if (!Array.isArray(plan)) return [];
+
+  return plan.map((entry: unknown) => {
+    if (!entry || typeof entry !== 'object') return { id: '', title: '', status: 'pending' };
+    const item = entry as Record<string, unknown>;
+    const text = stringifyCodexValue(item.step ?? item.title ?? item.content);
+    return {
+      id: stringifyCodexValue(item.id),
+      content: text,
+      activeForm: text,
+      status: stringifyCodexValue(item.status) || 'pending',
+    };
+  });
+}
+
+function normalizeQuestions(input: Record<string, unknown>): Array<Record<string, unknown>> {
+  const questions = input.questions;
+  if (!Array.isArray(questions)) return [];
+
+  return questions.map((entry: unknown, index: number) => {
+    if (!entry || typeof entry !== 'object') {
+      return {
+        question: `Question ${index + 1}`,
+        header: `Q${index + 1}`,
+        options: [],
+        multiSelect: false,
+      };
+    }
+    const item = entry as Record<string, unknown>;
+    const options = Array.isArray(item.options)
+      ? item.options
+          .map((option: unknown) => {
+            if (typeof option === 'string') {
+              return { label: option, description: '' };
+            }
+            if (!option || typeof option !== 'object') {
+              return null;
+            }
+            const raw = option as Record<string, unknown>;
+            const label = typeof raw.label === 'string' ? raw.label : '';
+            const description = typeof raw.description === 'string' ? raw.description : '';
+            if (!label) return null;
+            return { label, description };
+          })
+          .filter((option): option is { label: string; description: string } => option !== null)
+      : [];
+
+    return {
+      question: stringifyCodexValue(item.question) || `Question ${index + 1}`,
+      ...(item.id ? { id: stringifyCodexValue(item.id) } : {}),
+      header: typeof item.header === 'string' && item.header.trim()
+        ? String(item.header)
+        : `Q${index + 1}`,
+      options,
+      multiSelect: Boolean(item.multiSelect ?? item.multi_select),
+    };
+  });
+}
+
+function normalizeCommandValue(value: unknown): string {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    return value
+      .map(stringifyCodexValue)
+      .filter(Boolean)
+      .join(' ')
+      .trim();
+  }
+  return stringifyCodexValue(value);
+}
+
+function stringifyCodexValue(value: unknown): string {
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  if (value === null || value === undefined) return '';
+
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return '';
+  }
+}
+
+function normalizeWebSearchInput(input: Record<string, unknown>): Record<string, unknown> {
+  const action = input.action && typeof input.action === 'object'
+    ? input.action as Record<string, unknown>
+    : {};
+
+  const queries = normalizeStringArray(action.queries ?? input.queries);
+  const query = firstNonEmptyString(action.query, input.query, queries[0]);
+  const url = firstNonEmptyString(action.url, input.url);
+  const pattern = firstNonEmptyString(action.pattern, input.pattern);
+  const explicitType = firstNonEmptyString(action.type, input.actionType, input.action_type);
+
+  const actionType = explicitType
+    || (url && pattern ? 'find_in_page' : url ? 'open_page' : (query || queries.length > 0) ? 'search' : '');
+
+  const normalized: Record<string, unknown> = {};
+  if (actionType) normalized.actionType = actionType;
+  if (query) normalized.query = query;
+  if (queries.length > 0) normalized.queries = queries;
+  if (url) normalized.url = url;
+  if (pattern) normalized.pattern = pattern;
+  return normalized;
+}
+
+function normalizeApplyPatchInput(input: Record<string, unknown>): Record<string, unknown> {
+  const patch = firstNonEmptyString(input.patch, input.raw, input.value);
+  if (!patch) return input;
+
+  const normalized: Record<string, unknown> = { ...input, patch };
+  delete normalized.raw;
+  delete normalized.value;
+  return normalized;
+}
+
+function firstNonEmptyString(...values: unknown[]): string {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value;
+    }
+  }
+  return '';
+}
+
+function normalizeStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+
+  const uniqueValues = new Set<string>();
+  for (const entry of value) {
+    if (typeof entry !== 'string') continue;
+    const trimmed = entry.trim();
+    if (!trimmed) continue;
+    uniqueValues.add(trimmed);
+  }
+
+  return [...uniqueValues];
+}
+
+// ---------------------------------------------------------------------------
+// MCP tool normalization
+// ---------------------------------------------------------------------------
+
+interface CodexMcpResultPart {
+  type?: string;
+  text?: string;
+}
+
+interface CodexMcpResultPayload {
+  content?: CodexMcpResultPart[] | null;
+}
+
+export interface NormalizedCodexMcpToolState {
+  isTerminal: boolean;
+  isError: boolean;
+  status: 'running' | 'completed' | 'error';
+  result?: string;
+}
+
+export function normalizeCodexMcpToolName(server: unknown, tool: unknown): string {
+  const serverName = typeof server === 'string' ? server : '';
+  const toolName = typeof tool === 'string' ? tool : '';
+  if (!serverName && !toolName) return 'tool';
+  return `mcp__${serverName}__${toolName}`;
+}
+
+export function normalizeCodexMcpToolInput(rawArguments: unknown): Record<string, unknown> {
+  if (typeof rawArguments === 'string') {
+    return parseCodexArguments(rawArguments);
+  }
+
+  if (rawArguments && typeof rawArguments === 'object' && !Array.isArray(rawArguments)) {
+    return rawArguments as Record<string, unknown>;
+  }
+
+  return {};
+}
+
+export function normalizeCodexMcpToolState(
+  rawStatus: unknown,
+  resultPayload?: unknown,
+  rawError?: unknown,
+): NormalizedCodexMcpToolState {
+  const status = typeof rawStatus === 'string' ? rawStatus : '';
+  const error = typeof rawError === 'string' ? rawError : '';
+  const resultText = extractCodexMcpResultText(resultPayload);
+  const isTerminalStatus = status === 'completed'
+    || status === 'failed'
+    || status === 'error'
+    || status === 'cancelled';
+  const isTerminal = isTerminalStatus || Boolean(error) || Boolean(resultText);
+  const isError = Boolean(error) || status === 'failed' || status === 'error' || status === 'cancelled';
+
+  let result = error || resultText;
+  if (!result && isTerminalStatus) {
+    result = status === 'completed' ? 'Completed' : 'Failed';
+  }
+
+  return {
+    isTerminal,
+    isError,
+    status: isTerminal ? (isError ? 'error' : 'completed') : 'running',
+    ...(result ? { result } : {}),
+  };
+}
+
+function extractCodexMcpResultText(resultPayload?: unknown): string {
+  if (!resultPayload || typeof resultPayload !== 'object') return '';
+
+  const content = (resultPayload as CodexMcpResultPayload).content;
+  if (!Array.isArray(content)) return '';
+
+  return content
+    .map(item => (typeof item?.text === 'string' ? item.text : ''))
+    .filter(Boolean)
+    .join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Tool result normalization
+// ---------------------------------------------------------------------------
+
+/**
+ * Tools whose results should get terminal-style unwrapping.
+ * Uses normalized names only — callers always pass through normalizeCodexToolName first.
+ */
+const TERMINAL_RESULT_TOOLS = new Set([
+  'Bash',
+  'write_stdin',
+]);
+
+export function normalizeCodexToolResult(
+  normalizedName: string,
+  rawResult: string,
+): string {
+  if (!rawResult) return rawResult;
+  if (!TERMINAL_RESULT_TOOLS.has(normalizedName)) return rawResult;
+  return unwrapTerminalResult(rawResult);
+}
+
+function unwrapTerminalResult(raw: string): string {
+  let result = raw;
+
+  // Unwrap JSON { output: "..." } wrapper
+  const trimmed = result.trim();
+  if (trimmed.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(trimmed) as { output?: unknown };
+      if (typeof parsed.output === 'string') {
+        result = parsed.output;
+      }
+    } catch { /* not JSON, keep as-is */ }
+  }
+
+  // Strip "Output:\n" prefix
+  const outputMarker = 'Output:\n';
+  const markerIndex = result.indexOf(outputMarker);
+  if (markerIndex >= 0) {
+    result = result.slice(markerIndex + outputMarker.length);
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Error detection
+// ---------------------------------------------------------------------------
+
+export function isCodexToolOutputError(output: string): boolean {
+  const exitCodeMatch = output.match(/(?:Exit code:|Process exited with code)\s*(\d+)/i);
+  if (exitCodeMatch) {
+    return Number(exitCodeMatch[1]) !== 0;
+  }
+
+  const trimmed = output.trim();
+
+  // Detect "Error:" / "error:" prefix
+  if (/^[Ee]rror:/.test(trimmed)) return true;
+
+  // Detect JSON { "error": ... } wrapper
+  if (trimmed.startsWith('{')) {
+    try {
+      const parsed = JSON.parse(trimmed) as Record<string, unknown>;
+      if ('error' in parsed) return true;
+    } catch { /* not JSON */ }
+  }
+
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+export function parseCodexArguments(raw: string | undefined): Record<string, unknown> {
+  if (!raw) return {};
+
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return { value: parsed };
+  } catch {
+    return { raw };
+  }
+}

package/src/providers/codex/prompt/encodeCodexTurn.ts

@@ -0,0 +1,57 @@
+import type { ChatTurnRequest, PreparedChatTurn } from '../../../core/runtime/types';
+
+function isCompactCommand(text: string): boolean {
+  return /^\/compact(\s|$)/i.test(text);
+}
+
+export function encodeCodexTurn(request: ChatTurnRequest): PreparedChatTurn {
+  const isCompact = isCompactCommand(request.text);
+
+  if (isCompact) {
+    return {
+      request,
+      persistedContent: request.text,
+      prompt: request.text,
+      isCompact: true,
+      mcpMentions: new Set(),
+    };
+  }
+
+  const sections: string[] = [];
+  sections.push(request.text);
+
+  if (request.currentNotePath) {
+    sections.push(`\n[Current note: ${request.currentNotePath}]`);
+  }
+
+  if (request.editorSelection?.selectedText) {
+    sections.push(
+      `\n[Editor selection from ${request.editorSelection.notePath || 'current note'}:\n${request.editorSelection.selectedText}\n]`,
+    );
+  }
+
+  if (request.browserSelection?.selectedText) {
+    sections.push(
+      `\n[Browser selection from ${request.browserSelection.url ?? 'unknown page'}:\n${request.browserSelection.selectedText}\n]`,
+    );
+  }
+
+  if (request.canvasSelection) {
+    const nodeList = request.canvasSelection.nodeIds.join(', ');
+    if (nodeList) {
+      sections.push(
+        `\n[Canvas selection from ${request.canvasSelection.canvasPath}:\n${nodeList}\n]`,
+      );
+    }
+  }
+
+  const prompt = sections.join('');
+
+  return {
+    request,
+    persistedContent: request.text,
+    prompt,
+    isCompact: false,
+    mcpMentions: new Set(),
+  };
+}

package/src/providers/codex/registration.ts

@@ -0,0 +1,29 @@
+import type { ProviderRegistration } from '../../core/providers/types';
+import { CodexInlineEditService } from './auxiliary/CodexInlineEditService';
+import { CodexInstructionRefineService } from './auxiliary/CodexInstructionRefineService';
+import { CodexTaskResultInterpreter } from './auxiliary/CodexTaskResultInterpreter';
+import { CodexTitleGenerationService } from './auxiliary/CodexTitleGenerationService';
+import { CODEX_PROVIDER_CAPABILITIES } from './capabilities';
+import { codexSettingsReconciler } from './env/CodexSettingsReconciler';
+import { CodexConversationHistoryService } from './history/CodexConversationHistoryService';
+import { codexSubagentLifecycleAdapter } from './normalization/codexSubagentNormalization';
+import { CodexChatRuntime } from './runtime/CodexChatRuntime';
+import { getCodexProviderSettings } from './settings';
+import { codexChatUIConfig } from './ui/CodexChatUIConfig';
+
+export const codexProviderRegistration: ProviderRegistration = {
+  displayName: 'Codex',
+  blankTabOrder: 15,
+  isEnabled: (settings) => getCodexProviderSettings(settings).enabled,
+  capabilities: CODEX_PROVIDER_CAPABILITIES,
+  environmentKeyPatterns: [/^OPENAI_/i, /^CODEX_/i],
+  chatUIConfig: codexChatUIConfig,
+  settingsReconciler: codexSettingsReconciler,
+  createRuntime: ({ plugin }) => new CodexChatRuntime(plugin),
+  createTitleGenerationService: (plugin) => new CodexTitleGenerationService(plugin),
+  createInstructionRefineService: (plugin) => new CodexInstructionRefineService(plugin),
+  createInlineEditService: (plugin) => new CodexInlineEditService(plugin),
+  historyService: new CodexConversationHistoryService(),
+  taskResultInterpreter: new CodexTaskResultInterpreter(),
+  subagentLifecycleAdapter: codexSubagentLifecycleAdapter,
+};

package/src/providers/codex/runtime/CodexAppServerProcess.ts

@@ -0,0 +1,105 @@
+import { type ChildProcess, spawn } from 'child_process';
+import type { Readable, Writable } from 'stream';
+
+import {
+  resolveWindowsCmdShimSpawnSpec,
+  terminateSpawnedProcess,
+  type WindowsCmdShimSpawnSpec,
+} from '../../../utils/windowsCmdShim';
+import type { CodexLaunchSpec } from './codexLaunchTypes';
+
+const SIGKILL_TIMEOUT_MS = 3_000;
+
+type ExitCallback = (code: number | null, signal: string | null) => void;
+
+export class CodexAppServerProcess {
+  private proc: ChildProcess | null = null;
+  private alive = false;
+  private exitCallbacks: ExitCallback[] = [];
+  private resolvedSpawnSpec: WindowsCmdShimSpawnSpec | null = null;
+
+  constructor(
+    private readonly launchSpec: Pick<CodexLaunchSpec, 'command' | 'args' | 'spawnCwd' | 'env'>,
+  ) {}
+
+  start(): void {
+    const resolvedSpawnSpec = resolveWindowsCmdShimSpawnSpec(this.launchSpec);
+    this.resolvedSpawnSpec = resolvedSpawnSpec;
+
+    this.proc = spawn(resolvedSpawnSpec.command, resolvedSpawnSpec.args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      cwd: this.launchSpec.spawnCwd,
+      env: this.launchSpec.env,
+      windowsHide: true,
+      ...(resolvedSpawnSpec.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+    });
+
+    this.alive = true;
+
+    this.proc.on('exit', (code, signal) => {
+      this.alive = false;
+      for (const cb of this.exitCallbacks) {
+        cb(code, signal);
+      }
+    });
+
+    this.proc.on('error', () => {
+      this.alive = false;
+    });
+  }
+
+  get stdin(): Writable {
+    if (!this.proc?.stdin) throw new Error('Process not started');
+    return this.proc.stdin;
+  }
+
+  get stdout(): Readable {
+    if (!this.proc?.stdout) throw new Error('Process not started');
+    return this.proc.stdout;
+  }
+
+  get stderr(): Readable {
+    if (!this.proc?.stderr) throw new Error('Process not started');
+    return this.proc.stderr;
+  }
+
+  isAlive(): boolean {
+    return this.alive;
+  }
+
+  onExit(callback: ExitCallback): void {
+    this.exitCallbacks.push(callback);
+  }
+
+  offExit(callback: ExitCallback): void {
+    const idx = this.exitCallbacks.indexOf(callback);
+    if (idx !== -1) this.exitCallbacks.splice(idx, 1);
+  }
+
+  async shutdown(): Promise<void> {
+    if (!this.proc || !this.alive) return;
+
+    return new Promise<void>((resolve) => {
+      const onExit = () => {
+        window.clearTimeout(killTimer);
+        resolve();
+      };
+
+      this.proc!.once('exit', onExit);
+      this.killProc('SIGTERM');
+
+      const killTimer = window.setTimeout(() => {
+        if (this.alive) {
+          this.killProc('SIGKILL');
+        }
+      }, SIGKILL_TIMEOUT_MS);
+    });
+  }
+
+  private killProc(signal: NodeJS.Signals): boolean {
+    if (!this.proc) {
+      return false;
+    }
+    return terminateSpawnedProcess(this.proc, signal, spawn, this.resolvedSpawnSpec);
+  }
+}