@bitkyc08/opencodex 2.1.1 → 2.1.5

package/src/codex-catalog.ts

@@ -150,6 +150,7 @@ export function normalizeRoutedCatalogEntry(entry: RawEntry): RawEntry {
   // runs through native gpt-5.4-mini, so image search is available and verbalized for text-only models.
   entry.web_search_tool_type = "text_and_image";
   entry.supports_search_tool = true;
+  entry.supports_parallel_tool_calls = false;
   return ensureStrictCatalogFields(entry);
 }
 

package/src/codex-history-provider.ts

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { CODEX_HOME } from "./codex-paths";
+
+const STATE_DB_PATH = join(CODEX_HOME, "state_5.sqlite");
+const RESUMABLE_SOURCES = ["cli", "vscode"] as const;
+
+type CodexHistoryProvider = "openai" | "opencodex";
+
+interface ThreadRow {
+  id: string;
+  rollout_path: string;
+}
+
+function updateSessionMetaProvider(path: string, provider: CodexHistoryProvider): boolean {
+  if (!path || !existsSync(path)) return false;
+  const stat = statSync(path);
+  const raw = readFileSync(path, "utf8");
+  const newline = raw.indexOf("\n");
+  const firstLine = newline === -1 ? raw : raw.slice(0, newline);
+  const rest = newline === -1 ? "" : raw.slice(newline);
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(firstLine);
+  } catch {
+    return false;
+  }
+
+  if (!parsed || typeof parsed !== "object") return false;
+  const record = parsed as { type?: unknown; payload?: { model_provider?: unknown } };
+  if (record.type !== "session_meta" || !record.payload || typeof record.payload !== "object") return false;
+  if (record.payload.model_provider === provider) return false;
+
+  record.payload.model_provider = provider;
+  writeFileSync(path, `${JSON.stringify(record)}${rest}`, "utf8");
+  utimesSync(path, stat.atime, stat.mtime);
+  return true;
+}
+
+export function syncCodexHistoryProvider(provider: CodexHistoryProvider, stateDbPath = STATE_DB_PATH): { rows: number; files: number } {
+  if (!existsSync(stateDbPath)) return { rows: 0, files: 0 };
+  const from = provider === "opencodex" ? "openai" : "opencodex";
+  const db = new Database(stateDbPath);
+  try {
+    const placeholders = RESUMABLE_SOURCES.map(() => "?").join(",");
+    const rows = db
+      .query<ThreadRow, string[]>(`
+        SELECT id, rollout_path
+        FROM threads
+        WHERE model_provider = ?
+          AND source IN (${placeholders})
+      `)
+      .all(from, ...RESUMABLE_SOURCES);
+
+    let files = 0;
+    for (const row of rows) {
+      try {
+        if (updateSessionMetaProvider(row.rollout_path, provider)) files++;
+      } catch {
+        /* best-effort; keep DB migration moving even if one old rollout is malformed */
+      }
+    }
+
+    const update = db.transaction(() => {
+      db.query(`
+        UPDATE threads
+        SET has_user_event = 1
+        WHERE source IN (${placeholders})
+          AND trim(coalesce(first_user_message, '')) != ''
+      `).run(...RESUMABLE_SOURCES);
+      db.query(`
+        UPDATE threads
+        SET model_provider = ?
+        WHERE model_provider = ?
+          AND source IN (${placeholders})
+      `).run(provider, from, ...RESUMABLE_SOURCES);
+    });
+    update();
+
+    return { rows: rows.length, files };
+  } finally {
+    db.close();
+  }
+}

package/src/codex-inject.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { atomicWriteFile, websocketsEnabled } from "./config";
 import { restoreCodexCatalog } from "./codex-catalog";
+import { syncCodexHistoryProvider } from "./codex-history-provider";
 import { CODEX_CONFIG_PATH, CODEX_PROFILE_PATH, DEFAULT_CATALOG_PATH, parseTomlString, readRootTomlString, resolveCodexConfigPath, tomlString } from "./codex-paths";
 import type { OcxConfig } from "./types";
 
@@ -228,14 +229,19 @@ export async function injectCodexConfig(port: number, config?: OcxConfig, option
 
   writeFileSync(CODEX_CONFIG_PATH, content, "utf-8");
   writeFileSync(CODEX_PROFILE_PATH, buildProfileFile(port, catalogPath), "utf-8");
+  const history = syncCodexHistoryProvider("opencodex");
 
   const catalogMessage = catalogPath
     ? `  Codex model catalog: ${catalogPath}\n`
     : `  Codex model catalog not injected because no opencodex catalog file exists yet.\n`;
+  const historyMessage = history.rows > 0
+    ? `  Codex resume history: ${history.rows} thread(s) mapped to opencodex.\n`
+    : "";
   return {
     success: true,
     message: `Injected opencodex as default provider into Codex config.\n` +
       catalogMessage +
+      historyMessage +
       `  All models now route through opencodex proxy (like OpenRouter).\n` +
       `  OpenAI models (gpt-5.5, etc.) are passed through to OpenAI.\n` +
       `  Custom models route to their configured providers.\n` +
@@ -311,10 +317,12 @@ export function removeCodexConfig(): { success: boolean; message: string } {
 export function restoreNativeCodex(): { success: boolean; message: string } {
   const cfg = removeCodexConfig();
   const cat = restoreCodexCatalog();
+  const history = syncCodexHistoryProvider("openai");
   const msg = cat.removed > 0
     ? `${cfg.message} Catalog restored to ${cat.kept} native model(s) (dropped ${cat.removed} proxy-routed).`
     : cfg.message;
-  return { success: cfg.success, message: msg };
+  const historyMsg = history.rows > 0 ? ` Resume history restored to openai (${history.rows} thread(s)).` : "";
+  return { success: cfg.success, message: `${msg}${historyMsg}` };
 }
 
 export function getCodexConfigPath(): string {

package/src/codex-shim.ts

@@ -4,6 +4,30 @@ import { getConfigDir } from "./config";
 
 const SHIM_MARKER = "opencodex codex autostart shim";
 const STATE_PATH = join(getConfigDir(), "codex-shim.json");
+const CODEX_INTERNAL_COMMANDS = [
+  "app-server",
+  "archive",
+  "apply",
+  "cloud",
+  "completion",
+  "debug",
+  "delete",
+  "doctor",
+  "exec",
+  "exec-server",
+  "features",
+  "fork",
+  "help",
+  "login",
+  "logout",
+  "mcp",
+  "plugin",
+  "resume",
+  "review",
+  "sandbox",
+  "unarchive",
+  "update",
+];
 
 interface ShimState {
   platform: NodeJS.Platform;
@@ -51,39 +75,33 @@ function backupPathFor(path: string): string {
 }
 
 export function buildUnixCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
+  const internalCommands = CODEX_INTERNAL_COMMANDS.join("|");
   return `#!/usr/bin/env sh
 # ${SHIM_MARKER}
-if [ -z "$OCX_SHIM_BYPASS" ]; then
-  if ! "${bunPath}" "${cliPath}" status 2>/dev/null | grep -q "Proxy running"; then
-    mkdir -p "$HOME/.opencodex"
-    nohup env OCX_SERVICE=1 "${bunPath}" "${cliPath}" start >> "$HOME/.opencodex/shim.log" 2>&1 &
-    i=0
-    while [ "$i" -lt 50 ]; do
-      if "${bunPath}" "${cliPath}" status 2>/dev/null | grep -q "Proxy running"; then
-        break
-      fi
-      sleep 0.1
-      i=$((i + 1))
-    done
-  fi
-fi
+case "$1" in
+  ${internalCommands}|--help|-h|--version|-V)
+    ;;
+  *)
+    if [ -z "$OCX_SHIM_BYPASS" ]; then
+      "${bunPath}" "${cliPath}" ensure >/dev/null 2>&1 || true
+    fi
+    ;;
+esac
 exec "${realCodexPath}" "$@"
 `;
 }
 
 export function buildWindowsCodexShim(realCodexPath: string, bunPath: string, cliPath: string): string {
+  const internalCommandChecks = CODEX_INTERNAL_COMMANDS.map(command => `if /I "%~1"=="${command}" goto run_codex`).join("\r\n");
   return `@echo off\r
 rem ${SHIM_MARKER}\r
 if not "%OCX_SHIM_BYPASS%"=="" goto run_codex\r
-"${bunPath}" "${cliPath}" status 2>nul | findstr /C:"Proxy running" >nul\r
-if %ERRORLEVEL% EQU 0 goto run_codex\r
-if not exist "%USERPROFILE%\\.opencodex" mkdir "%USERPROFILE%\\.opencodex"\r
-start "" /b cmd /c "set OCX_SERVICE=1 && ""${bunPath}"" ""${cliPath}"" start >> ""%USERPROFILE%\\.opencodex\\shim.log"" 2>&1"\r
-for /l %%i in (1,1,50) do (\r
-  "${bunPath}" "${cliPath}" status 2>nul | findstr /C:"Proxy running" >nul\r
-  if not errorlevel 1 goto run_codex\r
-  powershell -NoProfile -Command "Start-Sleep -Milliseconds 100" >nul 2>nul\r
-)\r
+${internalCommandChecks}\r
+if /I "%~1"=="--help" goto run_codex\r
+if /I "%~1"=="-h" goto run_codex\r
+if /I "%~1"=="--version" goto run_codex\r
+if /I "%~1"=="-V" goto run_codex\r
+"${bunPath}" "${cliPath}" ensure >nul 2>nul\r
 :run_codex\r
 "${realCodexPath}" %*\r
 `;
@@ -127,7 +145,7 @@ export function installCodexShim(): { installed: boolean; message: string } {
     return { installed: false, message: `Codex autostart shim already installed at ${existing.wrapperPath}.` };
   }
   if (existing && existsSync(existing.backupPath) && (!existsSync(existing.wrapperPath) || !isShim(existing.wrapperPath))) {
-    if (existsSync(existing.wrapperPath)) renameSync(existing.wrapperPath, existing.backupPath);
+    if (existsSync(existing.wrapperPath)) unlinkSync(existing.wrapperPath);
     writeShim(existing.wrapperPath, existing.backupPath);
     writeState({ ...existing, platform: process.platform });
     return {

package/src/config.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, chmodSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import type { OcxConfig } from "./types";
@@ -10,7 +10,7 @@ let _atomicSeq = 0;
  */
 export function atomicWriteFile(path: string, content: string): void {
   const tmp = `${path}.ocx.${process.pid}.${++_atomicSeq}.tmp`;
-  writeFileSync(tmp, content, "utf-8");
+  writeFileSync(tmp, content, { encoding: "utf-8", mode: 0o600 });
   renameSync(tmp, path);
 }
 
@@ -39,7 +39,22 @@ export function getPidPath(): string {
   return PID_PATH;
 }
 
+export function hardenConfigDir(): void {
+  if (existsSync(OCX_DIR)) {
+    try { chmodSync(OCX_DIR, 0o700); } catch { /* best-effort */ }
+  }
+}
+
+export function hardenExistingSecret(path: string): void {
+  if (existsSync(path)) {
+    try { chmodSync(path, 0o600); } catch { /* best-effort */ }
+  }
+}
+
 export function loadConfig(): OcxConfig {
+  hardenConfigDir();
+  hardenExistingSecret(CONFIG_PATH);
+  hardenExistingSecret(join(OCX_DIR, "auth.json"));
   if (!existsSync(CONFIG_PATH)) {
     return getDefaultConfig();
   }
@@ -53,15 +68,21 @@ export function loadConfig(): OcxConfig {
 
 export function saveConfig(config: OcxConfig): void {
   if (!existsSync(OCX_DIR)) {
-    mkdirSync(OCX_DIR, { recursive: true });
+    mkdirSync(OCX_DIR, { recursive: true, mode: 0o700 });
+  } else {
+    try { chmodSync(OCX_DIR, 0o700); } catch { /* best-effort on existing dir */ }
   }
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  atomicWriteFile(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
 }
 
 export function websocketsEnabled(config: Pick<OcxConfig, "websockets">): boolean {
   return config.websockets === true;
 }
 
+export function codexAutoStartEnabled(config: Pick<OcxConfig, "codexAutoStart">): boolean {
+  return config.codexAutoStart !== false;
+}
+
 export function getDefaultConfig(): OcxConfig {
   // Fresh-install default: works out of the box with Codex's ChatGPT OAuth (no API key).
   // gpt-* requests forward the caller's incoming OAuth headers to the ChatGPT backend.
@@ -78,6 +99,7 @@ export function getDefaultConfig(): OcxConfig {
     defaultProvider: "openai",
     subagentModels: [...DEFAULT_SUBAGENT_MODELS],
     websockets: false,
+    codexAutoStart: true,
   };
 }
 
@@ -90,7 +112,11 @@ export function resolveEnvValue(value: string | undefined): string | undefined {
 }
 
 export function writePid(pid: number): void {
-  if (!existsSync(OCX_DIR)) mkdirSync(OCX_DIR, { recursive: true });
+  if (!existsSync(OCX_DIR)) {
+    mkdirSync(OCX_DIR, { recursive: true, mode: 0o700 });
+  } else {
+    hardenConfigDir();
+  }
   writeFileSync(PID_PATH, String(pid), "utf-8");
 }
 

package/src/init.ts

@@ -131,6 +131,17 @@ export async function runInit(): Promise<void> {
     console.log(result.success ? `✅ ${result.message}` : `⚠️  ${result.message}`);
   }
 
+  const shimAnswer = await prompt.ask("Install Codex autostart shim? [Y/n]: ");
+  if (shimAnswer.trim().toLowerCase() !== "n") {
+    try {
+      const { installCodexShim } = await import("./codex-shim");
+      const result = installCodexShim();
+      console.log(result.installed ? `✅ ${result.message}` : `⚠️  ${result.message}`);
+    } catch (err) {
+      console.log(`⚠️  Codex autostart shim skipped: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
   console.log(`\n🚀 Setup complete! Run 'ocx start' to start the proxy.`);
   prompt.close();
 }

package/src/oauth/store.ts

@@ -1,13 +1,15 @@
 /** OAuth token store at ~/.opencodex/auth.json, keyed by provider name. */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, chmodSync } from "node:fs";
 import { join } from "node:path";
-import { getConfigDir } from "../config";
+import { getConfigDir, atomicWriteFile, hardenConfigDir, hardenExistingSecret } from "../config";
 import type { OAuthCredentials } from "./types";
 
 const AUTH_PATH = join(getConfigDir(), "auth.json");
 type AuthStore = Record<string, OAuthCredentials>;
 
 export function loadAuthStore(): AuthStore {
+  hardenConfigDir();
+  hardenExistingSecret(AUTH_PATH);
   if (!existsSync(AUTH_PATH)) return {};
   try {
     return JSON.parse(readFileSync(AUTH_PATH, "utf-8")) as AuthStore;
@@ -18,8 +20,12 @@ export function loadAuthStore(): AuthStore {
 
 function persist(store: AuthStore): void {
   const dir = getConfigDir();
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(AUTH_PATH, JSON.stringify(store, null, 2) + "\n", "utf-8");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+  } else {
+    try { chmodSync(dir, 0o700); } catch { /* best-effort on existing dir */ }
+  }
+  atomicWriteFile(AUTH_PATH, JSON.stringify(store, null, 2) + "\n");
 }
 
 export function getCredential(provider: string): OAuthCredentials | null {

package/src/open-url.ts

@@ -1,9 +1,13 @@
-import { exec } from "node:child_process";
+import { spawn } from "node:child_process";
 
 export function openUrl(url: string): void {
+  if (!/^https?:\/\//i.test(url)) return;
   const cmd =
     process.platform === "darwin" ? "open"
-    : process.platform === "win32" ? 'start ""'
+    : process.platform === "win32" ? "rundll32"
     : "xdg-open";
-  exec(`${cmd} ${JSON.stringify(url)}`);
+  const args = process.platform === "win32"
+    ? ["url.dll,FileProtocolHandler", url]
+    : [url];
+  spawn(cmd, args, { detached: true, stdio: "ignore", shell: false }).unref();
 }

package/src/ports.ts

@@ -0,0 +1,30 @@
+import { createServer } from "node:net";
+
+export async function isPortAvailable(port: number, hostname = "127.0.0.1"): Promise<boolean> {
+  return await new Promise(resolve => {
+    const server = createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen({ port, host: hostname });
+  });
+}
+
+export async function findAvailablePort(preferredPort: number, hostname = "127.0.0.1"): Promise<number> {
+  if (await isPortAvailable(preferredPort, hostname)) return preferredPort;
+  return await new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.once("listening", () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      server.close(() => {
+        if (port > 0) resolve(port);
+        else reject(new Error("failed to allocate an available port"));
+      });
+    });
+    server.listen({ port: 0, host: hostname });
+  });
+}
+

package/src/providers/registry.ts

@@ -176,7 +176,7 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
   { id: "openrouter", label: "OpenRouter", adapter: "openai-chat", baseUrl: "https://openrouter.ai/api/v1", authKind: "key", featured: true, dashboardUrl: "https://openrouter.ai/keys", jawcodeBundle: "openrouter" },
   { id: "groq", label: "Groq", adapter: "openai-chat", baseUrl: "https://api.groq.com/openai/v1", authKind: "key", featured: true, dashboardUrl: "https://console.groq.com/keys" },
   { id: "google", label: "Google Gemini", adapter: "google", baseUrl: "https://generativelanguage.googleapis.com", authKind: "key", featured: true, dashboardUrl: "https://aistudio.google.com/apikey", defaultModel: "gemini-3-pro", jawcodeBundle: "google", extraMetadataAliases: ["gemini"] },
-  { id: "azure-openai", label: "Azure OpenAI", adapter: "azure-openai", baseUrl: "https://{resource}.openai.azure.com/openai/deployments/{deployment}", authKind: "key", featured: true, dashboardUrl: "https://portal.azure.com" },
+  { id: "azure-openai", label: "Azure OpenAI", adapter: "azure-openai", baseUrl: "https://{resource}.openai.azure.com/openai", authKind: "key", featured: true, dashboardUrl: "https://portal.azure.com" },
   { id: "ollama", label: "Ollama (local)", adapter: "openai-chat", baseUrl: "http://localhost:11434/v1", authKind: "local", featured: true, note: "Local — key usually blank" },
   { id: "vllm", label: "vLLM (local)", adapter: "openai-chat", baseUrl: "http://localhost:8000/v1", authKind: "local", featured: true, note: "Local — key usually blank" },
   { id: "lm-studio", label: "LM Studio (local)", adapter: "openai-chat", baseUrl: "http://localhost:1234/v1", authKind: "local", featured: true, note: "Local — no key needed" },

package/src/responses/parser.ts

@@ -177,15 +177,15 @@ function outputToToolResultContent(output: string | unknown[] | undefined): stri
   return parts;
 }
 
-function findToolNameById(messages: OcxMessage[], callId: string): string {
+function findToolById(messages: OcxMessage[], callId: string): { name: string; namespace?: string } {
   for (let i = messages.length - 1; i >= 0; i--) {
     const m = messages[i];
     if (m.role !== "assistant") continue;
     for (const part of m.content) {
-      if (part.type === "toolCall" && part.id === callId) return part.name;
+      if (part.type === "toolCall" && part.id === callId) return { name: part.name, namespace: part.namespace };
     }
   }
-  return "";
+  return { name: "" };
 }
 
 const REASONING_EFFORTS = new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
@@ -327,9 +327,10 @@ export function parseRequest(body: unknown): OcxParsedRequest {
 
       if (effectiveType === "function_call_output") {
         const output = item as { call_id: string; output?: string | unknown[] };
+        const toolInfo = findToolById(messages, output.call_id);
         messages.push({
           role: "toolResult", toolCallId: output.call_id,
-          toolName: findToolNameById(messages, output.call_id),
+          toolName: toolInfo.name, toolNamespace: toolInfo.namespace,
           content: outputToToolResultContent(output.output), isError: false, timestamp: now,
         });
         continue;
@@ -337,9 +338,10 @@ export function parseRequest(body: unknown): OcxParsedRequest {
 
       if (effectiveType === "custom_tool_call_output") {
         const output = item as { call_id: string; output: string };
+        const toolInfo = findToolById(messages, output.call_id);
         messages.push({
           role: "toolResult", toolCallId: output.call_id,
-          toolName: findToolNameById(messages, output.call_id),
+          toolName: toolInfo.name, toolNamespace: toolInfo.namespace,
           content: output.output ?? "", isError: false, timestamp: now,
         });
       }
@@ -373,7 +375,8 @@ export function parseRequest(body: unknown): OcxParsedRequest {
   if (data.reasoning?.effort && REASONING_EFFORTS.has(data.reasoning.effort)) {
     options.reasoning = data.reasoning.effort;
   }
-  if (data.reasoning?.summary === "none") options.hideThinkingSummary = true;
+  const summaryMode = data.reasoning?.summary;
+  if (!summaryMode || summaryMode === "none") options.hideThinkingSummary = true;
   if (data.presence_penalty !== undefined) options.presencePenalty = data.presence_penalty;
   if (data.frequency_penalty !== undefined) options.frequencyPenalty = data.frequency_penalty;
 

package/src/responses/schema.ts

@@ -50,6 +50,7 @@ const functionCallItemSchema = z.object({
   id: z.string().optional(),
   call_id: z.string().min(1),
   name: z.string().min(1),
+  namespace: z.string().optional(),
   arguments: z.string().optional(),
 });
 const functionCallOutputItemSchema = z.object({