codex-grok-bridge 1.0.4 → 1.5.0

package/scripts/launch-desktop.mjs

@@ -1,11 +1,19 @@
 import { execFileSync, spawn } from "node:child_process";
 import { appendFileSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import {
+  desktopLaunchArgs,
+  desktopLaunchEnv,
+  desktopUserDataDir,
+  isGrokDesktopProcess,
+  resolveDesktopApp,
+  resolvePlatform,
+} from "../src/paths.mjs";
 
-const userData = path.join(homedir(), ".local/share/codex-grok-bridge/desktop");
-const logFile = path.join(homedir(), ".local/share/codex-grok-bridge/launch.log");
+const platform = resolvePlatform();
+const userData = desktopUserDataDir();
+const logFile = path.join(userData, "..", "launch.log");
 mkdirSync(userData, { recursive: true, mode: 0o700 });
 mkdirSync(path.dirname(logFile), { recursive: true, mode: 0o700 });
 
@@ -13,17 +21,33 @@ function log(message) {
   appendFileSync(logFile, `${new Date().toISOString()} ${message}\n`);
 }
 
+function grokPidWin32() {
+  const systemRoot = process.env.SystemRoot || "C:\\Windows";
+  const powershell = `${systemRoot}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+  try {
+    const out = execFileSync(
+      powershell,
+      [
+        "-NoProfile",
+        "-Command",
+        `Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like ${JSON.stringify(`*--user-data-dir=${userData}*`)} } | Select-Object -First 1 -ExpandProperty ProcessId`,
+      ],
+      { encoding: "utf8", windowsHide: true, timeout: 15000 },
+    );
+    const pid = Number(String(out).trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
 function grokPid() {
+  if (platform === "win32") return grokPidWin32();
   const out = execFileSync("/bin/ps", ["-axo", "pid=,command="], {
     encoding: "utf8",
   });
   for (const line of out.split("\n")) {
-    if (
-      line.includes(`--user-data-dir=${userData}`) &&
-      /MacOS\/(ChatGPT|Codex)(\s|$)/.test(line) &&
-      !line.includes("Helper") &&
-      !line.includes("crashpad")
-    )
+    if (isGrokDesktopProcess(line, userData))
       return Number(line.trim().split(/\s+/)[0]);
   }
   return null;
@@ -41,6 +65,7 @@ function activate(pid) {
 }
 
 function notify(text) {
+  if (platform !== "darwin") return;
   try {
     execFileSync("/usr/bin/osascript", [
       "-e",
@@ -49,19 +74,48 @@ function notify(text) {
   } catch {}
 }
 
-const wrapper = fileURLToPath(new URL("./codex-wrapper.mjs", import.meta.url));
-try {
-  const running = grokPid();
-  if (running) {
-    log(`activate pid=${running}`);
-    try {
-      activate(running);
-      notify("Codex Grok 창을 앞으로 가져왔습니다.");
-      process.exit(0);
-    } catch (error) {
-      log(`activate failed: ${error.message}`);
-    }
-  }
+function startWin32(wrapper) {
+  const app = resolveDesktopApp();
+  log(`start win32 app=${app} wrapper=${wrapper}`);
+  const child = spawn(app, desktopLaunchArgs(userData), {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...desktopLaunchEnv({ wrapper, userData }),
+    },
+  });
+  child.on("error", (error) => {
+    log(`spawn failed: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    log(`chatgpt exit=${code}`);
+    process.exit(code ?? 1);
+  });
+}
+
+function startLinux(wrapper) {
+  const app = resolveDesktopApp();
+  const pathPrefix = `${path.dirname(process.execPath)}:/usr/local/bin:/usr/bin:/bin`;
+  log(`start linux app=${app} wrapper=${wrapper}`);
+  const child = spawn(app, desktopLaunchArgs(userData), {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...desktopLaunchEnv({ wrapper, userData, pathPrefix }),
+    },
+  });
+  child.on("error", (error) => {
+    log(`spawn failed: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    log(`chatgpt exit=${code}`);
+    process.exit(code ?? 1);
+  });
+}
+
+function startDarwin(wrapper) {
   log(`start wrapper=${wrapper}`);
   const child = spawn(
     "/usr/bin/open",
@@ -95,6 +149,27 @@ try {
     }
     process.exit(code ?? 1);
   });
+}
+
+const wrapper = fileURLToPath(new URL("./codex-wrapper.mjs", import.meta.url));
+try {
+  const running = grokPid();
+  if (running) {
+    log(`activate pid=${running}`);
+    if (platform !== "darwin") {
+      process.exit(0);
+    }
+    try {
+      activate(running);
+      notify("Codex Grok 창을 앞으로 가져왔습니다.");
+      process.exit(0);
+    } catch (error) {
+      log(`activate failed: ${error.message}`);
+    }
+  }
+  if (platform === "linux") startLinux(wrapper);
+  else if (platform === "win32") startWin32(wrapper);
+  else startDarwin(wrapper);
 } catch (error) {
   log(`fatal: ${error.message}`);
   notify(error.message);

package/src/bridge.mjs

@@ -13,35 +13,9 @@ import { toProxyRequest } from "./tools.mjs";
 import { classifyBridgeError, errorSignature, bridgeErrorMessage } from "./errors.mjs";
 import { createDiagnostics } from "./diagnostics.mjs";
 import { createSlots } from "./slots.mjs";
+import { catalogModelInfos, isGrokModel, MODEL_INFO } from "./models.mjs";
 
-export const MODEL_INFO = {
-  slug: "grok-4.6",
-  display_name: "Grok 4.6 / xAI",
-  description: "Grok 4.6 via grok login; Codex executes tools",
-  default_reasoning_level: "high",
-  supported_reasoning_levels: ["low", "medium", "high", "xhigh"].map(
-    (effort) => ({ effort, description: effort }),
-  ),
-  shell_type: "unified_exec",
-  visibility: "list",
-  supported_in_api: true,
-  priority: 50,
-  availability_nux: null,
-  upgrade: null,
-  support_verbosity: false,
-  default_verbosity: null,
-  apply_patch_tool_type: "freeform",
-  truncation_policy: { mode: "tokens", limit: 10000 },
-  experimental_supported_tools: [],
-  context_window: 500000,
-  input_modalities: ["text", "image"],
-  tool_mode: "direct",
-  node_repl_disabled: true,
-  model_messages: {
-    instructions_template:
-      "You are Grok 4.6 by xAI, running as the Codex model. Use the tools provided by Codex and respect its permissions. Complete the user request accurately.",
-  },
-};
+export { MODEL_INFO };
 
 export function publicBridgeError(error, context = {}) {
   if (error instanceof GrokAuthError) return error.message;
@@ -69,7 +43,7 @@ export function createBridgeServer(options = {}) {
     };
     const route = new URL(req.url, "http://127.0.0.1").pathname;
     if (req.method === "GET" && route === "/v1/models")
-      return json(200, { models: [MODEL_INFO] });
+      return json(200, { models: catalogModelInfos() });
     if (req.method !== "POST" || route !== "/v1/responses")
       return json(404, { error: "Not found" });
     const auth = Buffer.from(req.headers.authorization ?? "");
@@ -95,7 +69,7 @@ export function createBridgeServer(options = {}) {
       }
       requestBytes = size;
       body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-      if (body?.model !== "grok-4.6" || !Array.isArray(body.input))
+      if (!isGrokModel(body?.model) || !Array.isArray(body.input))
         throw new Error();
     } catch {
       return json(400, { error: "Invalid request" });

package/src/cli-inference.mjs

@@ -5,6 +5,8 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir, homedir } from "node:os";
 import path from "node:path";
 import { toImageBlocks } from "./images.mjs";
+import { resolveGrokBinary } from "./paths.mjs";
+import { resolveGrokModel } from "./models.mjs";
 
 // The GROK_BRIDGE_INFERENCE=cli fallback. It drives the Grok CLI once per turn
 // with the whole Codex request as a prompt and parses a JSON envelope back out.
@@ -59,7 +61,7 @@ export function buildGrokInvocation(body, options = {}) {
     "--single",
     extractLatestUserPrompt(body.input),
     "--model",
-    "grok-4.6",
+    resolveGrokModel(body.model),
     "--output-format",
     "json",
     "--json-schema",
@@ -117,7 +119,7 @@ export function buildGrokInvocation(body, options = {}) {
     "You are a model backend for Codex. Return exactly the JSON envelope requested in the input. Do not execute your own tools. Tool calls in the envelope are executed by Codex.",
   ];
   return {
-    binary: options.grokBinary ?? path.join(homedir(), ".grok/bin/grok"),
+    binary: options.grokBinary ?? resolveGrokBinary(homedir()),
     args,
     // Run the CLI where Codex is working, not where the bridge happens to live.
     cwd:

package/src/models.mjs

@@ -0,0 +1,121 @@
+export const DEFAULT_GROK_MODEL = "grok-4.6";
+export const GROK_PROVIDER = "grok_build_cli";
+
+export function isGrokModel(model) {
+  return typeof model === "string" && model.startsWith("grok-");
+}
+
+export function resolveGrokModel(model) {
+  return isGrokModel(model) ? model : DEFAULT_GROK_MODEL;
+}
+
+export function grokDisplayName(id) {
+  return `Grok ${String(id).slice("grok-".length)}`;
+}
+
+export function extraGrokModels(env = process.env) {
+  const raw = env.GROK_BRIDGE_MODELS ?? "";
+  const seen = new Set();
+  const ids = [];
+  for (const part of raw.split(/[,\s]+/)) {
+    const id = part.trim();
+    if (!isGrokModel(id) || seen.has(id)) continue;
+    seen.add(id);
+    ids.push(id);
+  }
+  return ids;
+}
+
+export function catalogModelIds(env = process.env) {
+  const ids = [DEFAULT_GROK_MODEL];
+  const seen = new Set(ids);
+  for (const id of extraGrokModels(env)) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    ids.push(id);
+  }
+  return ids;
+}
+
+export function parseGrokCliModels(text) {
+  const ids = [];
+  const seen = new Set();
+  for (const line of String(text).split(/\r?\n/)) {
+    const match = line.match(/^\s*[*+-]\s+(grok-[^\s(]+)/);
+    if (!match || seen.has(match[1])) continue;
+    seen.add(match[1]);
+    ids.push(match[1]);
+  }
+  return ids;
+}
+
+export function modelEntry(id = DEFAULT_GROK_MODEL) {
+  const label = grokDisplayName(id);
+  return {
+    id,
+    model: id,
+    displayName: `${label} / xAI`,
+    description: `${label} · Codex tools`,
+    hidden: false,
+    isDefault: false,
+    upgrade: null,
+    upgradeInfo: null,
+    availabilityNux: null,
+    supportedReasoningEfforts: ["low", "medium", "high", "xhigh"].map(
+      (reasoningEffort) => ({ reasoningEffort, description: reasoningEffort }),
+    ),
+    defaultReasoningEffort: "high",
+    inputModalities: ["text", "image"],
+    supportsPersonality: false,
+    multiAgentVersion: null,
+    additionalSpeedTiers: [],
+    serviceTiers: [],
+  };
+}
+
+export function modelInfo(id = DEFAULT_GROK_MODEL) {
+  const label = grokDisplayName(id);
+  return {
+    slug: id,
+    display_name: `${label} / xAI`,
+    description: `${label} via grok login; Codex executes tools`,
+    default_reasoning_level: "high",
+    supported_reasoning_levels: ["low", "medium", "high", "xhigh"].map(
+      (effort) => ({ effort, description: effort }),
+    ),
+    shell_type: "unified_exec",
+    visibility: "list",
+    supported_in_api: true,
+    priority: 50,
+    availability_nux: null,
+    upgrade: null,
+    support_verbosity: false,
+    default_verbosity: null,
+    apply_patch_tool_type: "freeform",
+    truncation_policy: { mode: "tokens", limit: 10000 },
+    experimental_supported_tools: [],
+    context_window: 500000,
+    input_modalities: ["text", "image"],
+    tool_mode: "direct",
+    node_repl_disabled: true,
+    model_messages: {
+      instructions_template:
+        `You are ${label} by xAI, running as the Codex model. Use the tools provided by Codex and respect its permissions. Complete the user request accurately.`,
+    },
+  };
+}
+
+export const MODEL_ENTRY = modelEntry();
+export const MODEL_INFO = modelInfo();
+
+export function catalogModelEntries(env = process.env) {
+  return catalogModelIds(env).map((id) =>
+    id === DEFAULT_GROK_MODEL ? MODEL_ENTRY : modelEntry(id),
+  );
+}
+
+export function catalogModelInfos(env = process.env) {
+  return catalogModelIds(env).map((id) =>
+    id === DEFAULT_GROK_MODEL ? MODEL_INFO : modelInfo(id),
+  );
+}

package/src/paths.mjs

@@ -0,0 +1,163 @@
+import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+
+export const LINUX_CODEX_BINARY = "/usr/lib/chatgpt/resources/codex";
+export const LINUX_CHATGPT_BIN = "/usr/lib/chatgpt/ChatGPT";
+export const DARWIN_CODEX_BINARY = "/Applications/Codex.app/Contents/Resources/codex";
+export const DARWIN_CODEX_APP = "/Applications/Codex.app";
+export const LINUX_STOCK_PREFIX = "/usr/lib/chatgpt";
+export const WIN32_WINDOWSAPPS = "WindowsApps";
+export const WIN32_BRIDGE_APP = "codex-grok-bridge";
+
+export function resolvePlatform(options = {}) {
+  const env = options.env ?? process.env;
+  return options.platform ?? env.CODEX_GROK_PLATFORM ?? process.platform;
+}
+
+export function localAppData(home = homedir(), options = {}) {
+  const env = options.env ?? process.env;
+  if (env.LOCALAPPDATA) return env.LOCALAPPDATA;
+  return path.join(home, "AppData", "Local");
+}
+
+export function win32AppDir(home = homedir(), options = {}) {
+  return path.join(localAppData(home, options), WIN32_BRIDGE_APP, "app");
+}
+
+export function win32StorePointer(home = homedir(), options = {}, name = "store-app.txt") {
+  return path.join(localAppData(home, options), WIN32_BRIDGE_APP, name);
+}
+
+function readPointer(file, options = {}) {
+  const exists = options.existsSync ?? existsSync;
+  const read = options.readFileSync ?? ((p) => readFileSync(p, "utf8"));
+  if (!exists(file)) return "";
+  return String(read(file)).trim();
+}
+
+function resolveWin32Binary(fileName, pointerName, options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  const exists = options.existsSync ?? existsSync;
+  const isolated = path.join(win32AppDir(home, { env }), fileName);
+  if (exists(isolated)) return isolated;
+  const pointed = readPointer(win32StorePointer(home, { env }, pointerName), options);
+  return pointed || isolated;
+}
+
+export function resolveCodexBinary(options = {}) {
+  const env = options.env ?? process.env;
+  if (env.CODEX_BINARY) return env.CODEX_BINARY;
+  const platform = resolvePlatform({ ...options, env });
+  if (platform === "linux") return LINUX_CODEX_BINARY;
+  if (platform === "win32") {
+    return resolveWin32Binary("codex.exe", "store-codex.txt", { ...options, env });
+  }
+  return DARWIN_CODEX_BINARY;
+}
+
+export function resolveDesktopApp(options = {}) {
+  const env = options.env ?? process.env;
+  if (env.CODEX_DESKTOP_APP) return env.CODEX_DESKTOP_APP;
+  const platform = resolvePlatform({ ...options, env });
+  if (platform === "linux") return LINUX_CHATGPT_BIN;
+  if (platform === "win32") {
+    return resolveWin32Binary("ChatGPT.exe", "store-app.txt", { ...options, env });
+  }
+  return DARWIN_CODEX_APP;
+}
+
+export function resolveGrokBinary(home = homedir(), options = {}) {
+  const env = options.env ?? process.env;
+  if (env.GROK_BINARY) return env.GROK_BINARY;
+  const platform = resolvePlatform({ ...options, env });
+  const name = platform === "win32" ? "grok.exe" : "grok";
+  return path.join(home, ".grok", "bin", name);
+}
+
+export function desktopUserDataDir(home = homedir(), options = {}) {
+  const env = options.env ?? process.env;
+  if (resolvePlatform({ ...options, env }) === "win32") {
+    return path.join(localAppData(home, { env }), WIN32_BRIDGE_APP, "desktop");
+  }
+  return path.join(home, ".local/share/codex-grok-bridge/desktop");
+}
+
+export function linuxAppDir(home = homedir()) {
+  return path.join(home, ".local/share/codex-grok-bridge/app");
+}
+
+export function linuxDesktopEntryPath(home = homedir(), xdgDataHome) {
+  const dataHome = xdgDataHome || path.join(home, ".local/share");
+  return path.join(dataHome, "applications", "codex-grok.desktop");
+}
+
+export function desktopLaunchEnv({ wrapper, userData, pathPrefix }) {
+  const env = {
+    CODEX_CLI_PATH: wrapper,
+    CODEX_APP_SERVER_FORCE_CLI: "1",
+    CODEX_ELECTRON_USER_DATA_PATH: userData,
+  };
+  if (pathPrefix) env.PATH = pathPrefix;
+  return env;
+}
+
+export function desktopLaunchArgs(userData) {
+  return [`--user-data-dir=${userData}`];
+}
+
+export function isGrokDesktopProcess(line, userData, options = {}) {
+  if (!line.includes(`--user-data-dir=${userData}`)) return false;
+  if (line.includes("Helper") || line.includes("crashpad")) return false;
+  const app = resolveDesktopApp(options);
+  if (line.includes(app)) return true;
+  const platform = resolvePlatform(options);
+  if (platform === "linux") return line.includes(LINUX_CHATGPT_BIN);
+  if (platform === "win32") {
+    return /ChatGPT\.exe|Codex\.exe/i.test(line);
+  }
+  return /MacOS\/(ChatGPT|Codex)(\s|$)/.test(line);
+}
+
+export function isForbiddenInstallDir(app) {
+  const resolved = path.resolve(app);
+  const norm = resolved.replace(/\\/g, "/").toLowerCase();
+  const asPosix = String(app).replace(/\\/g, "/");
+  const forbidden = [
+    LINUX_STOCK_PREFIX,
+    "/usr/bin/chatgpt",
+    "/usr/share/applications/chatgpt.desktop",
+    DARWIN_CODEX_APP,
+  ];
+  if (
+    forbidden.some((prefix) => {
+      const p = prefix.toLowerCase();
+      return (
+        asPosix === prefix ||
+        asPosix.startsWith(`${prefix}/`) ||
+        norm === p ||
+        norm.endsWith(p) ||
+        norm.includes(`${p}/`)
+      );
+    })
+  ) {
+    return true;
+  }
+  return norm.includes("/windowsapps/") || norm.endsWith("/windowsapps");
+}
+
+export function linuxDesktopEntry({ exec, icon = "chatgpt" }) {
+  return [
+    "[Desktop Entry]",
+    "Type=Application",
+    "Name=Codex Grok",
+    "Comment=Codex desktop with Grok via the local bridge",
+    `Exec=${exec}`,
+    `Icon=${icon}`,
+    "Terminal=false",
+    "Categories=Development;",
+    "StartupWMClass=ChatGPT",
+    "",
+  ].join("\n");
+}

package/src/proxy.mjs

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { resolveGrokBinary } from "./paths.mjs";
 import { createSseRewriter } from "./tools.mjs";
 import { requestStream } from "./transport.mjs";
 import { BRIDGE_ERROR, classifyBridgeError } from "./errors.mjs";
@@ -15,7 +15,7 @@ export function detectGrokClientVersion(home = homedir()) {
   try {
     // Synchronous, and on the first request's critical path: a grok binary that
     // hangs would freeze the whole bridge event loop without a timeout.
-    const output = execFileSync(join(home, ".grok/bin/grok"), ["--version"], {
+    const output = execFileSync(resolveGrokBinary(home), ["--version"], {
       encoding: "utf8",
       timeout: 5000,
     });

package/src/router.mjs

@@ -1,25 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
+import { catalogModelEntries, isGrokModel, MODEL_ENTRY } from "./models.mjs";
 
-export const MODEL_ENTRY = {
-  id: "grok-4.6",
-  model: "grok-4.6",
-  displayName: "Grok 4.6 / xAI",
-  description: "Grok 4.6 · Codex tools",
-  hidden: false,
-  isDefault: false,
-  upgrade: null,
-  upgradeInfo: null,
-  availabilityNux: null,
-  supportedReasoningEfforts: ["low", "medium", "high", "xhigh"].map(
-    (reasoningEffort) => ({ reasoningEffort, description: reasoningEffort }),
-  ),
-  defaultReasoningEffort: "high",
-  inputModalities: ["text", "image"],
-  supportsPersonality: false,
-  multiAgentVersion: null,
-  additionalSpeedTiers: [],
-  serviceTiers: [],
-};
+export { MODEL_ENTRY };
 
 export class Router {
   constructor(catalogPath) {
@@ -45,7 +27,7 @@ export class Router {
     const fresh = this.unstarted.get(p.threadId);
     const snapshot = fresh ?? await rpc("thread/resume", { threadId: p.threadId, excludeTurns: true });
     const model = selected ?? snapshot.model;
-    const provider = model === "grok-4.6"
+    const provider = isGrokModel(model)
       ? "grok_build_cli"
       : model?.startsWith("gpt-") && snapshot.modelProvider === "grok_build_cli"
         ? "openai" : snapshot.modelProvider;
@@ -73,7 +55,7 @@ export class Router {
     const msg = structuredClone(message),
       p = msg.params ?? {};
     const model = p.collaborationMode?.settings?.model ?? p.model;
-    const grok = model === "grok-4.6";
+    const grok = isGrokModel(model);
     if (
       ["thread/start", "thread/resume", "thread/fork"].includes(
         msg.method,
@@ -95,12 +77,12 @@ export class Router {
     this.pending.delete(msg.id);
     if (request.method === "thread/start" && msg.result?.thread?.id)
       this.unstarted.set(msg.result.thread.id, structuredClone(msg.result));
-    if (
-      request.method === "model/list" &&
-      Array.isArray(msg.result?.data) &&
-      !msg.result.data.some((m) => m.id === "grok-4.6")
-    )
-      msg.result.data.push(MODEL_ENTRY);
+    if (request.method === "model/list" && Array.isArray(msg.result?.data)) {
+      for (const entry of catalogModelEntries()) {
+        if (!msg.result.data.some((m) => m.id === entry.id))
+          msg.result.data.push(entry);
+      }
+    }
     if (
       ["thread/start", "thread/resume", "thread/fork"].includes(
         request.method,

package/src/runtime.mjs

@@ -3,13 +3,14 @@ import { mkdtemp, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { once } from "node:events";
-import { createBridgeServer, MODEL_INFO } from "./bridge.mjs";
+import { createBridgeServer } from "./bridge.mjs";
+import { catalogModelInfos } from "./models.mjs";
 
 export async function startRuntime(options = {}) {
   const token = randomBytes(32).toString("hex");
   const dir = await mkdtemp(path.join(tmpdir(), "codex-grok-runtime-"));
   const catalogPath = path.join(dir, "models.json");
-  await writeFile(catalogPath, JSON.stringify({ models: [MODEL_INFO] }), {
+  await writeFile(catalogPath, JSON.stringify({ models: catalogModelInfos() }), {
     mode: 0o600,
   });
   const server = createBridgeServer({