@mseep/claudian 2.0.25

package/src/providers/codex/auxiliary/CodexInlineEditService.ts

@@ -0,0 +1,9 @@
+import { QueryBackedInlineEditService } from '../../../core/auxiliary/QueryBackedInlineEditService';
+import type ClaudianPlugin from '../../../main';
+import { CodexAuxQueryRunner } from '../runtime/CodexAuxQueryRunner';
+
+export class CodexInlineEditService extends QueryBackedInlineEditService {
+  constructor(plugin: ClaudianPlugin) {
+    super(new CodexAuxQueryRunner(plugin));
+  }
+}

package/src/providers/codex/auxiliary/CodexInstructionRefineService.ts

@@ -0,0 +1,9 @@
+import { QueryBackedInstructionRefineService } from '../../../core/auxiliary/QueryBackedInstructionRefineService';
+import type ClaudianPlugin from '../../../main';
+import { CodexAuxQueryRunner } from '../runtime/CodexAuxQueryRunner';
+
+export class CodexInstructionRefineService extends QueryBackedInstructionRefineService {
+  constructor(plugin: ClaudianPlugin) {
+    super(new CodexAuxQueryRunner(plugin));
+  }
+}

package/src/providers/codex/auxiliary/CodexTaskResultInterpreter.ts

@@ -0,0 +1,29 @@
+import type {
+  ProviderTaskResultInterpreter,
+  ProviderTaskTerminalStatus,
+} from '../../../core/providers/types';
+
+export class CodexTaskResultInterpreter implements ProviderTaskResultInterpreter {
+  hasAsyncLaunchMarker(_toolUseResult: unknown): boolean {
+    return false;
+  }
+
+  extractAgentId(_toolUseResult: unknown): string | null {
+    return null;
+  }
+
+  extractStructuredResult(_toolUseResult: unknown): string | null {
+    return null;
+  }
+
+  resolveTerminalStatus(
+    _toolUseResult: unknown,
+    fallbackStatus: ProviderTaskTerminalStatus,
+  ): ProviderTaskTerminalStatus {
+    return fallbackStatus;
+  }
+
+  extractTagValue(_payload: string, _tagName: string): string | null {
+    return null;
+  }
+}

package/src/providers/codex/auxiliary/CodexTitleGenerationService.ts

@@ -0,0 +1,22 @@
+import { QueryBackedTitleGenerationService } from '../../../core/auxiliary/QueryBackedTitleGenerationService';
+import type ClaudianPlugin from '../../../main';
+import { toCodexRuntimeModelId } from '../modelSelection';
+import { CodexAuxQueryRunner } from '../runtime/CodexAuxQueryRunner';
+import { codexChatUIConfig } from '../ui/CodexChatUIConfig';
+
+export class CodexTitleGenerationService extends QueryBackedTitleGenerationService {
+  constructor(plugin: ClaudianPlugin) {
+    super({
+      createRunner: () => new CodexAuxQueryRunner(plugin),
+      resolveModel: () => {
+        const settings = plugin.settings as unknown as Record<string, unknown>;
+        const titleModel = typeof settings.titleGenerationModel === 'string'
+          ? settings.titleGenerationModel
+          : '';
+        return codexChatUIConfig.ownsModel(titleModel, settings)
+          ? toCodexRuntimeModelId(titleModel)
+          : undefined;
+      },
+    });
+  }
+}

package/src/providers/codex/capabilities.ts

@@ -0,0 +1,16 @@
+import type { ProviderCapabilities } from '../../core/providers/types';
+
+export const CODEX_PROVIDER_CAPABILITIES: Readonly<ProviderCapabilities> = Object.freeze({
+  providerId: 'codex',
+  supportsPersistentRuntime: true,
+  supportsNativeHistory: true,
+  supportsPlanMode: true,
+  supportsRewind: false,
+  supportsFork: true,
+  supportsProviderCommands: false,
+  supportsImageAttachments: true,
+  supportsInstructionMode: true,
+  supportsMcpTools: false,
+  supportsTurnSteer: true,
+  reasoningControl: 'effort',
+});

package/src/providers/codex/commands/CodexSkillCatalog.ts

@@ -0,0 +1,180 @@
+import type {
+  ProviderCommandCatalog,
+  ProviderCommandDropdownConfig,
+} from '../../../core/providers/commands/ProviderCommandCatalog';
+import type { ProviderCommandEntry } from '../../../core/providers/commands/ProviderCommandEntry';
+import type { SlashCommand } from '../../../core/types';
+import type { SkillMetadata } from '../runtime/codexAppServerTypes';
+import {
+  type CodexSkillListProvider,
+  compareCodexSkillPriority,
+  getCodexSkillDescription,
+} from '../skills/CodexSkillListingService';
+import {
+  type CodexSkillStorage,
+  createCodexSkillPersistenceKey,
+  parseCodexSkillPersistenceKey,
+  resolveCodexSkillLocationFromPath,
+} from '../storage/CodexSkillStorage';
+
+const CODEX_SKILL_ID_PREFIX = 'codex-skill-';
+
+const CODEX_COMPACT_COMMAND: ProviderCommandEntry = {
+  id: 'codex-builtin-compact',
+  providerId: 'codex',
+  kind: 'command',
+  name: 'compact',
+  description: 'Compact conversation history',
+  content: '',
+  scope: 'system',
+  source: 'builtin',
+  isEditable: false,
+  isDeletable: false,
+  displayPrefix: '/',
+  insertPrefix: '/',
+};
+
+function buildSkillId(
+  skill: Pick<SkillMetadata, 'name' | 'path' | 'scope'>,
+  location?: { rootId: string; name: string } | null,
+): string {
+  if (location) {
+    return `${CODEX_SKILL_ID_PREFIX}${location.rootId}-${location.name}`;
+  }
+
+  const encodedPath = encodeURIComponent(skill.path);
+  return `${CODEX_SKILL_ID_PREFIX}${skill.scope}-${encodedPath}`;
+}
+
+function listedSkillToProviderEntry(
+  skill: SkillMetadata,
+  vaultPath: string | null,
+): ProviderCommandEntry {
+  const location = vaultPath ? resolveCodexSkillLocationFromPath(skill.path, vaultPath) : null;
+  const isVault = skill.scope === 'repo' && location !== null;
+
+  return {
+    id: buildSkillId(skill, isVault ? location : null),
+    providerId: 'codex',
+    kind: 'skill',
+    name: skill.name,
+    description: getCodexSkillDescription(skill),
+    content: '',
+    scope: isVault ? 'vault' : 'user',
+    source: 'user',
+    isEditable: isVault,
+    isDeletable: isVault,
+    displayPrefix: '$',
+    insertPrefix: '$',
+    ...(isVault
+      ? {
+          persistenceKey: createCodexSkillPersistenceKey({
+            rootId: location.rootId,
+            currentName: location.name,
+          }),
+        }
+      : {}),
+  };
+}
+
+export class CodexSkillCatalog implements ProviderCommandCatalog {
+  constructor(
+    private storage: CodexSkillStorage,
+    private listProvider: CodexSkillListProvider,
+    private vaultPath: string | null,
+  ) {}
+
+  setRuntimeCommands(_commands: SlashCommand[]): void {
+    // Codex dropdown entries come from app-server metadata; runtime commands are ignored.
+  }
+
+  async listDropdownEntries(context: { includeBuiltIns: boolean }): Promise<ProviderCommandEntry[]> {
+    const skills = (await this.listProvider.listSkills())
+      .filter(skill => skill.enabled)
+      .sort(compareCodexSkillPriority);
+    const entries = skills.map(skill => listedSkillToProviderEntry(skill, this.vaultPath));
+    return context.includeBuiltIns ? [CODEX_COMPACT_COMMAND, ...entries] : entries;
+  }
+
+  async listVaultEntries(): Promise<ProviderCommandEntry[]> {
+    if (!this.vaultPath) {
+      return [];
+    }
+
+    const listedSkills = (await this.listProvider.listSkills())
+      .filter(skill => skill.scope === 'repo')
+      .sort(compareCodexSkillPriority);
+    const entries: ProviderCommandEntry[] = [];
+
+    for (const listedSkill of listedSkills) {
+      const location = resolveCodexSkillLocationFromPath(listedSkill.path, this.vaultPath);
+      if (!location) {
+        continue;
+      }
+
+      const storedSkill = await this.storage.load(location);
+      if (!storedSkill) {
+        continue;
+      }
+
+      entries.push({
+        id: `${CODEX_SKILL_ID_PREFIX}${location.rootId}-${storedSkill.name}`,
+        providerId: 'codex',
+        kind: 'skill',
+        name: storedSkill.name,
+        description: storedSkill.description ?? getCodexSkillDescription(listedSkill),
+        content: storedSkill.content,
+        scope: 'vault',
+        source: 'user',
+        isEditable: true,
+        isDeletable: true,
+        displayPrefix: '$',
+        insertPrefix: '$',
+        persistenceKey: createCodexSkillPersistenceKey({
+          rootId: location.rootId,
+          currentName: location.name,
+        }),
+      });
+    }
+
+    return entries;
+  }
+
+  async saveVaultEntry(entry: ProviderCommandEntry): Promise<void> {
+    const persistenceState = parseCodexSkillPersistenceKey(entry.persistenceKey);
+    await this.storage.save({
+      name: entry.name,
+      description: entry.description,
+      content: entry.content,
+      rootId: persistenceState?.rootId,
+      previousLocation: persistenceState?.currentName
+        ? { rootId: persistenceState.rootId, name: persistenceState.currentName }
+        : undefined,
+    });
+    this.listProvider.invalidate();
+  }
+
+  async deleteVaultEntry(entry: ProviderCommandEntry): Promise<void> {
+    const persistenceState = parseCodexSkillPersistenceKey(entry.persistenceKey);
+    await this.storage.delete({
+      name: persistenceState?.currentName ?? entry.name,
+      rootId: persistenceState?.rootId ?? 'vault-codex',
+    });
+    this.listProvider.invalidate();
+  }
+
+  getDropdownConfig(): ProviderCommandDropdownConfig {
+    return {
+      providerId: 'codex',
+      triggerChars: ['/', '$'],
+      builtInPrefix: '/',
+      skillPrefix: '$',
+      commandPrefix: '/',
+    };
+  }
+
+  async refresh(): Promise<void> {
+    this.listProvider.invalidate();
+    await this.listProvider.listSkills({ forceReload: true });
+  }
+}

package/src/providers/codex/env/CodexSettingsReconciler.ts

@@ -0,0 +1,68 @@
+import { getRuntimeEnvironmentText } from '../../../core/providers/providerEnvironment';
+import type { ProviderSettingsReconciler } from '../../../core/providers/types';
+import type { Conversation } from '../../../core/types';
+import { parseEnvironmentVariables } from '../../../utils/env';
+import { resolveCodexModelSelection } from '../modelOptions';
+import { getCodexProviderSettings, updateCodexProviderSettings } from '../settings';
+import { getCodexState } from '../types';
+import { codexChatUIConfig } from '../ui/CodexChatUIConfig';
+
+const ENV_HASH_KEYS = ['OPENAI_MODEL', 'OPENAI_BASE_URL', 'OPENAI_API_KEY'];
+
+function computeCodexEnvHash(envText: string): string {
+  const envVars = parseEnvironmentVariables(envText || '');
+  return ENV_HASH_KEYS
+    .filter(key => envVars[key])
+    .map(key => `${key}=${envVars[key]}`)
+    .sort()
+    .join('|');
+}
+
+export const codexSettingsReconciler: ProviderSettingsReconciler = {
+  reconcileModelWithEnvironment(
+    settings: Record<string, unknown>,
+    conversations: Conversation[],
+  ): { changed: boolean; invalidatedConversations: Conversation[] } {
+    const envText = getRuntimeEnvironmentText(settings, 'codex');
+    const currentHash = computeCodexEnvHash(envText);
+    const savedHash = getCodexProviderSettings(settings).environmentHash;
+
+    if (currentHash === savedHash) {
+      return { changed: false, invalidatedConversations: [] };
+    }
+
+    const invalidatedConversations: Conversation[] = [];
+    for (const conv of conversations) {
+      const state = getCodexState(conv.providerState);
+      if (conv.providerId === 'codex' && (conv.sessionId || state.threadId)) {
+        conv.sessionId = null;
+        conv.providerState = undefined;
+        invalidatedConversations.push(conv);
+      }
+    }
+
+    const currentModel = typeof settings.model === 'string' ? settings.model : '';
+    const nextModel = resolveCodexModelSelection(settings, currentModel);
+    if (nextModel) {
+      settings.model = nextModel;
+    }
+
+    updateCodexProviderSettings(settings, { environmentHash: currentHash });
+    return { changed: true, invalidatedConversations };
+  },
+
+  normalizeModelVariantSettings(settings: Record<string, unknown>): boolean {
+    const model = settings.model as string;
+    if (!model) {
+      return false;
+    }
+
+    const normalizedModel = codexChatUIConfig.normalizeModelVariant(model, settings);
+    if (normalizedModel === model) {
+      return false;
+    }
+
+    settings.model = normalizedModel;
+    return true;
+  },
+};

package/src/providers/codex/history/CodexConversationHistoryService.ts

@@ -0,0 +1,212 @@
+import * as fs from 'fs';
+
+import type { ProviderConversationHistoryService } from '../../../core/providers/types';
+import type { Conversation } from '../../../core/types';
+import type { CodexProviderState } from '../types';
+import { getCodexState } from '../types';
+import {
+  type CodexParsedTurn,
+  deriveCodexSessionsRootFromSessionPath,
+  findCodexSessionFile,
+  parseCodexSessionFile,
+  parseCodexSessionTurns,
+} from './CodexHistoryStore';
+
+function readSessionTurns(sessionFilePath: string): CodexParsedTurn[] {
+  let content: string;
+  try {
+    content = fs.readFileSync(sessionFilePath, 'utf-8');
+  } catch {
+    return [];
+  }
+  return parseCodexSessionTurns(content);
+}
+
+export class CodexConversationHistoryService implements ProviderConversationHistoryService {
+  private hydratedConversationPaths = new Map<string, string>();
+
+  async hydrateConversationHistory(
+    conversation: Conversation,
+    _vaultPath: string | null,
+  ): Promise<void> {
+    const state = getCodexState(conversation.providerState);
+    const transcriptRootPath = state.transcriptRootPath
+      ?? deriveCodexSessionsRootFromSessionPath(state.sessionFilePath);
+
+    // Pending fork with existing in-memory messages: keep them as-is
+    if (this.isPendingForkConversation(conversation) && conversation.messages.length > 0) {
+      return;
+    }
+
+    // Pending fork without messages: hydrate from source transcript truncated at resumeAt
+    if (this.isPendingForkConversation(conversation)) {
+      const sourceSessionFile = this.resolveSourceSessionFile(state);
+      if (!sourceSessionFile) return;
+
+      const turns = readSessionTurns(sourceSessionFile);
+      const resumeAt = state.forkSource!.resumeAt;
+      const truncated = this.truncateTurnsAtCheckpoint(turns, resumeAt);
+      if (!truncated) {
+        this.hydratedConversationPaths.delete(conversation.id);
+        return;
+      }
+      conversation.messages = truncated.flatMap(t => t.messages);
+      return;
+    }
+
+    // Established fork: source prefix + fork-only turns
+    if (state.forkSource && state.threadId) {
+      const sourceSessionFile = this.resolveSourceSessionFile(state);
+      const forkSessionFile = state.sessionFilePath ?? (
+        state.threadId
+          ? findCodexSessionFile(state.threadId, transcriptRootPath ?? undefined)
+          : null
+      );
+
+      if (sourceSessionFile && forkSessionFile) {
+        const sourceTurns = readSessionTurns(sourceSessionFile);
+        const forkTurns = readSessionTurns(forkSessionFile);
+
+        const resumeAt = state.forkSource.resumeAt;
+        const sourcePrefix = this.truncateTurnsAtCheckpoint(sourceTurns, resumeAt);
+        if (!sourcePrefix) {
+          this.hydratedConversationPaths.delete(conversation.id);
+          return;
+        }
+        const sourceTurnIds = new Set(sourceTurns.map(t => t.turnId).filter(Boolean));
+        const forkOnlyTurns = forkTurns.filter(t => !t.turnId || !sourceTurnIds.has(t.turnId));
+
+        const messages = [
+          ...sourcePrefix.flatMap(t => t.messages),
+          ...forkOnlyTurns.flatMap(t => t.messages),
+        ];
+
+        if (messages.length === 0) {
+          this.hydratedConversationPaths.delete(conversation.id);
+          return;
+        }
+
+        conversation.messages = messages;
+        this.hydratedConversationPaths.set(conversation.id, `fork::${state.threadId}`);
+        return;
+      }
+    }
+
+    // Normal hydration
+    const threadId = state.threadId ?? conversation.sessionId ?? null;
+    const sessionFilePath = state.sessionFilePath ?? (
+      threadId
+        ? findCodexSessionFile(threadId, transcriptRootPath ?? undefined)
+        : null
+    );
+    const resolvedTranscriptRootPath = transcriptRootPath
+      ?? deriveCodexSessionsRootFromSessionPath(sessionFilePath);
+
+    if (!sessionFilePath) {
+      this.hydratedConversationPaths.delete(conversation.id);
+      return;
+    }
+
+    const hydrationKey = `${threadId ?? ''}::${sessionFilePath}`;
+    if (
+      conversation.messages.length > 0
+      && this.hydratedConversationPaths.get(conversation.id) === hydrationKey
+    ) {
+      return;
+    }
+
+    if (sessionFilePath !== state.sessionFilePath) {
+      conversation.providerState = {
+        ...(conversation.providerState ?? {}),
+        ...(threadId ? { threadId } : {}),
+        sessionFilePath,
+        ...(resolvedTranscriptRootPath ? { transcriptRootPath: resolvedTranscriptRootPath } : {}),
+      };
+    } else if (resolvedTranscriptRootPath && resolvedTranscriptRootPath !== state.transcriptRootPath) {
+      conversation.providerState = {
+        ...(conversation.providerState ?? {}),
+        ...(threadId ? { threadId } : {}),
+        transcriptRootPath: resolvedTranscriptRootPath,
+      };
+    }
+
+    const sdkMessages = parseCodexSessionFile(sessionFilePath);
+    if (sdkMessages.length === 0) {
+      this.hydratedConversationPaths.delete(conversation.id);
+      return;
+    }
+
+    conversation.messages = sdkMessages;
+    this.hydratedConversationPaths.set(conversation.id, hydrationKey);
+  }
+
+  async deleteConversationSession(
+    _conversation: Conversation,
+    _vaultPath: string | null,
+  ): Promise<void> {
+    // Never delete ~/.codex transcripts
+  }
+
+  resolveSessionIdForConversation(conversation: Conversation | null): string | null {
+    if (!conversation) return null;
+    const state = getCodexState(conversation.providerState);
+    return state.threadId ?? conversation.sessionId ?? state.forkSource?.sessionId ?? null;
+  }
+
+  isPendingForkConversation(conversation: Conversation): boolean {
+    const state = getCodexState(conversation.providerState);
+    return !!state.forkSource && !state.threadId && !conversation.sessionId;
+  }
+
+  buildForkProviderState(
+    sourceSessionId: string,
+    resumeAt: string,
+    sourceProviderState?: Record<string, unknown>,
+  ): Record<string, unknown> {
+    const sourceState = getCodexState(sourceProviderState);
+    const sourceTranscriptRootPath = sourceState.transcriptRootPath
+      ?? deriveCodexSessionsRootFromSessionPath(sourceState.sessionFilePath);
+    const providerState: CodexProviderState = {
+      forkSource: { sessionId: sourceSessionId, resumeAt },
+      ...(sourceState.sessionFilePath ? { forkSourceSessionFilePath: sourceState.sessionFilePath } : {}),
+      ...(
+        sourceTranscriptRootPath
+          ? { forkSourceTranscriptRootPath: sourceTranscriptRootPath }
+          : {}
+      ),
+    };
+    return providerState as Record<string, unknown>;
+  }
+
+  buildPersistedProviderState(
+    conversation: Conversation,
+  ): Record<string, unknown> | undefined {
+    const entries = Object.entries(getCodexState(conversation.providerState))
+      .filter(([, value]) => value !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+
+  private resolveSourceSessionFile(state: CodexProviderState): string | null {
+    if (!state.forkSource) return null;
+    const sourceTranscriptRootPath = state.forkSourceTranscriptRootPath
+      ?? deriveCodexSessionsRootFromSessionPath(state.forkSourceSessionFilePath);
+    return state.forkSourceSessionFilePath
+      ?? findCodexSessionFile(state.forkSource.sessionId, sourceTranscriptRootPath ?? undefined);
+  }
+
+  private truncateTurnsAtCheckpoint(
+    turns: CodexParsedTurn[],
+    resumeAt: string,
+  ): CodexParsedTurn[] | null {
+    const checkpointIndex = turns.findIndex(turn => turn.turnId === resumeAt);
+    if (checkpointIndex < 0) {
+      return null;
+    }
+
+    return turns.slice(0, checkpointIndex + 1);
+  }
+}