@bitkyc08/opencodex 2.7.18 → 2.7.20

package/src/codex/catalog.ts

@@ -1190,7 +1190,8 @@ async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs:
       provider: name,
       owned_by: m.owned_by,
       ...catalogHintsFromModelsApiItem(name, m),
-    }, contextCap));
+    }, contextCap))
+      .filter(m => shouldExposeProviderModel(name, m.id));
     const liveIds = new Set(live.map(m => m.id));
     // Dated-release aliases (Anthropic pattern): older models may appear in the live catalog
     // ONLY under their dated id (claude-haiku-4-5-20251001) while the config names the
@@ -1204,6 +1205,8 @@ async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs:
       if (dated) {
         // Reapply config hints so alias-keyed overrides (modelContextWindows etc.) win.
         live.push(applyProviderConfigHints(name, prov, { ...dated, id: m.id }, contextCap));
+      } else if (shouldRetainConfiguredProviderModel(name, m.id)) {
+        live.push(m);
       } else {
         droppedConfiguredIds.push(m.id);
       }
@@ -1224,6 +1227,16 @@ async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs:
   }
 }
 
+function shouldExposeProviderModel(providerName: string, modelId: string): boolean {
+  if (providerName === "opencode-free") return modelId === "big-pickle" || modelId.endsWith("-free");
+  return true;
+}
+
+function shouldRetainConfiguredProviderModel(providerName: string, modelId: string): boolean {
+  if (providerName === "opencode-free") return modelId === "big-pickle" || modelId.endsWith("-free");
+  return false;
+}
+
 /**
  * Narrow a raw routed-model list to what Codex's catalog / clients should see: drop the
  * `disabledModels` blocklist AND, for any provider with a non-empty `selectedModels` allowlist, keep

package/src/codex/project-config-warnings.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import path, { dirname, join, resolve } from "node:path";
 import { expandUserPath } from "../config";
 import { defaultCodexHome } from "./home";
 import { readRootTomlString } from "./paths";
@@ -223,12 +223,24 @@ export function dedupeRelatedProjectCodexWarnings(
   });
 }
 
-function relPath(abs: string): string {
+/**
+ * Render a path under the user's home as `~/...` for warning display.
+ * Platform-correct containment (devlog 260715_cross_platform_audit/030): the old
+ * lowercase prefix match had no component boundary (`C:\Users\bob2` rendered as
+ * inside `~` for home `C:\Users\bob`) and case-folded on case-sensitive POSIX
+ * filesystems. `relative()` carries the right case semantics per platform; reject
+ * parent (`..`, `..\x`) and cross-drive (absolute) results.
+ */
+export function relPath(
+  abs: string,
+  pathApi: Pick<typeof path, "relative" | "sep" | "isAbsolute"> = path,
+): string {
   const home = process.env.USERPROFILE ?? process.env.HOME ?? "";
-  if (home && abs.toLowerCase().startsWith(home.toLowerCase())) {
-    return `~${abs.slice(home.length).replace(/\\/g, "/")}`;
-  }
-  return abs;
+  if (!home) return abs;
+  const rel = pathApi.relative(home, abs);
+  if (rel === "") return "~";
+  if (rel === ".." || rel.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(rel)) return abs;
+  return `~/${rel.replace(/\\/g, "/")}`;
 }
 
 export function discoverProjectCodexConfigPaths(options: {

package/src/lib/win-exec.ts

@@ -0,0 +1,105 @@
+/**
+ * Cross-platform command launching (devlog 260715_cross_platform_audit/020).
+ *
+ * Windows npm installs expose CLIs as `.cmd` shims, and Node/Bun refuse shell-less
+ * `.cmd` spawns (CVE-2024-27980 hardening). Bare names like `spawn("claude")` also
+ * skip PATHEXT resolution entirely, so they ENOENT even when `claude.cmd` is on PATH.
+ * This module mirrors the battle-tested cross-spawn approach: resolve the real target
+ * via PATH×PATHEXT, launch `.exe` targets directly (argument boundaries preserved by
+ * the normal shell-less spawn), and route `.cmd`/`.bat` targets through
+ * `cmd.exe /d /s /c "<escaped line>"` with `windowsVerbatimArguments: true`.
+ */
+import { existsSync } from "node:fs";
+import { win32 } from "node:path";
+
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+/** cross-spawn parse.js: only npm local-bin shims get double escaping. */
+const IS_CMD_SHIM = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+
+/** cross-spawn escape.js argument(): quote + escape one argument for cmd.exe /d /s /c. */
+export function escapeCmdArg(arg: string, doubleEscape = false): string {
+  let out = String(arg).replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1");
+  out = `"${out}"`.replace(CMD_META, "^$1");
+  return doubleEscape ? out.replace(CMD_META, "^$1") : out;
+}
+
+/** cross-spawn escape.js command(): escape the command token itself (no quoting). */
+export function escapeCmdCommand(command: string): string {
+  return command.replace(CMD_META, "^$1");
+}
+
+export interface ResolveDeps {
+  env?: Record<string, string | undefined>;
+  exists?: (path: string) => boolean;
+}
+
+/**
+ * Resolve a bare command name to its first PATH×PATHEXT hit (win32 semantics).
+ * Commands that already carry an extension, a separator, or an absolute prefix are
+ * returned unchanged; unresolvable names fall back unchanged (spawn will surface it).
+ */
+export function resolveWindowsCommand(command: string, deps: ResolveDeps = {}): string {
+  const env = deps.env ?? process.env;
+  const exists = deps.exists ?? existsSync;
+  if (win32.extname(command) || command.includes("\\") || command.includes("/") || win32.isAbsolute(command)) {
+    return command;
+  }
+  const exts = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  for (const dir of (env.PATH ?? env.Path ?? "").split(win32.delimiter).filter(Boolean)) {
+    for (const ext of exts) {
+      const candidate = win32.join(dir, command + ext.toLowerCase());
+      if (exists(candidate)) return candidate;
+    }
+  }
+  return command;
+}
+
+export interface SpawnInvocation {
+  file: string;
+  args: string[];
+  options: { windowsVerbatimArguments?: boolean };
+}
+
+/**
+ * Platform-safe invocation preserving argument boundaries (cross-spawn parse.js).
+ * POSIX: passthrough. win32 `.exe`: resolved direct spawn. win32 `.cmd`/`.bat`:
+ * `ComSpec /d /s /c "<escaped command line>"` with verbatim args; npm local-bin
+ * shims get cross-spawn's double escaping, all other batch targets single.
+ */
+export function commandInvocation(
+  command: string,
+  args: readonly string[],
+  platform: NodeJS.Platform = process.platform,
+  deps: ResolveDeps = {},
+): SpawnInvocation {
+  if (platform !== "win32") return { file: command, args: [...args], options: {} };
+  const resolved = resolveWindowsCommand(command, deps);
+  if (!/\.(cmd|bat)$/i.test(resolved)) return { file: resolved, args: [...args], options: {} };
+  const env = deps.env ?? process.env;
+  const doubleEscape = IS_CMD_SHIM.test(resolved);
+  const line = [escapeCmdCommand(resolved), ...args.map(a => escapeCmdArg(a, doubleEscape))].join(" ");
+  return {
+    file: env.ComSpec ?? "cmd.exe",
+    args: ["/d", "/s", "/c", `"${line}"`],
+    options: { windowsVerbatimArguments: true },
+  };
+}
+
+/**
+ * `sh -c <command>` analog per platform. The configured command string is passed
+ * VERBATIM in content; on win32 it gets the outer quotes `/s` requires, so
+ * `"C:\Program Files\x.exe" --json` runs as `cmd.exe /d /s /c ""C:\Program Files\x.exe" --json"`.
+ * Contract: the command is platform-native shell syntax (sh on POSIX, CMD on Windows).
+ */
+export function shellInvocation(
+  command: string,
+  platform: NodeJS.Platform = process.platform,
+  env: Record<string, string | undefined> = process.env,
+): SpawnInvocation {
+  if (platform !== "win32") return { file: "sh", args: ["-c", command], options: {} };
+  return {
+    file: env.ComSpec ?? "cmd.exe",
+    args: ["/d", "/s", "/c", `"${command}"`],
+    options: { windowsVerbatimArguments: true },
+  };
+}

package/src/oauth/callback-server.ts

@@ -235,12 +235,16 @@ export abstract class OAuthCallbackFlow {
         while (true) {
           const result = await Promise.race([
             callbackPromise,
-            requestManualInput()
+            requestManualInput(expectedState)
               .then((input): CallbackResult | null => {
                 const parsed = parseCallbackInput(input);
                 if (!parsed.code) return null;
-                if (expectedState && parsed.state !== expectedState) return null;
-                return { code: parsed.code, state: parsed.state ?? "" };
+                // Kind-aware state enforcement: url/query-shaped input is an authorization
+                // RESPONSE and must carry a matching state — missing state is rejected, not
+                // downgraded to raw. Only a syntactically raw code (same PKCE session) is
+                // exempt, so the CLI/GUI paste fallback still works.
+                if (parsed.kind !== "raw" && expectedState && parsed.state !== expectedState) return null;
+                return { code: parsed.code, state: parsed.state ?? expectedState };
               })
               .catch((): CallbackResult | null => null),
           ]);
@@ -255,14 +259,19 @@ export abstract class OAuthCallbackFlow {
   }
 }
 
-/** Parse a redirect URL or code string to extract code and state. */
-export function parseCallbackInput(input: string): { code?: string; state?: string } {
+/**
+ * Parse a redirect URL or code string to extract code and state.
+ * `kind` records the syntactic shape so callers can enforce state on authorization
+ * responses (url/query) while exempting raw in-session codes.
+ */
+export function parseCallbackInput(input: string): { kind: "url" | "query" | "raw"; code?: string; state?: string } {
   const value = input.trim();
-  if (!value) return {};
+  if (!value) return { kind: "raw" };
 
   try {
     const url = new URL(value);
     return {
+      kind: "url",
       code: url.searchParams.get("code") ?? undefined,
       state: url.searchParams.get("state") ?? undefined,
     };
@@ -273,6 +282,7 @@ export function parseCallbackInput(input: string): { code?: string; state?: stri
   if (value.includes("code=")) {
     const params = new URLSearchParams(value.replace(/^[?#]/, ""));
     return {
+      kind: "query",
       code: params.get("code") ?? undefined,
       state: params.get("state") ?? undefined,
     };
@@ -280,5 +290,5 @@ export function parseCallbackInput(input: string): { code?: string; state?: stri
 
   // Assume raw code, possibly with state after #
   const [code, state] = value.split("#", 2);
-  return { code, state };
+  return { kind: "raw", code, state };
 }

package/src/oauth/index.ts

@@ -1,4 +1,5 @@
 import type { OAuthController, OAuthCredentials } from "./types";
+import { parseCallbackInput } from "./callback-server";
 import type { OcxConfig, OcxProviderConfig, RefreshPolicy } from "../types";
 import { loadConfig, resolveEnvValue, saveConfig } from "../config";
 import { maskEmail } from "../lib/privacy";
@@ -362,10 +363,95 @@ export async function runLogin(provider: string, ctrl: OAuthController, opts?: L
  * GUI async login: start the flow, return the auth URL EARLY (the flow keeps running in the
  * background until the callback server captures the redirect), with a concurrency guard and an
  * error surfaced via getLoginStatus().
+ *
+ * Manual fallback: when the browser cannot reach the loopback callback (remote GUI, SSH, blocked
+ * localhost), the GUI can POST the final redirect URL or authorization code via
+ * submitManualLoginCode(), which feeds OAuthController.onManualCodeInput.
  */
 const loginState = new Map<string, { error?: string; done: boolean }>();
 const loginAbort = new Map<string, AbortController>();
 
+/** Pending paste for a login in progress: either a waiter or a stashed early submission. */
+interface ManualCodeSlot {
+  pendingInput?: string;
+  resolve?: (value: string) => void;
+  /** Registered by the callback flow so submits can validate state synchronously. */
+  expectedState?: string;
+}
+const loginManual = new Map<string, ManualCodeSlot>();
+
+function clearManualCodeSlot(provider: string): void {
+  loginManual.delete(provider);
+}
+
+function ensureManualCodeSlot(provider: string): ManualCodeSlot {
+  let slot = loginManual.get(provider);
+  if (!slot) {
+    slot = {};
+    loginManual.set(provider, slot);
+  }
+  return slot;
+}
+
+/** Wait for a GUI/CLI paste of the OAuth redirect URL or code (or return a stashed early submit). */
+function waitForManualLoginCode(provider: string, signal: AbortSignal, expectedState?: string): Promise<string> {
+  if (signal.aborted) {
+    return Promise.reject(new Error(`OAuth callback cancelled: ${signal.reason}`));
+  }
+  const slot = ensureManualCodeSlot(provider);
+  if (expectedState !== undefined) slot.expectedState = expectedState;
+  if (slot.pendingInput !== undefined) {
+    const value = slot.pendingInput;
+    slot.pendingInput = undefined;
+    return Promise.resolve(value);
+  }
+  return new Promise<string>((resolve, reject) => {
+    const onAbort = () => {
+      if (slot.resolve === resolve) slot.resolve = undefined;
+      reject(new Error(`OAuth callback cancelled: ${signal.reason}`));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    slot.resolve = (value: string) => {
+      signal.removeEventListener("abort", onAbort);
+      if (slot.resolve === resolve) slot.resolve = undefined;
+      resolve(value);
+    };
+  });
+}
+
+/**
+ * Feed a pasted redirect URL or authorization code into an in-progress GUI login.
+ * Returns ok:false when no login is waiting (or input is empty). Invalid pastes are accepted
+ * here and re-prompted by the OAuth callback loop if they cannot be parsed / fail state checks.
+ */
+export function submitManualLoginCode(provider: string, input: string): { ok: true } | { ok: false; error: string } {
+  const trimmed = input.trim();
+  if (!trimmed) return { ok: false, error: "empty code" };
+  const st = loginState.get(provider);
+  if (!st || st.done) return { ok: false, error: "no login in progress" };
+  const slot = ensureManualCodeSlot(provider);
+  // Synchronous validation (validated request/ack): reject un-parseable input and
+  // authorization responses (url/query kind) whose state is missing or mismatched
+  // once the flow has registered its expected state. Raw codes stay in-session-PKCE
+  // protected. Early posts (flow not yet waiting, no expectedState) are stashed and
+  // re-validated by the callback loop.
+  const parsed = parseCallbackInput(trimmed);
+  if (!parsed.code) return { ok: false, error: "no authorization code found in input" };
+  if (parsed.kind !== "raw" && slot.expectedState !== undefined) {
+    if (parsed.state === undefined) return { ok: false, error: "redirect URL is missing the state parameter" };
+    if (parsed.state !== slot.expectedState) return { ok: false, error: "state mismatch — paste the redirect URL from THIS login attempt" };
+  }
+  if (slot.resolve) {
+    const resolve = slot.resolve;
+    slot.resolve = undefined;
+    resolve(trimmed);
+  } else {
+    // Race: GUI may POST before the flow reaches onManualCodeInput — stash for the waiter.
+    slot.pendingInput = trimmed;
+  }
+  return { ok: true };
+}
+
 export interface OAuthAccountSummary { id: string; email?: string; active: boolean; needsReauth?: boolean; expiresAt?: number }
 
 export function getLoginStatus(provider: string): { loggedIn: boolean; email?: string; source?: OAuthCredentials["source"]; error?: string; done: boolean; activeAccountId?: string; accounts?: OAuthAccountSummary[] } {
@@ -400,6 +486,7 @@ export function oauthLoginSummary(): Array<{ provider: string; loggedIn: boolean
 export function clearLoginState(provider: string): void {
   loginAbort.get(provider)?.abort("cleared");
   loginAbort.delete(provider);
+  clearManualCodeSlot(provider);
   loginState.delete(provider);
 }
 
@@ -409,6 +496,7 @@ export function cancelLoginFlow(provider: string): boolean {
   if (!ctrl && (!existing || existing.done)) return false;
   ctrl?.abort("cancelled");
   loginAbort.delete(provider);
+  clearManualCodeSlot(provider);
   loginState.set(provider, { done: true, error: "Login cancelled" });
   return true;
 }
@@ -420,6 +508,7 @@ export async function startLoginFlow(provider: string, opts?: LoginOpts): Promis
   if (existing && !existing.done) {
     throw new Error(`A login for ${provider} is already in progress`);
   }
+  clearManualCodeSlot(provider);
   loginState.set(provider, { done: false });
   const abort = new AbortController();
   loginAbort.set(provider, abort);
@@ -431,12 +520,15 @@ export async function startLoginFlow(provider: string, opts?: LoginOpts): Promis
         resolve({ url, instructions });
       },
       onProgress: () => {},
+      // GUI fallback when the browser cannot hit the loopback callback server.
+      onManualCodeInput: (expectedState?: string) => waitForManualLoginCode(provider, abort.signal, expectedState),
       signal: abort.signal,
     };
     // Background: runLogin persists the credential + upserts the provider entry to disk config.
     runLogin(provider, ctrl, opts)
       .then(() => {
         loginAbort.delete(provider);
+        clearManualCodeSlot(provider);
         loginState.set(provider, { done: true });
         // Local-token import (grok-cli / Claude Code keychain) completes WITHOUT firing onAuth —
         // resolve so the GUI call returns instead of hanging.
@@ -444,6 +536,7 @@ export async function startLoginFlow(provider: string, opts?: LoginOpts): Promis
       })
       .catch((e: unknown) => {
         loginAbort.delete(provider);
+        clearManualCodeSlot(provider);
         const msg = e instanceof Error ? e.message : String(e);
         loginState.set(provider, { done: true, error: msg });
         if (!urlResolved) reject(e);

package/src/oauth/types.ts

@@ -31,7 +31,7 @@ export interface ProviderAccountSet {
 export interface OAuthController {
   onAuth?(info: { url: string; instructions?: string }): void;
   onProgress?(message: string): void;
-  onManualCodeInput?(): Promise<string>;
+  onManualCodeInput?(expectedState?: string): Promise<string>;
   signal?: AbortSignal;
 }
 

package/src/providers/derive.ts

@@ -48,6 +48,7 @@ export interface DerivedProviderPreset {
   oauthProvider?: string;
   dashboardUrl?: string;
   note?: string;
+  keyOptional?: boolean;
 }
 
 export function listRegistryEntries(): readonly ProviderRegistryEntry[] {
@@ -69,6 +70,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     authMode: entry.authKind === "local" ? undefined : entry.authKind,
     ...(entry.keyOptional !== undefined ? { keyOptional: entry.keyOptional } : {}),
     ...(entry.modelSuffixBracketStrip !== undefined ? { modelSuffixBracketStrip: entry.modelSuffixBracketStrip } : {}),
+    ...(entry.staticHeaders ? { headers: { ...entry.staticHeaders } } : {}),
     ...(entry.defaultModel ? { defaultModel: entry.defaultModel } : {}),
     ...(entry.models ? { models: [...entry.models] } : {}),
     ...(entry.liveModels !== undefined ? { liveModels: entry.liveModels } : {}),
@@ -193,6 +195,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (prov.escapeBuiltinToolNames === undefined && seed.escapeBuiltinToolNames !== undefined) prov.escapeBuiltinToolNames = seed.escapeBuiltinToolNames;
   if (prov.keyOptional === undefined && seed.keyOptional !== undefined) prov.keyOptional = seed.keyOptional;
   if (prov.modelSuffixBracketStrip === undefined && seed.modelSuffixBracketStrip !== undefined) prov.modelSuffixBracketStrip = seed.modelSuffixBracketStrip;
+  if (!prov.headers && seed.headers) prov.headers = { ...seed.headers };
 }
 
 export function deriveFeaturedProviderIds(): string[] {
@@ -227,6 +230,7 @@ function entryToPreset(entry: ProviderRegistryEntry): DerivedProviderPreset {
     ...(entry.authKind === "oauth" ? { oauthProvider: entry.oauthId ?? entry.id } : {}),
     ...(entry.dashboardUrl ? { dashboardUrl: entry.dashboardUrl } : {}),
     ...(entry.note ? { note: entry.note } : {}),
+    ...(entry.keyOptional ? { keyOptional: true } : {}),
   };
 }
 

package/src/providers/registry.ts

@@ -23,6 +23,8 @@ export interface ProviderRegistryEntry {
   allowPrivateNetworkByDefault?: boolean;
   keyOptional?: boolean;
   allowBaseUrlOverride?: boolean;
+  /** Static headers merged into every upstream request for this provider. */
+  staticHeaders?: Record<string, string>;
   modelSuffixBracketStrip?: boolean;
   featured?: boolean;
   dashboardPreset?: boolean;
@@ -66,7 +68,7 @@ export type ProviderConfigSeed = Pick<
   | "reasoningEfforts" | "modelReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap"
   | "noVisionModels" | "noReasoningModels" | "noTemperatureModels" | "noTopPModels" | "noPenaltyModels"
   | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "thinkingToggleModels" | "thinkingBudgetModels" | "escapeBuiltinToolNames"
-  | "googleMode" | "project" | "location"
+  | "googleMode" | "project" | "location" | "headers"
 >;
 
 // Shared between the OAuth (Claude account) and API-key Anthropic entries so both expose the
@@ -133,6 +135,7 @@ const THINKING_BUDGET_MODELS = [
 ];
 const OPENCODE_GO_THINKING_BUDGET_MODELS = ["qwen3.5-plus", "qwen3.6-plus", "qwen3.7-max", "qwen3.7-plus"];
 const DEEPSEEK_THINKING_MODELS = ["deepseek-v4-pro", "deepseek-v4-flash"];
+const OPENCODE_FREE_DEEPSEEK_MODELS = ["deepseek-v4-flash-free"];
 // "max" is advertised too: the wire map routes xhigh->max and max->max, so the picker
 // should surface the max tier instead of hiding it behind xhigh.
 const DEEPSEEK_THINKING_EFFORTS = ["high", "xhigh", "max"];
@@ -608,8 +611,41 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   },
   { id: "opencode-zen", label: "opencode zen", baseUrl: "https://opencode.ai/zen/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://opencode.ai/auth" },
   { id: "vercel-ai-gateway", label: "Vercel AI Gateway", baseUrl: "https://ai-gateway.vercel.sh/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://vercel.com/dashboard" },
+  {
+    id: "opencode-free",
+    label: "OpenCode Free",
+    adapter: "openai-chat",
+    baseUrl: "https://opencode.ai/zen/v1",
+    authKind: "key",
+    keyOptional: true,
+    featured: true,
+    liveModels: true,
+    note: "No key needed — public desktop tier. OpenCode currently advertises about 200 Big Pickle/free-model requests per 5 hours. Free models are discovered live from Zen. Data use: per OpenCode's Zen docs (https://opencode.ai/docs/zen/), prompts sent to free models may be retained and used for training/improvement — do not send confidential material through this provider.",
+    dashboardUrl: "https://opencode.ai",
+    staticHeaders: {
+      "x-opencode-client": "desktop",
+    },
+    modelReasoningEfforts: Object.fromEntries(OPENCODE_FREE_DEEPSEEK_MODELS.map(id => [id, DEEPSEEK_THINKING_EFFORTS])),
+    modelReasoningEffortMap: Object.fromEntries(OPENCODE_FREE_DEEPSEEK_MODELS.map(id => [id, DEEPSEEK_THINKING_REASONING_MAP])),
+    preserveReasoningContentModels: OPENCODE_FREE_DEEPSEEK_MODELS,
+    noVisionModels: OPENCODE_FREE_DEEPSEEK_MODELS,
+  },
   { id: "xiaomi", label: "Xiaomi MiMo", baseUrl: "https://api.xiaomimimo.com/anthropic", adapter: "anthropic", authKind: "key", dashboardUrl: "https://xiaomimimo.com", defaultModel: "mimo-v2.5-pro" },
   { id: "kilo", label: "Kilo", baseUrl: "https://api.kilo.ai/api/gateway", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://kilo.ai" },
+  {
+    id: "mimo-free",
+    label: "MiMo Free",
+    adapter: "mimo-free",
+    baseUrl: "https://api.xiaomimimo.com/api/free-ai/openai/chat",
+    authKind: "key",
+    keyOptional: true,
+    featured: true,
+    liveModels: true,
+    dashboardUrl: "https://xiaomimimo.com",
+    defaultModel: "mimo-auto",
+    models: ["mimo-auto"],
+    note: "No key needed — uses Xiaomi MiMo's free public tier (limited-time offer). A JWT is bootstrapped automatically with an anonymous random client id stored locally. The endpoint contract mirrors the official MiMoCode client and is not publicly documented — Xiaomi may change or restrict it at any time. Prompts may be processed/retained by Xiaomi; do not send confidential material.",
+  },
   { id: "cloudflare-ai-gateway", label: "Cloudflare AI Gateway", baseUrl: "https://gateway.ai.cloudflare.com/v1/{account-id}/{gateway}/anthropic", adapter: "anthropic", authKind: "key", dashboardUrl: "https://dash.cloudflare.com/?to=/:account/ai/ai-gateway" },
   // FREEZE 2026-07-10: /models is auth-gated, so ids remain unverified. Evidence: devlog/_plan/260710_provider_hardening/003_research_aggregators.md.
   { id: "github-copilot", label: "GitHub Copilot", baseUrl: "https://api.githubcopilot.com", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://github.com/settings/copilot" },

package/src/server/adapter-resolve.ts

@@ -3,6 +3,7 @@ import { createAzureAdapter } from "../adapters/azure";
 import { createCursorAdapter } from "../adapters/cursor";
 import { createGoogleAdapter } from "../adapters/google";
 import { createKiroAdapter } from "../adapters/kiro";
+import { createMimoFreeAdapter } from "../adapters/mimo-free";
 import { createOpenAIChatAdapter } from "../adapters/openai-chat";
 import { createResponsesPassthroughAdapter } from "../adapters/openai-responses";
 import type { OcxProviderConfig } from "../types";
@@ -40,6 +41,8 @@ export function resolveAdapter(providerConfig: OcxProviderConfig, cacheRetention
       return createAzureAdapter(providerConfig);
     case "cursor":
       return createCursorAdapter(providerConfig);
+    case "mimo-free":
+      return createMimoFreeAdapter(providerConfig);
     default:
       throw new Error(`Unknown adapter: ${providerConfig.adapter}`);
   }

package/src/server/auth-cors.ts

@@ -6,6 +6,7 @@ import {
   providerHeadersConfigError,
 } from "../config";
 import { providerDestinationConfigError } from "../lib/destination-policy";
+import { getProviderRegistryEntry } from "../providers/registry";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 
 let _corsOrigin = "http://localhost:10100";
@@ -210,6 +211,7 @@ export function safeConfigDTO(config: OcxConfig): unknown {
       "disabled",
       "allowPrivateNetwork",
       "authMode",
+      "keyOptional",
       "liveModels",
       "models",
       "contextWindow",
@@ -227,6 +229,8 @@ export function safeConfigDTO(config: OcxConfig): unknown {
     ] as const) {
       copyIfDefined(dto, provider, key);
     }
+    const registryNote = getProviderRegistryEntry(name)?.note;
+    if (typeof registryNote === "string" && registryNote.trim()) dto.note = registryNote;
     providers[name] = dto;
   }
   return {

package/src/server/management-api.ts

@@ -16,6 +16,7 @@ import {
   isOAuthProvider,
   listOAuthProviders,
   startLoginFlow,
+  submitManualLoginCode,
   upsertOAuthProvider,
 } from "../oauth";
 import { removeCredential } from "../oauth/store";
@@ -28,6 +29,7 @@ import { readUsageEntries } from "../usage/log";
 import { getUsageDebugLogEntries } from "../usage/debug";
 import { parseRange, summarizeUsage } from "../usage/summary";
 import { stripCodexRuntimeProviderFields } from "../codex/auth-context";
+import { getProviderRegistryEntry } from "../providers/registry";
 import { getDebugLogEntries } from "../lib/debug-log-buffer";
 import { getInjectionDebugLogEntries } from "../lib/injection-debug-log";
 import {
@@ -430,7 +432,7 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     // let the (possibly new) apiKey join the pool as the active entry.
     const existingPool = config.providers[name]?.apiKeyPool;
     if (existingPool && !prov.apiKeyPool) prov.apiKeyPool = existingPool;
-    config.providers[name] = prov;
+    config.providers[name] = stripRegistryOnlyStaticHeaders(name, prov);
     if (body.setDefault) config.defaultProvider = name;
     save(config);
     if (prov.apiKey && prov.apiKeyPool) {
@@ -609,10 +611,11 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
       let toggle = deps.toggleCodexMultiAgentV2;
       if (!toggle) {
         const { execFileSync } = await import("node:child_process");
+        const { codexFeaturesInvocation } = await import("../cli/v2");
         toggle = (enabled: boolean) => {
-          const command = process.env.CODEX_CLI_PATH?.trim() || "codex";
-          execFileSync(command, ["features", enabled ? "enable" : "disable", "multi_agent_v2"],
-            { stdio: ["ignore", "pipe", "pipe"], timeout: 15_000, windowsHide: true });
+          const inv = codexFeaturesInvocation(enabled ? "enable" : "disable");
+          execFileSync(inv.file, inv.args,
+            { stdio: ["ignore", "pipe", "pipe"], timeout: 15_000, windowsHide: true, ...inv.options });
         };
       }
       const result = transitionMultiAgentV2(targetFlag, toggle, {
@@ -1043,6 +1046,21 @@ export async function handleManagementAPI(req: Request, url: URL, config: OcxCon
     }
   }
 
+  // Manual fallback for browser OAuth: paste the final redirect URL (or authorization code)
+  // when the browser cannot reach the loopback callback (remote/SSH/blocked localhost).
+  if (url.pathname === "/api/oauth/login/code" && req.method === "POST") {
+    const body = await req.json().catch(() => ({})) as { provider?: string; input?: string; code?: string };
+    const provider = (body.provider ?? "").trim().toLowerCase();
+    if (!isOAuthProvider(provider)) return jsonResponse({ error: "unknown oauth provider" }, 400);
+    const input = typeof body.input === "string" ? body.input : typeof body.code === "string" ? body.code : "";
+    // Authorization responses are measured in hundreds of bytes; never accept the
+    // generic management-body allowance here.
+    if (input.length > 4096) return jsonResponse({ error: "input too long" }, 400);
+    const result = submitManualLoginCode(provider, input);
+    if (!result.ok) return jsonResponse({ error: result.error }, 409);
+    return jsonResponse({ ok: true });
+  }
+
   if (url.pathname === "/api/oauth/status" && req.method === "GET") {
     const provider = (url.searchParams.get("provider") ?? "").trim().toLowerCase();
     return jsonResponse(getLoginStatus(provider));
@@ -1207,3 +1225,15 @@ export async function fetchAllModels(config: OcxConfig): Promise<CatalogModel[]>
   const { gatherRoutedModels } = await import("../codex/catalog");
   return gatherRoutedModels(config);
 }
+
+function stripRegistryOnlyStaticHeaders(name: string, provider: OcxProviderConfig): OcxProviderConfig {
+  const entry = getProviderRegistryEntry(name);
+  if (!entry?.staticHeaders || !provider.headers) return provider;
+  const headerEntries = Object.entries(provider.headers);
+  const staticEntries = Object.entries(entry.staticHeaders);
+  if (headerEntries.length !== staticEntries.length) return provider;
+  const matchesRegistryStaticHeaders = staticEntries.every(([key, value]) => provider.headers?.[key] === value);
+  if (!matchesRegistryStaticHeaders) return provider;
+  const { headers: _headers, ...rest } = provider;
+  return rest;
+}

package/src/server/relay.ts

@@ -212,10 +212,14 @@ export function responseWithDeferredRequestLog(
     return response;
   }
   if (!response.body || !contentType.includes("text/event-stream")) {
-    if (response.body && contentType.includes("application/json")) {
+    if (response.body && (contentType.includes("application/json") || response.status >= 400)) {
       const finalizeJsonLog = async () => {
         const text = await response.text();
-        inspectResponseLogJson(logCtx, text);
+        // Non-JSON error bodies: inspect/log only a bounded prefix (the stored
+        // upstreamError is 500 chars anyway); the FULL text is still forwarded to the
+        // client below, unchanged. JSON bodies keep full inspection (usage parsing).
+        const isJson = contentType.includes("application/json");
+        inspectResponseLogJson(logCtx, isJson ? text : text.slice(0, 8192));
         addFinalRequestLog(requestId, start, logCtx, response.status, { closeReason: "non_stream" }, addLog);
         return text;
       };

package/src/server/request-log.ts

@@ -294,7 +294,10 @@ function captureUpstreamError(logCtx: RequestLogContext, text: string | null): v
       logCtx.upstreamError = redactSecretString(incompleteReasonLabel(reason.trim())).slice(0, 500);
     }
   } catch {
-    /* not JSON; nothing to capture */
+    const trimmed = text.trim();
+    if (trimmed) {
+      logCtx.upstreamError = redactSecretString(trimmed).slice(0, 500);
+    }
   }
 }