@golba98/codexa 1.0.4 → 1.0.6

package/src/commands/handler.ts

@@ -18,7 +18,6 @@ import {
   AUTH_PREFERENCES,
   AVAILABLE_BACKENDS,
   AVAILABLE_MODELS,
-  AVAILABLE_REASONING_LEVELS,
   AVAILABLE_THEMES,
   BUSY_LOADER_SETTING_VALUES,
   WORKSPACE_DISPLAY_MODES,
@@ -150,10 +149,6 @@ function expandReasoningAliases(arg: string): string {
   return normalized === "extra high" ? "xhigh" : normalized;
 }
 
-function isKnownFallbackReasoning(value: string): boolean {
-  return AVAILABLE_REASONING_LEVELS.some((item) => item.id === value);
-}
-
 function simplePolicySetter<T extends string>(
   rest: string,
   normalizedRest: string,
@@ -396,12 +391,12 @@ function buildHelpMessage(context: CommandContext): string {
     `  Current reasoning: ${formatReasoningLabel(context.runtime.reasoningLevel)}`,
     `  Current plan mode: ${context.runtime.planMode ? "Enabled" : "Disabled"}`,
     "  /copy              Copy last response to clipboard",
-    "  /update [check]    Show update status and instructions for updating Codexa",
+    "  /update [status]   Check for updates and install the latest Codexa (status: cached result only)",
     "  /help              Show this help",
-    "",
-    "Local development:",
-    "  npm run install:dev-bin  Install the codexa-dev command",
-    "  codexa-dev               Run this repo without replacing codexa",
+    "",
+    "Local development:",
+    "  npm run install:dev-bin  Install the codexa-dev command",
+    "  codexa-dev               Run this repo without replacing codexa",
     "",
     "Shortcuts:",
     "  Ctrl+B    Open backend picker",
@@ -520,16 +515,10 @@ export function handleCommand(text: string, context: CommandContext): CommandRes
             message: `Unknown reasoning level for ${context.runtime.model}: ${arg}. Valid: ${valid}`,
           };
         }
-        if (isKnownFallbackReasoning(normalized)) {
-          return {
-            action: "reasoning",
-            value: normalized,
-            message: `Reasoning level switched to ${formatReasoningLabel(normalized)} (runtime metadata unavailable)`,
-          };
-        }
         return {
-          action: "unknown",
-          message: `Unknown reasoning level: ${arg}. Runtime reasoning metadata is unavailable for ${context.runtime.model}.`,
+          action: "reasoning",
+          value: normalized,
+          message: `Reasoning level switched to ${formatReasoningLabel(normalized)} (runtime metadata unavailable; unverified until runtime)`,
         };
       }
 
@@ -857,7 +846,9 @@ export function handleCommand(text: string, context: CommandContext): CommandRes
         return { action: "help", message: buildHelpMessage(context) };
 
       case "update":
-        return { action: "update", value: normalizedArg || "status" };
+        // Bare /update forces a fresh registry check; /update status is the
+        // explicit no-network path that reuses the cached/in-memory result.
+        return { action: "update", value: normalizedArg || "check" };
 
       default:
         return {

package/src/config/appVersion.ts

@@ -0,0 +1,65 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { APP_VERSION as BUILD_INFO_VERSION } from "./buildInfo.js";
+
+// Leaf module: must not import settings.ts or anything under src/core/version
+// (settings.ts re-exports APP_VERSION from here, so that would be a cycle).
+
+const CODEXA_PACKAGE_NAME = "@golba98/codexa";
+const SEMVER_RE = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+
+function readPackageVersion(packageJsonPath: string, requireName?: string): string | null {
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+      name?: unknown;
+      version?: unknown;
+    };
+    if (requireName !== undefined && parsed.name !== requireName) return null;
+    if (typeof parsed.version !== "string") return null;
+    const version = parsed.version.trim();
+    return SEMVER_RE.test(version) ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolves the version of the running Codexa install:
+ * 1. `CODEXA_PACKAGE_ROOT` (set by bin/codexa.js) → that package.json's version
+ * 2. Walk up from this module for a package.json named "@golba98/codexa" (local dev)
+ * 3. The committed buildInfo.ts APP_VERSION as the last resort
+ *
+ * `startDir` overrides the walk-up starting directory (test seam).
+ */
+export function resolveAppVersion(
+  env: NodeJS.ProcessEnv = process.env,
+  startDir?: string,
+): string {
+  const packageRoot = env.CODEXA_PACKAGE_ROOT?.trim();
+  if (packageRoot) {
+    const version = readPackageVersion(join(packageRoot, "package.json"));
+    if (version) return version;
+  }
+
+  let dir = startDir ?? dirname(fileURLToPath(import.meta.url));
+  for (;;) {
+    const version = readPackageVersion(join(dir, "package.json"), CODEXA_PACKAGE_NAME);
+    if (version) return version;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return BUILD_INFO_VERSION;
+}
+
+let cachedVersion: string | null = null;
+
+/** Cached form of resolveAppVersion() — the installed version cannot change mid-process. */
+export function getAppVersion(): string {
+  if (cachedVersion === null) {
+    cachedVersion = resolveAppVersion();
+  }
+  return cachedVersion;
+}

package/src/config/buildInfo.ts

@@ -1,3 +1,3 @@
 // Generated by scripts/gen-build-info.mjs — do not edit manually.
-export const BUILD_COMMIT = "b066a15b77696d2a0945ea7c6c3d07630584296b" as const;
-export const APP_VERSION = "1.0.4" as const;
+export const BUILD_COMMIT = "8a275f0a19434d0cf59ff59cebe1aae734559bde" as const;
+export const APP_VERSION = "1.0.6" as const;

package/src/config/settings.ts

@@ -9,7 +9,11 @@ function smartJoin(base: string, ...parts: string[]): string {
   return isWindowsStylePath(base) ? win32.join(base, ...parts) : join(base, ...parts);
 }
 
-export { APP_VERSION } from "./buildInfo.js";
+import { getAppVersion } from "./appVersion.js";
+
+// Authoritative runtime version: resolved from the installed package.json at
+// startup (buildInfo.ts is only the committed fallback and can drift).
+export const APP_VERSION: string = getAppVersion();
 export const APP_NAME = "Codexa";
 export const DEFAULT_BACKEND = "codex-subprocess";
 export const DEFAULT_MODEL = "gpt-5.4";

package/src/config/updateCheckCache.ts

@@ -9,11 +9,16 @@ export interface UpdateCheckCache {
   updateAvailable: boolean;
 }
 
-const CACHE_FILE = join(homedir(), ".codexa-update-check.json");
+// Resolved per call (not at module load) so HOME changes — e.g. test isolation —
+// are honored. See the same pattern in src/core/models/providerModelCache.ts.
+export function getUpdateCheckCacheFilePath(): string {
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? homedir();
+  return join(home, ".codexa-update-check.json");
+}
 
-export function loadUpdateCheckCache(): UpdateCheckCache | null {
+export function loadUpdateCheckCache(filePath = getUpdateCheckCacheFilePath()): UpdateCheckCache | null {
   try {
-    const text = readFileSync(CACHE_FILE, "utf-8");
+    const text = readFileSync(filePath, "utf-8");
     const data = JSON.parse(text) as Record<string, unknown>;
     if (typeof data.lastChecked !== "number") return null;
     if (typeof data.currentVersion !== "string") return null;
@@ -28,12 +33,12 @@ export function loadUpdateCheckCache(): UpdateCheckCache | null {
   }
 }
 
-export function saveUpdateCheckCache(cache: UpdateCheckCache): void {
+export function saveUpdateCheckCache(cache: UpdateCheckCache, filePath = getUpdateCheckCacheFilePath()): void {
   try {
-    mkdirSync(dirname(CACHE_FILE), { recursive: true });
-    const tmp = `${CACHE_FILE}.tmp`;
+    mkdirSync(dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp`;
     writeFileSync(tmp, JSON.stringify(cache, null, 2), "utf-8");
-    renameSync(tmp, CACHE_FILE);
+    renameSync(tmp, filePath);
   } catch {
     // Best-effort — never crash on cache write failure.
   }
@@ -43,6 +48,11 @@ function stripV(v: string): string {
   return v.startsWith("v") ? v.slice(1) : v;
 }
 
+/** Returns true when a cache entry was created by the running Codexa version. */
+export function isCacheForRunningVersion(cache: UpdateCheckCache, runningVersion: string): boolean {
+  return stripV(cache.currentVersion) === stripV(runningVersion);
+}
+
 /**
  * Returns true only when the cache is still usable:
  * - `runningVersion` matches the version the cache was written for (version-mismatch = stale)
@@ -54,7 +64,7 @@ export function isCacheValid(
   runningVersion?: string,
 ): boolean {
   if (runningVersion !== undefined) {
-    if (stripV(cache.currentVersion) !== stripV(runningVersion)) {
+    if (!isCacheForRunningVersion(cache, runningVersion)) {
       return false;
     }
   }

package/src/core/models/codexModelCapabilities.ts

@@ -1,6 +1,9 @@
 import { type ChildProcess } from "child_process";
 import { APP_NAME, APP_VERSION, DEFAULT_MODEL, LEGACY_FALLBACK_MODELS, formatReasoningLabel } from "../../config/settings.js";
 import { resolveCodexExecutable, spawnCodexProcess } from "../executables/codexExecutable.js";
+import { loadSeededCodexCapabilities } from "./codexModelsCacheSeed.js";
+import { saveCachedProviderModels } from "./providerModelCache.js";
+import type { ProviderModel } from "../providerRuntime/types.js";
 
 export type ModelCapabilitySource = "runtime" | "fallback";
 export type ModelCapabilityStatus = "ready" | "fallback";
@@ -47,6 +50,8 @@ export interface GetCodexModelCapabilitiesOptions extends DiscoverCodexModelCapa
   ttlMs?: number;
   resolveExecutable?: typeof resolveCodexExecutable;
   discover?: typeof discoverCodexModelCapabilities;
+  seed?: typeof loadSeededCodexCapabilities;
+  persist?: typeof persistCodexModelCapabilities;
 }
 
 interface JsonRpcResponse {
@@ -439,14 +444,36 @@ export async function discoverCodexModelCapabilities(
   });
 }
 
-// Cache chain: TTL-based in-memory cache → live discovery → fallback model list on error.
-// Failed discoveries are evicted from the cache so retries are possible.
+// Persist a successful live discovery so the next launch can seed the model
+// picker without spawning the codex app-server. Best-effort by design.
+export function persistCodexModelCapabilities(capabilities: CodexModelCapabilities): void {
+  const models: ProviderModel[] = capabilities.models
+    .filter((capability) => !capability.hidden)
+    .map((capability) => ({
+      id: capability.id,
+      modelId: capability.model,
+      label: capability.label,
+      description: capability.description,
+      defaultReasoningLevel: capability.defaultReasoningLevel,
+      supportedReasoningLevels: capability.supportedReasoningLevels,
+      source: "discovered",
+    }));
+  saveCachedProviderModels("openai", { discoveredAt: capabilities.discoveredAt, models });
+}
+
+// Cache chain: TTL-based in-memory cache → live discovery → seeded local caches
+// (codex's own models_cache.json / Codexa's last-good discovery) → static
+// fallback model list. Failed discoveries are evicted from the in-memory cache
+// so retries are possible even when a seed satisfied the request.
 export async function getCodexModelCapabilities(
   options: GetCodexModelCapabilitiesOptions = {},
 ): Promise<CodexModelCapabilities> {
   const now = options.now?.() ?? Date.now();
   const ttlMs = options.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const seed = options.seed ?? loadSeededCodexCapabilities;
+  const persist = options.persist ?? persistCodexModelCapabilities;
   let executable: string | null = null;
+  let liveDiscoverySucceeded = false;
 
   try {
     executable = options.executable ?? await (options.resolveExecutable ?? resolveCodexExecutable)();
@@ -462,7 +489,25 @@ export async function getCodexModelCapabilities(
       includeHidden: options.includeHidden,
       timeoutMs: options.timeoutMs,
       now: () => now,
-    }).catch((error) => createFallbackModelCapabilities(error, { discoveredAt: now, executable }));
+    }).then((discovered) => {
+      liveDiscoverySucceeded = true;
+      try {
+        persist(discovered);
+      } catch {
+        // Persistence must never fail a successful discovery.
+      }
+      return discovered;
+    }).catch((error) => {
+      try {
+        const seeded = seed();
+        if (seeded) {
+          return seeded;
+        }
+      } catch {
+        // Seed read failures fall through to the static list.
+      }
+      return createFallbackModelCapabilities(error, { discoveredAt: now, executable });
+    });
 
     capabilityCache.set(cacheKey, {
       expiresAt: now + ttlMs,
@@ -470,12 +515,20 @@ export async function getCodexModelCapabilities(
     });
 
     const result = await promise;
-    if (result.status === "fallback") {
+    if (!liveDiscoverySucceeded) {
       capabilityCache.delete(cacheKey);
     }
 
     return result;
   } catch (error) {
+    try {
+      const seeded = seed();
+      if (seeded) {
+        return seeded;
+      }
+    } catch {
+      // Seed read failures fall through to the static list.
+    }
     return createFallbackModelCapabilities(error, { discoveredAt: now, executable });
   }
 }

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,90 @@
+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;
+  }
+}
+
+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)
+    && candidate.models.every((model) =>
+      typeof model === "object" && model !== null
+      && typeof model.id === "string"
+      && typeof model.modelId === "string"
+      && typeof model.label === "string");
+}
+
+export function loadCachedProviderModels(
+  providerId: ProviderId,
+  cacheFile = getProviderModelCacheFile(),
+): CachedProviderModels | null {
+  const cache = readCacheFile(cacheFile);
+  const entry = cache?.providers?.[providerId];
+  if (!entry || !isValidEntry(entry) || entry.models.length === 0) {
+    return null;
+  }
+  return entry;
+}
+
+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);