@codexapi/codexclaude 2.0.4

package/CUSTOMIZATIONS.md

@@ -0,0 +1,54 @@
+# CodexAPI.pro Customizations
+
+`codexclaude` intentionally tracks the official OpenAI Codex CLI while keeping a thin CodexAPI.pro launcher layer.
+
+## Upstream Runtime
+
+- Official package: `@openai/codex`
+- Pinned runtime version: `0.134.0`
+- Local launcher version: `2.0.4`
+
+## Launcher Behavior
+
+- Authenticates customers against `https://codexapi.pro/api/v1/auth/login`.
+- Saves the returned API username in `~/.codexclaude/config.json`.
+- Rewrites `~/.codex/config.toml` before every launch.
+- Starts official Codex with `--search` by default.
+- Passes all unknown commands directly to the official Codex CLI.
+- Provides `codexclaude changelog` so users can see forced-update changes from the terminal.
+- Checks npm latest at startup and blocks coding with an Update Now command when a newer launcher is available.
+
+## Provider Config
+
+The launcher writes a Codex model provider named `codexapi`:
+
+- `base_url = "https://codexapi.pro/v1"`
+- `wire_api = "responses"`
+- `supports_websockets = false`
+- `experimental_bearer_token` set to the customer API username
+- `http_headers` identify launcher traffic to CodexAPI.pro for server-side plan enforcement
+
+## Runtime Defaults
+
+- Model: selected by the user, defaulting to `gpt-5.5`; supported launcher choices are `gpt-5.5`, `claude-opus-4-7`, and `deepseek-v4-pro`.
+- Reasoning effort: `high`
+- Service tier: `fast`
+- Approval policy: `never`
+- Sandbox mode: `danger-full-access`
+- TUI status line: `model-with-reasoning`, `fast-mode`, `current-dir`
+- Opus 4.7 Responses traffic is routed through CodexAPI.pro's working Claude tool-call bridge.
+- Deepseek v4 Budget Responses traffic is routed through CodexAPI.pro's Deepseek-compatible gateway.
+
+## Wallet Display
+
+Before launching Codex, the launcher calls `/api/v1/me` using the saved API username as a bearer token and prints a compact status line:
+
+```text
+gpt-5.5 high fast · ~/project · Wallet $20.00
+```
+
+The same wallet lookup is available through:
+
+```bash
+codexclaude status
+```

package/README.md

@@ -0,0 +1,84 @@
+# codexclaude
+
+`codexclaude` is the CodexAPI.pro launcher for customers who want one coding CLI that can use ChatGPT-5.5, Opus 4.7, or Deepseek v4 Budget against the same CodexAPI.pro Token Wallet.
+
+Version `2.0.4` launches the official OpenAI Codex CLI `0.134.0` package and applies CodexAPI.pro account, wallet, model, and Full Access defaults before Codex starts.
+
+## Install
+
+```bash
+npm install -g https://codexapi.pro/downloads/codexapi-codexclaude-2.0.4.tgz
+```
+
+This installs the current `codexclaude` launcher from npm.
+
+## Required updates
+
+CodexAPI.pro checks the CodexAPI.pro API and npm at startup. If a newer required launcher is available, the app stops before coding starts and shows the exact **Update Now** command:
+
+```bash
+npm install -g https://codexapi.pro/downloads/codexapi-codexclaude-2.0.4.tgz
+```
+
+This does not delete your local Codex session history. The update only replaces the `codexclaude` launcher and refreshes the CodexAPI.pro provider config.
+
+## First Login
+
+```bash
+codexclaude login
+```
+
+Enter the dashboard username or email address and password. The launcher saves the API username locally, writes `~/.codex/config.toml`, sets Full Access defaults, and lets you choose the coding model.
+
+## Start Coding
+
+```bash
+codexclaude start
+```
+
+Resume the latest project:
+
+```bash
+codexclaude resume
+```
+
+Switch model:
+
+```bash
+codexclaude model
+```
+
+Available model labels are `ChatGPT-5.5`, `Opus 4.7`, and `Deepseek v4 Budget`. All three use the CodexAPI.pro Responses-compatible endpoint and the same customer Token Wallet.
+
+Show current launcher changes:
+
+```bash
+codexclaude changelog
+```
+
+## Wallet Status
+
+Before launching Codex, the app prints a compact status line like:
+
+```text
+gpt-5.5 high fast · ~/codexapi · Wallet $20.00
+```
+
+You can also check this without starting Codex:
+
+```bash
+codexclaude status
+```
+
+## Preserved CodexAPI.pro Customizations
+
+- Dashboard username or email plus password login.
+- ChatGPT-5.5, Opus 4.7, or Deepseek v4 Budget model selection.
+- CodexAPI.pro Responses-compatible provider at `https://codexapi.pro/v1`.
+- Full Access defaults: approval policy `never` and sandbox mode `danger-full-access`.
+- High reasoning and fast service tier defaults.
+- Official Codex `0.134.0` runtime with the current profile-compatible config enabled.
+- Token Wallet balance lookup before launch and in `codexclaude status`.
+- Opus 4.7 tool-call compatibility through the CodexAPI.pro Responses gateway.
+- Backend-identifying request headers so CodexAPI.pro can enforce subscription plan rules server-side.
+- npm latest-version checks before coding starts, with an explicit update command when a newer required launcher exists.

package/bin/codexclaude.js

@@ -0,0 +1,660 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const require = createRequire(import.meta.url);
+
+const APP_VERSION = "2.0.4";
+const CODEX_VERSION = "0.134.0";
+const CODEX_REASONING_EFFORT = "high";
+const CODEX_SERVICE_TIER = "fast";
+const API_ORIGIN = (process.env.CODEXCLAUDE_API_ORIGIN || "https://codexapi.pro").replace(/\/+$/, "");
+const API_BASE_URL = `${API_ORIGIN}/v1`;
+const VERSION_CHECK_PATH = "/api/v1/codexclaude/version";
+const NPM_PACKAGE_NAME = "@codexapi/codexclaude";
+const NPM_LATEST_URL = "https://registry.npmjs.org/@codexapi%2Fcodexclaude/latest";
+const UPDATE_COMMAND = `npm install -g ${NPM_PACKAGE_NAME}@latest`;
+const CONFIG_DIR = path.join(homedir(), ".codexclaude");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const CODEX_DIR = path.join(homedir(), ".codex");
+const CODEX_CONFIG_FILE = path.join(CODEX_DIR, "config.toml");
+const PROVIDER_ID = "codexapi";
+
+const MODELS = {
+  "gpt-5.5": {
+    id: "gpt-5.5",
+    label: "ChatGPT-5.5",
+    aliases: ["1", "gpt", "gpt-5.5", "chatgpt", "chatgpt-5.5"],
+  },
+  "claude-opus-4-7": {
+    id: "claude-opus-4-7",
+    label: "Opus 4.7",
+    aliases: ["2", "opus", "opus-4.7", "claude", "claude-opus-4-7"],
+  },
+  "deepseek-v4-pro": {
+    id: "deepseek-v4-pro",
+    label: "Deepseek v4 Budget",
+    aliases: ["3", "deepseek", "deepseek-v4", "deepseek-v4-pro", "budget"],
+    budget: true,
+  },
+};
+
+async function main() {
+  ensureExecutable();
+  const [command = "start", ...args] = process.argv.slice(2);
+  if (["-v", "--version", "version"].includes(command)) {
+    console.log(`codexclaude ${APP_VERSION}`);
+    return;
+  }
+  if (["-h", "--help", "help"].includes(command)) {
+    printHelp();
+    return;
+  }
+  if (["changelog", "changes", "whats-new"].includes(command)) {
+    await printChangelog();
+    return;
+  }
+  await enforceLauncherVersion();
+  if (command === "login") {
+    await loginFlow();
+    return;
+  }
+  if (command === "logout") {
+    logout();
+    return;
+  }
+  if (command === "status") {
+    await status();
+    return;
+  }
+  if (command === "model") {
+    await modelFlow();
+    return;
+  }
+  if (command === "setup") {
+    await setupFlow();
+    return;
+  }
+  if (command === "resume") {
+    await ensureReady();
+    await runCodex(["resume", "--search", ...args]);
+    return;
+  }
+  if (command === "start") {
+    await ensureReady();
+    await runCodex(args.length ? args : ["--search"]);
+    return;
+  }
+
+  await ensureReady();
+  await runCodex([command, ...args]);
+}
+
+function printHelp() {
+  console.log(`
+codexclaude ${APP_VERSION}
+
+Commands:
+  codexclaude login       Login with CodexAPI.pro username/email and password
+  codexclaude model       Select ChatGPT-5.5, Opus 4.7, or Deepseek v4 Budget
+  codexclaude changelog   Show the latest CodexAPI.pro launcher changes
+  codexclaude setup       Rewrite ~/.codex/config.toml with Full Access defaults
+  codexclaude start       Start Codex with --search
+  codexclaude resume      Resume with codex resume --search
+  codexclaude status      Show saved account, selected model, and wallet balance
+  codexclaude logout      Remove saved codexclaude account state
+
+Any other command is passed through to official Codex CLI ${CODEX_VERSION} after config is applied.
+`);
+}
+
+async function printChangelog() {
+  const metadata = await getJson(`${VERSION_CHECK_PATH}?current=${encodeURIComponent(APP_VERSION)}`);
+  console.log(`codexclaude ${metadata?.latestVersion || APP_VERSION}`);
+  console.log(`Required minimum: ${metadata?.minimumVersion || APP_VERSION}`);
+  const changes = Array.isArray(metadata?.changes) ? metadata.changes : [];
+  if (changes.length) {
+    console.log("\nChanges:");
+    for (const change of changes) {
+      console.log(`- ${change}`);
+    }
+  } else if (metadata?.changelog) {
+    console.log(`\n${metadata.changelog}`);
+  }
+  if (metadata?.installCommand) {
+    console.log(`\nUpdate command: ${metadata.installCommand}`);
+  }
+}
+
+async function loginFlow() {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const username = (await rl.question("CodexAPI.pro username or email: ")).trim();
+    const password = await rl.question("Dashboard password: ");
+    if (!username || !password) {
+      throw new Error("Username/email and password are required.");
+    }
+    const response = await postJson("/api/v1/auth/login", {
+      username,
+      password,
+      deviceName: `codexclaude ${APP_VERSION}`,
+    });
+    const apiUsername = response?.cliCredentials?.username || response?.user?.username;
+    if (!apiUsername) {
+      throw new Error("Login succeeded but no API username was returned.");
+    }
+    const existing = readConfig();
+    const selectedModel = await askModel(rl, existing?.model || "gpt-5.5");
+    const config = {
+      version: APP_VERSION,
+      apiOrigin: API_ORIGIN,
+      username: apiUsername,
+      dashboardEmail: response?.user?.email || null,
+      model: selectedModel,
+      loggedInAt: new Date().toISOString(),
+    };
+    saveConfig(config);
+    writeCodexConfig(config);
+    console.log(`\nLogged in as ${apiUsername}. Model: ${MODELS[selectedModel].label}.`);
+    console.log("Full Access permissions, high reasoning, fast mode, and CodexAPI.pro provider config were written.");
+  } finally {
+    rl.close();
+  }
+}
+
+async function modelFlow() {
+  const config = requireConfig();
+  const rl = readline.createInterface({ input, output });
+  try {
+    config.model = await askModel(rl, config.model || "gpt-5.5");
+    saveConfig(config);
+    writeCodexConfig(config);
+    console.log(`Model set to ${MODELS[config.model].label}.`);
+  } finally {
+    rl.close();
+  }
+}
+
+async function setupFlow() {
+  const config = requireConfig();
+  writeCodexConfig(config);
+  console.log(`Configured ${CODEX_CONFIG_FILE} for ${MODELS[config.model].label} with Full Access, high reasoning, and fast mode.`);
+}
+
+async function ensureReady() {
+  let config = readConfig();
+  if (!config?.username) {
+    await loginFlow();
+    config = requireConfig();
+  }
+  writeCodexConfig(config);
+}
+
+async function askModel(rl, current) {
+  const currentLabel = MODELS[current]?.label || MODELS["gpt-5.5"].label;
+  console.log("\nChoose your coding model:");
+  console.log("  1. ChatGPT-5.5");
+  console.log("  2. Opus 4.7");
+  console.log("  3. Deepseek v4 Budget");
+  const answer = (await rl.question(`Model [${currentLabel}]: `)).trim().toLowerCase();
+  if (!answer) {
+    return MODELS[current] ? current : "gpt-5.5";
+  }
+  const match = Object.values(MODELS).find((model) => model.aliases.includes(answer));
+  if (!match) {
+    throw new Error("Unknown model choice. Enter 1 for ChatGPT-5.5, 2 for Opus 4.7, or 3 for Deepseek v4 Budget.");
+  }
+  return match.id;
+}
+
+async function postJson(pathname, body) {
+  const response = await fetch(`${API_ORIGIN}${pathname}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "user-agent": `codexclaude/${APP_VERSION}`,
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { detail: text };
+  }
+  if (!response.ok) {
+    if (response.status === 426) {
+      throw new Error(updateRequiredMessage(payload));
+    }
+    throw new Error(payload?.detail || `Request failed with HTTP ${response.status}.`);
+  }
+  return payload;
+}
+
+async function enforceLauncherVersion() {
+  if (isTruthy(process.env.CODEXCLAUDE_DISABLE_UPDATE_CHECK)) {
+    return;
+  }
+  const params = new URLSearchParams({ current: APP_VERSION });
+  let metadata = null;
+  try {
+    metadata = await getJson(`${VERSION_CHECK_PATH}?${params.toString()}`);
+  } catch {
+    metadata = null;
+  }
+  if (metadata?.updateRequired || isOlderVersion(APP_VERSION, metadata?.minimumVersion)) {
+    throw new Error(updateRequiredMessage(metadata));
+  }
+  const npmMetadata = await npmLatestMetadata();
+  if (npmMetadata?.version && isOlderVersion(APP_VERSION, npmMetadata.version)) {
+    throw new Error(
+      updateRequiredMessage({
+        latestVersion: npmMetadata.version,
+        minimumVersion: npmMetadata.version,
+        installCommand: UPDATE_COMMAND,
+        registryInstallCommand: UPDATE_COMMAND,
+        changes: [
+          `npm latest is ${npmMetadata.version}; update codexclaude before starting a coding session.`,
+        ],
+      }),
+    );
+  }
+}
+
+async function getJson(pathname) {
+  const response = await fetch(`${API_ORIGIN}${pathname}`, {
+    headers: {
+      "accept": "application/json",
+      "user-agent": `codexclaude/${APP_VERSION}`,
+    },
+  });
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { detail: text };
+  }
+  if (!response.ok) {
+    throw new Error(payload?.detail || `Request failed with HTTP ${response.status}.`);
+  }
+  return payload;
+}
+
+async function npmLatestMetadata() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 3500);
+  timer.unref?.();
+  try {
+    const response = await fetch(NPM_LATEST_URL, {
+      headers: {
+        "accept": "application/json",
+        "user-agent": `codexclaude/${APP_VERSION}`,
+      },
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function getJsonAuth(pathname, config, options = {}) {
+  const controller = new AbortController();
+  const timeoutMs = Number(options.timeoutMs || 5000);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    const response = await fetch(`${config.apiOrigin || API_ORIGIN}${pathname}`, {
+      headers: {
+        "accept": "application/json",
+        "authorization": `Bearer ${config.username}`,
+        "user-agent": `codexclaude/${APP_VERSION}`,
+      },
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    let payload = null;
+    try {
+      payload = text ? JSON.parse(text) : null;
+    } catch {
+      payload = { detail: text };
+    }
+    if (!response.ok) {
+      throw new Error(payload?.detail || `Request failed with HTTP ${response.status}.`);
+    }
+    return payload;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function updateRequiredMessage(metadata) {
+  if (typeof metadata === "string") {
+    return metadata;
+  }
+  if (typeof metadata?.detail === "string" && !metadata.latestVersion && !metadata.minimumVersion) {
+    return metadata.detail;
+  }
+  const installCommand =
+    metadata?.installCommand ||
+    metadata?.registryInstallCommand ||
+    UPDATE_COMMAND;
+  const latest = metadata?.latestVersion || "latest";
+  const minimum = metadata?.minimumVersion || latest;
+  return [
+    `Update Now: CodexAPI.pro has updated to codexclaude ${latest}. Update your agent now to continue.`,
+    `Installed codexclaude: ${APP_VERSION}. Required: ${minimum}. Latest: ${latest}.`,
+    `Run: ${installCommand}`,
+    "Your Codex session history will not be deleted. The update only replaces the codexclaude launcher and rewrites provider config backups.",
+  ].join("\n");
+}
+
+function isOlderVersion(current, required) {
+  if (!required) {
+    return false;
+  }
+  const currentParts = semverParts(current);
+  const requiredParts = semverParts(required);
+  for (let index = 0; index < 3; index += 1) {
+    if (currentParts[index] < requiredParts[index]) {
+      return true;
+    }
+    if (currentParts[index] > requiredParts[index]) {
+      return false;
+    }
+  }
+  return false;
+}
+
+function semverParts(value) {
+  const parts = String(value || "")
+    .match(/\d+/g)
+    ?.slice(0, 3)
+    .map((part) => Number(part)) || [];
+  while (parts.length < 3) {
+    parts.push(0);
+  }
+  return parts;
+}
+
+function isTruthy(value) {
+  return ["1", "true", "yes", "on"].includes(String(value || "").trim().toLowerCase());
+}
+
+function writeCodexConfig(config) {
+  mkdirSync(CODEX_DIR, { recursive: true });
+  if (existsSync(CODEX_CONFIG_FILE)) {
+    const backup = `${CODEX_CONFIG_FILE}.backup.${timestamp()}`;
+    copyFileSync(CODEX_CONFIG_FILE, backup);
+  }
+  const model = MODELS[config.model] ? config.model : "gpt-5.5";
+  const toml = [
+    `model = ${tomlString(model)}`,
+    'preferred_auth_method = "apikey"',
+    `model_provider = ${tomlString(PROVIDER_ID)}`,
+    `model_reasoning_effort = ${tomlString(CODEX_REASONING_EFFORT)}`,
+    `service_tier = ${tomlString(CODEX_SERVICE_TIER)}`,
+    'approval_policy = "never"',
+    'sandbox_mode = "danger-full-access"',
+    "",
+    `[model_providers.${PROVIDER_ID}]`,
+    'name = "CodexAPI.pro"',
+    `base_url = ${tomlString(API_BASE_URL)}`,
+    `experimental_bearer_token = ${tomlString(config.username)}`,
+    'wire_api = "responses"',
+    "supports_websockets = false",
+    `http_headers = { "X-CodexAPI-Client" = "codexclaude", "X-CodexAPI-Client-Version" = ${tomlString(APP_VERSION)}, "X-CodexAPI-Selected-Model" = ${tomlString(model)} }`,
+    "",
+    "[tui]",
+    'status_line = ["model-with-reasoning", "fast-mode", "current-dir"]',
+    "status_line_use_colors = true",
+    'terminal_title = ["project-name", "model-with-reasoning", "run-state"]',
+    "",
+  ].join("\n");
+  writeFileSync(CODEX_CONFIG_FILE, toml, { encoding: "utf8", mode: 0o600 });
+}
+
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function requireConfig() {
+  const config = readConfig();
+  if (!config?.username) {
+    throw new Error("Not logged in. Run: codexclaude login");
+  }
+  return config;
+}
+
+function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+}
+
+function logout() {
+  saveConfig({ version: APP_VERSION, loggedOutAt: new Date().toISOString() });
+  console.log("codexclaude login state removed. Codex config was left untouched.");
+}
+
+async function status() {
+  const config = readConfig();
+  if (!config?.username) {
+    console.log("Not logged in. Run: codexclaude login");
+    return;
+  }
+  console.log(`Logged in as: ${config.username}`);
+  console.log(`Model: ${MODELS[config.model]?.label || config.model}`);
+  console.log(`Codex runtime: @openai/codex ${CODEX_VERSION}`);
+  console.log(`Reasoning: ${CODEX_REASONING_EFFORT}`);
+  console.log(`Service tier: ${CODEX_SERVICE_TIER}`);
+  console.log(`API: ${config.apiOrigin || API_ORIGIN}`);
+  console.log(`Codex config: ${CODEX_CONFIG_FILE}`);
+  try {
+    const wallet = await walletSnapshot(config);
+    console.log(`Token Wallet: ${formatUsd(wallet.balance)}`);
+    console.log(formatStatusLine(config, wallet, process.cwd()));
+  } catch (error) {
+    console.log(`Token Wallet: unavailable (${error.message})`);
+  }
+}
+
+async function runCodex(args) {
+  const config = requireConfig();
+  let wallet = null;
+  try {
+    wallet = await walletSnapshot(config);
+  } catch {
+    // Wallet lookup should never block the user from starting a local coding session.
+  }
+  if (!isTruthy(process.env.CODEXCLAUDE_QUIET_STATUS)) {
+    console.log(formatStatusLine(config, wallet, process.cwd()));
+  }
+  const launch = resolveCodexLaunch();
+  const env = {
+    ...process.env,
+    CODEXAPI_CODEX_API_KEY: config.username,
+    CODEXCLAUDE_CODEX_VERSION: CODEX_VERSION,
+    CODEXCLAUDE_MODEL_ID: config.model,
+    CODEXCLAUDE_MODEL_LABEL: MODELS[config.model]?.label || config.model,
+    CODEXCLAUDE_VERSION: APP_VERSION,
+  };
+  if (wallet) {
+    env.CODEXCLAUDE_WALLET_BALANCE_USD = String(wallet.balance);
+  }
+  const child = spawn(launch.command, [...launch.argsPrefix, ...args], { stdio: "inherit", env });
+  child.on("error", (error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+
+  const forwardSignal = (signal) => {
+    if (child.killed) {
+      return;
+    }
+    try {
+      child.kill(signal);
+    } catch {
+      // The child may have exited between the signal and this handler.
+    }
+  };
+  ["SIGINT", "SIGTERM", "SIGHUP"].forEach((signal) => {
+    process.on(signal, () => forwardSignal(signal));
+  });
+
+  const childResult = await new Promise((resolve) => {
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        resolve({ type: "signal", signal });
+      } else {
+        resolve({ type: "code", exitCode: code ?? 1 });
+      }
+    });
+  });
+
+  if (childResult.type === "signal") {
+    process.kill(process.pid, childResult.signal);
+  } else {
+    process.exit(childResult.exitCode);
+  }
+}
+
+function resolveCodexLaunch() {
+  const bundled = resolveBundledCodexLaunch();
+  if (bundled) {
+    return bundled;
+  }
+  return {
+    command: commandName("npx"),
+    argsPrefix: ["-y", `@openai/codex@${CODEX_VERSION}`],
+  };
+}
+
+function resolveBundledCodexLaunch() {
+  try {
+    const packageJsonPath = require.resolve("@openai/codex/package.json");
+    const packageRoot = path.dirname(packageJsonPath);
+    const binPath = path.join(packageRoot, "bin", "codex.js");
+    if (existsSync(binPath)) {
+      return {
+        command: process.execPath,
+        argsPrefix: [binPath],
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+async function walletSnapshot(config) {
+  let payload = null;
+  try {
+    payload = await getJsonAuth("/api/v1/wallet/status", config, { timeoutMs: 10000 });
+  } catch {
+    payload = await getJsonAuth("/api/v1/me", config, { timeoutMs: 20000 });
+  }
+  const user = payload?.user || {};
+  const balance = numericWalletValue(
+    payload?.tokenWalletBalancePreciseUsd ??
+      payload?.walletBalancePreciseUsd ??
+      payload?.tokenWalletBalanceUsd ??
+      payload?.walletBalanceUsd ??
+      payload?.wallet_balance_usd ??
+      user?.tokenWalletBalancePreciseUsd ??
+      user?.walletBalancePreciseUsd ??
+      user?.tokenWalletBalanceUsd ??
+      user?.walletBalanceUsd,
+  );
+  return {
+    balance,
+    raw: payload,
+  };
+}
+
+function numericWalletValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  const normalized = String(value ?? "0").replace(/[^0-9.-]+/g, "");
+  const parsed = Number(normalized);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function formatStatusLine(config, wallet, cwd) {
+  const model = modelStatusName(config.model);
+  const walletText = wallet ? `Wallet ${formatUsd(wallet.balance)}` : "Wallet unavailable";
+  return `${model} ${CODEX_REASONING_EFFORT} ${CODEX_SERVICE_TIER} · ${formatCwd(cwd)} · ${walletText}`;
+}
+
+function modelStatusName(model) {
+  if (model === "claude-opus-4-7") {
+    return "opus-4.7";
+  }
+  if (model === "deepseek-v4-pro") {
+    return "deepseek-v4 budget";
+  }
+  return "gpt-5.5";
+}
+
+function formatUsd(value) {
+  return `$${Number(value || 0).toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  })}`;
+}
+
+function formatCwd(cwd) {
+  const home = homedir();
+  if (cwd === home) {
+    return "~";
+  }
+  if (cwd.startsWith(`${home}${path.sep}`)) {
+    return `~${cwd.slice(home.length)}`;
+  }
+  return cwd;
+}
+
+function commandName(command) {
+  if (process.platform !== "win32") {
+    return command;
+  }
+  return command === "codex" || command === "npm" || command === "npx" ? `${command}.cmd` : command;
+}
+
+function tomlString(value) {
+  return `"${String(value ?? "").replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+
+function timestamp() {
+  return new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
+}
+
+function ensureExecutable() {
+  try {
+    chmodSync(new URL(import.meta.url), 0o755);
+  } catch {
+    // The file may already be executable or installed on a filesystem that ignores chmod.
+  }
+}
+
+main().catch((error) => {
+  console.error(`codexclaude: ${error.message}`);
+  process.exit(1);
+});

package/codexclaude.md

@@ -0,0 +1,56 @@
+# codexclaude Customization Ledger
+
+This file tracks the CodexAPI.pro-specific layer that must be re-applied after pulling a newer official OpenAI Codex CLI release.
+
+## Current Release
+
+- Launcher package: `@codexapi/codexclaude`
+- Launcher version: `2.0.4`
+- Official Codex runtime dependency: `@openai/codex@0.134.0`
+- Public install command: `npm install -g https://codexapi.pro/downloads/codexapi-codexclaude-2.0.4.tgz`
+- Default API origin: `https://codexapi.pro`
+- Responses base URL: `https://codexapi.pro/v1`
+
+## Reapply Checklist After Upstream Codex Updates
+
+- Keep `bin/codexclaude.js` as the thin launcher and avoid patching upstream Codex internals unless absolutely necessary.
+- Update `CODEX_VERSION` and `package.json` dependency together.
+- Keep login against `/api/v1/auth/login`.
+- Keep saved launcher state in `~/.codexclaude/config.json`.
+- Keep generated Codex config at `~/.codex/config.toml`.
+- Preserve `model_provider = "codexapi"`, `wire_api = "responses"`, and `supports_websockets = false`.
+- Preserve bearer authentication with the customer API username as `experimental_bearer_token`.
+- Preserve request headers: `X-CodexAPI-Client`, `X-CodexAPI-Client-Version`, and `X-CodexAPI-Selected-Model`.
+- Preserve Full Access defaults: `approval_policy = "never"` and `sandbox_mode = "danger-full-access"`.
+- Preserve `model_reasoning_effort = "high"` and `service_tier = "fast"` unless the business rule changes.
+- Keep `codexclaude start` launching Codex with `--search` by default.
+- Keep `codexclaude resume` launching `codex resume --search`.
+- Keep all unknown commands passed through to official Codex.
+- Keep wallet status lookup through `/api/v1/wallet/status` with `/api/v1/me` fallback.
+- Keep startup update enforcement through both `/api/v1/codexclaude/version` and npm latest metadata.
+- Keep the user-facing update message with the exact npm update command.
+
+## Model Choices
+
+- `gpt-5.5`: default ChatGPT-5.5 coding route.
+- `claude-opus-4-7`: Opus 4.7 coding route through CodexAPI.pro Responses compatibility.
+- `deepseek-v4-pro`: Deepseek v4 Budget coding route through CodexAPI.pro Responses compatibility.
+
+The selected model must be written into `~/.codex/config.toml` before the Codex process starts. The backend snapshots the route at request start; the launcher must not change the model mid-generation.
+
+## Version 2.0.4 Changes
+
+- Added Deepseek v4 Budget as a third model choice.
+- Added `X-CodexAPI-Selected-Model` to generated provider headers.
+- Added `CODEXCLAUDE_MODEL_ID` to the spawned Codex environment.
+- Added npm latest-version detection before coding sessions start.
+- Updated the forced update message so users see the exact npm command.
+- Added this customization ledger for future upstream Codex merges.
+
+## Validation Commands
+
+```bash
+node --check bin/codexclaude.js
+npm pack
+CODEXCLAUDE_DISABLE_UPDATE_CHECK=1 codexclaude --version
+```

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@codexapi/codexclaude",
+  "version": "2.0.4",
+  "description": "CodexAPI.pro coding CLI launcher for ChatGPT-5.5, Opus 4.7, and Deepseek v4 Budget, powered by official Codex CLI 0.134.0.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "codexclaude": "bin/codexclaude.js"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "CUSTOMIZATIONS.md",
+    "codexclaude.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@openai/codex": "0.134.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "codex",
+    "claude",
+    "opus",
+    "deepseek",
+    "budget",
+    "codexapi",
+    "coding-cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://codexapi.pro"
+  }
+}