@golba98/codexa 1.0.4 → 1.0.5

package/src/core/models/codexModelsCacheSeed.ts

@@ -0,0 +1,153 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { formatReasoningLabel } from "../../config/settings.js";
+import type { ProviderModel } from "../providerRuntime/types.js";
+import type {
+  CodexModelCapabilities,
+  CodexModelCapability,
+  ReasoningEffortCapability,
+} from "./codexModelCapabilities.js";
+import { loadCachedProviderModels, type CachedProviderModels } from "./providerModelCache.js";
+
+// The codex CLI maintains its own model catalog cache with slugs, labels and
+// reasoning levels. Reading it seeds Codexa's OpenAI model list instantly —
+// no subprocess — and stays current because the codex CLI refreshes the file
+// on its own runs.
+// Resolved per call from env (matching claudeCodeDiscovery) so HOME
+// redirection in tests holds — Bun's homedir() ignores runtime HOME changes.
+export function getCodexModelsCacheFile(): string {
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? homedir();
+  return join(home, ".codex", "models_cache.json");
+}
+
+interface CodexSeed {
+  fetchedAt: number;
+  models: readonly ProviderModel[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asString(value: unknown): string | null {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function parseReasoningLevels(raw: unknown): readonly ReasoningEffortCapability[] | null {
+  if (!Array.isArray(raw)) {
+    return null;
+  }
+  const levels = raw
+    .map((entry): ReasoningEffortCapability | null => {
+      if (!isRecord(entry)) {
+        return null;
+      }
+      const id = asString(entry.effort);
+      if (!id) {
+        return null;
+      }
+      return { id, label: formatReasoningLabel(id), description: asString(entry.description) };
+    })
+    .filter((entry): entry is ReasoningEffortCapability => entry !== null);
+  return levels.length > 0 ? levels : null;
+}
+
+function parseSeedModel(raw: unknown): ProviderModel | null {
+  if (!isRecord(raw)) {
+    return null;
+  }
+  // Models with visibility "hide" are internal codex routes (e.g. auto-review).
+  if (asString(raw.visibility) === "hide") {
+    return null;
+  }
+  const modelId = asString(raw.slug);
+  if (!modelId) {
+    return null;
+  }
+  return {
+    id: modelId,
+    modelId,
+    label: asString(raw.display_name) ?? modelId,
+    description: asString(raw.description),
+    defaultReasoningLevel: asString(raw.default_reasoning_level),
+    supportedReasoningLevels: parseReasoningLevels(raw.supported_reasoning_levels),
+    source: "discovered",
+  };
+}
+
+export function loadCodexSeedModels(cacheFile = getCodexModelsCacheFile()): CodexSeed | null {
+  try {
+    if (!existsSync(cacheFile)) {
+      return null;
+    }
+    const parsed: unknown = JSON.parse(readFileSync(cacheFile, "utf8"));
+    if (!isRecord(parsed) || !Array.isArray(parsed.models)) {
+      return null;
+    }
+    const models = parsed.models
+      .map(parseSeedModel)
+      .filter((model): model is ProviderModel => model !== null);
+    if (models.length === 0) {
+      return null;
+    }
+    const fetchedAtRaw = asString(parsed.fetched_at);
+    const fetchedAt = fetchedAtRaw ? Date.parse(fetchedAtRaw) : Number.NaN;
+    return { fetchedAt: Number.isFinite(fetchedAt) ? fetchedAt : 0, models };
+  } catch {
+    return null;
+  }
+}
+
+// Freshest locally known OpenAI models without spawning a subprocess:
+// codex's own cache file vs Codexa's persisted last-good discovery.
+export function loadSeededOpenAiModels(options: {
+  codexCacheFile?: string;
+  providerCacheFile?: string;
+} = {}): CachedProviderModels | null {
+  const seed = loadCodexSeedModels(options.codexCacheFile);
+  const persisted = options.providerCacheFile === undefined
+    ? loadCachedProviderModels("openai")
+    : loadCachedProviderModels("openai", options.providerCacheFile);
+  if (seed && (!persisted || seed.fetchedAt >= persisted.discoveredAt)) {
+    return { discoveredAt: seed.fetchedAt, models: seed.models };
+  }
+  return persisted;
+}
+
+function toCapability(model: ProviderModel, index: number): CodexModelCapability {
+  return {
+    id: model.id,
+    model: model.modelId,
+    label: model.label,
+    description: model.description,
+    available: true,
+    hidden: false,
+    isDefault: index === 0,
+    defaultReasoningLevel: model.defaultReasoningLevel,
+    supportedReasoningLevels: model.supportedReasoningLevels,
+    reasoningLevelCount: model.supportedReasoningLevels ? model.supportedReasoningLevels.length : null,
+    source: "runtime",
+    raw: model,
+  };
+}
+
+// Capabilities for the OpenAI picker sourced purely from local caches.
+// Returns null when nothing is cached yet (first ever launch).
+export function loadSeededCodexCapabilities(options: {
+  codexCacheFile?: string;
+  providerCacheFile?: string;
+} = {}): CodexModelCapabilities | null {
+  const seeded = loadSeededOpenAiModels(options);
+  if (!seeded) {
+    return null;
+  }
+  return {
+    status: "ready",
+    source: "runtime",
+    models: seeded.models.map(toCapability),
+    discoveredAt: seeded.discoveredAt,
+    executable: null,
+    error: null,
+  };
+}

package/src/core/models/providerModelCache.ts

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ProviderId } from "../providerLauncher/types.js";
+import type { ProviderModel } from "../providerRuntime/types.js";
+
+// Persistent last-good model discovery results, one entry per provider.
+// Lets pickers open instantly with the previous session's discovered models
+// while a background refresh runs. Corrupt or missing cache degrades to null.
+// Resolved per call from env (matching claudeCodeDiscovery) so HOME
+// redirection in tests holds — Bun's homedir() ignores runtime HOME changes.
+export function getProviderModelCacheFile(): string {
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? homedir();
+  return join(home, ".codexa-model-cache.json");
+}
+
+const CACHE_VERSION = 1;
+
+export interface CachedProviderModels {
+  discoveredAt: number;
+  models: readonly ProviderModel[];
+}
+
+interface ProviderModelCacheFile {
+  version: number;
+  providers: Partial<Record<ProviderId, CachedProviderModels>>;
+}
+
+function readCacheFile(cacheFile: string): ProviderModelCacheFile | null {
+  try {
+    if (!existsSync(cacheFile)) {
+      return null;
+    }
+    const parsed: unknown = JSON.parse(readFileSync(cacheFile, "utf8"));
+    if (
+      typeof parsed !== "object" || parsed === null || Array.isArray(parsed)
+      || (parsed as ProviderModelCacheFile).version !== CACHE_VERSION
+      || typeof (parsed as ProviderModelCacheFile).providers !== "object"
+      || (parsed as ProviderModelCacheFile).providers === null
+    ) {
+      return null;
+    }
+    return parsed as ProviderModelCacheFile;
+  } catch {
+    return null;
+  }
+}
+
+// A model id is passed straight to a provider CLI, so it must be a bare token.
+// Discovery scrapes CLI output, and a buggy build can bake an ANSI escape into
+// an id (e.g. "claude-fable-5\x1b[1m"). Reject rather than repair: a cached id
+// we cannot vouch for is dropped so discovery re-probes for a clean one.
+const VALID_MODEL_ID = /^[A-Za-z0-9._:\/-]+$/;
+
+function isUsableModel(model: unknown): model is ProviderModel {
+  if (typeof model !== "object" || model === null) {
+    return false;
+  }
+  const candidate = model as ProviderModel;
+  return typeof candidate.id === "string"
+    && typeof candidate.modelId === "string"
+    && typeof candidate.label === "string"
+    && VALID_MODEL_ID.test(candidate.id)
+    && VALID_MODEL_ID.test(candidate.modelId);
+}
+
+function isValidEntry(entry: unknown): entry is CachedProviderModels {
+  if (typeof entry !== "object" || entry === null) {
+    return false;
+  }
+  const candidate = entry as CachedProviderModels;
+  return typeof candidate.discoveredAt === "number" && Array.isArray(candidate.models);
+}
+
+export function loadCachedProviderModels(
+  providerId: ProviderId,
+  cacheFile = getProviderModelCacheFile(),
+): CachedProviderModels | null {
+  const cache = readCacheFile(cacheFile);
+  const entry = cache?.providers?.[providerId];
+  if (!entry || !isValidEntry(entry)) {
+    return null;
+  }
+  const models = entry.models.filter(isUsableModel);
+  if (models.length === 0) {
+    return null;
+  }
+  return { discoveredAt: entry.discoveredAt, models };
+}
+
+export function saveCachedProviderModels(
+  providerId: ProviderId,
+  entry: CachedProviderModels,
+  cacheFile = getProviderModelCacheFile(),
+): void {
+  if (entry.models.length === 0) {
+    return;
+  }
+  try {
+    const cache = readCacheFile(cacheFile) ?? { version: CACHE_VERSION, providers: {} };
+    cache.providers[providerId] = entry;
+    writeFileSync(cacheFile, `${JSON.stringify(cache, null, 2)}\n`, "utf8");
+  } catch {
+    // Persistence is best-effort; discovery still works without it.
+  }
+}

package/src/core/process/CommandRunner.ts

@@ -9,6 +9,7 @@ export interface CommandSpec {
   cwd: string;
   env?: NodeJS.ProcessEnv;
   timeoutMs?: number;
+  stdinData?: string;
 }
 
 export interface CommandResult {
@@ -177,10 +178,20 @@ function runProcess(
     cwd: spec.cwd,
     env: spec.env,
     shell: false,
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: [spec.stdinData !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
   });
   handlers.onProcessLifecycle?.("spawned");
 
+  if (spec.stdinData !== undefined) {
+    try {
+      child.stdin?.on("error", () => { /* EPIPE when the process exits before reading stdin */ });
+      child.stdin?.write(spec.stdinData);
+      child.stdin?.end();
+    } catch {
+      // stdin already closed; the close/error handlers report the outcome
+    }
+  }
+
   const result = new Promise<CommandResult>((resolve) => {
     const finish = (partial: Omit<CommandResult, "stdout" | "stderr" | "startedAt" | "endedAt" | "durationMs" | "userMessage"> & { endedAt?: number }) => {
       if (timeoutHandle) clearTimeout(timeoutHandle);

package/src/core/providerLauncher/registry.ts

@@ -16,14 +16,15 @@ import {
 } from "../providerRuntime/registry.js";
 import { normalizeGeminiModelId } from "../providerRuntime/models.js";
 import { ANTIGRAVITY_DEFAULT_MODEL_ID } from "../providerRuntime/antigravity.js";
+import { discoverMistralVibeModels } from "../providerRuntime/mistralVibe.js";
 import { setLocalProviderConfig } from "../providerRuntime/local.js";
 import { formatContextLength, resolveModelContextLengthCached } from "../providerRuntime/contextMetadata.js";
 import { resolveModelCapabilityProfileCached } from "../providerRuntime/capabilityProfile.js";
 
 // Google/Gemini remains a recognized legacy config value so existing workspace
 // files can be migrated, but it is no longer a selectable Codexa provider.
-const PROVIDER_ORDER: readonly ProviderId[] = ["openai", "anthropic", "local", "antigravity"];
-const KNOWN_PROVIDER_IDS: readonly ProviderId[] = ["openai", "anthropic", "google", "local", "antigravity"];
+const PROVIDER_ORDER: readonly ProviderId[] = ["openai", "anthropic", "mistral", "local", "antigravity"];
+const KNOWN_PROVIDER_IDS: readonly ProviderId[] = ["openai", "anthropic", "google", "mistral", "local", "antigravity"];
 
 const DEFAULT_PROVIDER_ID: ProviderId = "openai";
 
@@ -78,6 +79,17 @@ const DEFAULT_PROVIDERS: Record<ProviderId, ProviderDefault> = {
     isActiveRoute: false,
     routeUnavailableReason: "Local provider unavailable. Start LM Studio, load a model, and enable the local server.",
   },
+  mistral: {
+    id: "mistral",
+    displayName: "Mistral Vibe CLI",
+    currentModel: () => "Vibe default",
+    backendType: "mistral-vibe-cli-auth",
+    routeMode: "in-codexa",
+    enabled: true,
+    launchCommand: { executable: "vibe", args: [] },
+    isActiveRoute: false,
+    routeUnavailableReason: null,
+  },
   antigravity: {
     id: "antigravity",
     displayName: "Antigravity",
@@ -137,9 +149,11 @@ function applyOverride(
       : provider.currentModel,
     enabled: nextEnabled,
     launchCommand: nextCommand,
-    statusLabel: nextEnabled
-      ? (provider.routeUnavailableReason ? "Needs config" : "Enabled")
-      : "Disabled",
+    statusLabel: !nextEnabled
+      ? "Disabled"
+      : provider.routeMode === "launch-only"
+        ? provider.statusLabel
+        : (provider.routeUnavailableReason ? "Needs config" : "Enabled"),
   };
 }
 
@@ -157,6 +171,7 @@ export function getActiveRouteProviderId(config: ProviderWorkspaceConfig | null
 
 export function buildProviderRegistry(options: {
   activeModel: string;
+  workspaceRoot?: string;
   workspaceConfig?: ProviderWorkspaceConfig | null;
   diagnostics?: Record<string, Record<string, string | number | boolean | null>>;
   routeErrors?: Record<string, string>;
@@ -170,7 +185,9 @@ export function buildProviderRegistry(options: {
     }
     const defaults = DEFAULT_PROVIDERS[id];
     const runtime = getProviderRuntime(id);
-    const discovery = runtime.discoverModels();
+    const discovery = id === "mistral"
+      ? discoverMistralVibeModels(options.workspaceRoot ?? process.cwd())
+      : runtime.discoverModels();
 
     const activeRoute = options.workspaceConfig?.activeRoute;
     const isThisActive = activeRoute?.providerId === id;
@@ -205,6 +222,10 @@ export function buildProviderRegistry(options: {
       }
     }
 
+    if (id === "mistral") {
+      currentModelLabel = discovery.models[0]?.modelId ?? "Vibe default";
+    }
+
     const rawMetadataForModel = discovery.models.find((model) => model.modelId === currentModelLabel)?.raw;
     const contextMetadata = resolveModelContextLengthCached({
       providerId: id,
@@ -230,7 +251,16 @@ export function buildProviderRegistry(options: {
 
     const enabled = id === "local" ? discovery.status === "ready" : defaults.enabled;
 
-    const statusLabel = id === "local"
+    const availabilityStatus = options.diagnostics?.[id]?.availabilityStatus;
+    const statusLabel = id === "mistral"
+      ? availabilityStatus === "checking"
+        ? "Checking"
+        : availabilityStatus === "unavailable"
+          ? "Missing"
+          : routeUnavailableReason
+            ? "Needs config"
+            : "Enabled"
+      : id === "local"
       ? (discovery.status === "ready" ? "Enabled" : "Disabled")
       : !defaults.enabled
         ? "Disabled"

package/src/core/providerLauncher/types.ts

@@ -1,9 +1,10 @@
-export type ProviderId = "openai" | "anthropic" | "google" | "local" | "antigravity";
+export type ProviderId = "openai" | "anthropic" | "google" | "mistral" | "local" | "antigravity";
 
 export type ProviderBackendType =
   | "codex-cli-auth"
   | "gemini-cli-auth"
   | "claude-code-auth"
+  | "mistral-vibe-cli-auth"
   | "antigravity-cli-auth"
   | "openai-api-key"
   | "gemini-api-key"

package/src/core/providerRuntime/anthropic.ts

@@ -4,7 +4,6 @@ import type { BackendRunHandlers } from "../providers/types.js";
 import { ANTHROPIC_FALLBACK_MODELS } from "./models.js";
 import type { ProviderBackendKind, ProviderChatRequest, ProviderModel, ProviderModelDiscoveryResult, ProviderRouteValidationResult, ProviderRuntime } from "./types.js";
 import { buildClaudeSpawnSpec, resetClaudeExecutableCacheForTests } from "../executables/claudeExecutable.js";
-import { CLAUDE_CODE_EFFORT_IDS } from "./reasoning.js";
 import {
   claudeCodeModelsToProviderModels,
   discoverClaudeCodeCapabilities,
@@ -56,10 +55,9 @@ export function mapModelIdToClaudeArg(modelId: string): string {
   return modelId;
 }
 
-export function mapReasoningToEffort(reasoning: string | null | undefined): string | null {
-  if (reasoning && CLAUDE_CODE_EFFORT_IDS.has(reasoning)) return reasoning;
-  return null;
-}
+export function mapReasoningToEffort(reasoning: string | null | undefined): string | null {
+  return reasoning?.trim() || null;
+}
 
 function buildClaudeCodeBaseArgs(request: ProviderChatRequest): string[] {
   const effort = mapReasoningToEffort(request.route.reasoning ?? null);