@codexed/codex 0.121.0-codexed.3 → 0.121.0-codexed.5

package/README.md

@@ -1 +1,60 @@
-Patched Codex CLI with persistent retry behavior.
+<p align="center"><code>npm i -g @openai/codex</code><br />or <code>brew install --cask codex</code></p>
+<p align="center"><strong>Codex CLI</strong> is a coding agent from OpenAI that runs locally on your computer.
+<p align="center">
+  <img src="https://github.com/openai/codex/blob/main/.github/codex-cli-splash.png" alt="Codex CLI splash" width="80%" />
+</p>
+</br>
+If you want Codex in your code editor (VS Code, Cursor, Windsurf), <a href="https://developers.openai.com/codex/ide">install in your IDE.</a>
+</br>If you want the desktop app experience, run <code>codex app</code> or visit <a href="https://chatgpt.com/codex?app-landing-page=true">the Codex App page</a>.
+</br>If you are looking for the <em>cloud-based agent</em> from OpenAI, <strong>Codex Web</strong>, go to <a href="https://chatgpt.com/codex">chatgpt.com/codex</a>.</p>
+
+---
+
+## Quickstart
+
+### Installing and running Codex CLI
+
+Install globally with your preferred package manager:
+
+```shell
+# Install using npm
+npm install -g @openai/codex
+```
+
+```shell
+# Install using Homebrew
+brew install --cask codex
+```
+
+Then simply run `codex` to get started.
+
+<details>
+<summary>You can also go to the <a href="https://github.com/openai/codex/releases/latest">latest GitHub Release</a> and download the appropriate binary for your platform.</summary>
+
+Each GitHub Release contains many executables, but in practice, you likely want one of these:
+
+- macOS
+  - Apple Silicon/arm64: `codex-aarch64-apple-darwin.tar.gz`
+  - x86_64 (older Mac hardware): `codex-x86_64-apple-darwin.tar.gz`
+- Linux
+  - x86_64: `codex-x86_64-unknown-linux-musl.tar.gz`
+  - arm64: `codex-aarch64-unknown-linux-musl.tar.gz`
+
+Each archive contains a single entry with the platform baked into the name (e.g., `codex-x86_64-unknown-linux-musl`), so you likely want to rename it to `codex` after extracting it.
+
+</details>
+
+### Using Codex with your ChatGPT plan
+
+Run `codex` and select **Sign in with ChatGPT**. We recommend signing into your ChatGPT account to use Codex as part of your Plus, Pro, Business, Edu, or Enterprise plan. [Learn more about what's included in your ChatGPT plan](https://help.openai.com/en/articles/11369540-codex-in-chatgpt).
+
+You can also use Codex with an API key, but this requires [additional setup](https://developers.openai.com/codex/auth#sign-in-with-an-api-key).
+
+## Docs
+
+- [**Codex Documentation**](https://developers.openai.com/codex)
+- [**Contributing**](./docs/contributing.md)
+- [**Installing & building**](./docs/install.md)
+- [**Open source fund**](./docs/open-source-fund.md)
+
+This repository is licensed under the [Apache-2.0 License](LICENSE).

package/bin/codex.js

@@ -1,28 +1,35 @@
 #!/usr/bin/env node
+// Unified entry point for the Codex CLI.
 
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync } from "fs";
 import { createRequire } from "node:module";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import path from "path";
+import { fileURLToPath } from "url";
 
+// __dirname equivalent in ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const require = createRequire(import.meta.url);
 
 const PLATFORM_PACKAGE_BY_TARGET = {
-  "x86_64-unknown-linux-musl": "@codexed/codex-linux-x64",
+  "x86_64-unknown-linux-gnu": "@codexed/codex-linux-x64",
   "aarch64-unknown-linux-musl": "@codexed/codex-linux-arm64",
+  "x86_64-apple-darwin": "@codexed/codex-darwin-x64",
+  "aarch64-apple-darwin": "@codexed/codex-darwin-arm64",
   "x86_64-pc-windows-msvc": "@codexed/codex-win32-x64",
+  "aarch64-pc-windows-msvc": "@codexed/codex-win32-arm64",
 };
 
+const { platform, arch } = process;
+
 let targetTriple = null;
-switch (process.platform) {
+switch (platform) {
   case "linux":
   case "android":
-    switch (process.arch) {
+    switch (arch) {
       case "x64":
-        targetTriple = "x86_64-unknown-linux-musl";
+        targetTriple = "x86_64-unknown-linux-gnu";
         break;
       case "arm64":
         targetTriple = "aarch64-unknown-linux-musl";
@@ -31,9 +38,28 @@ switch (process.platform) {
         break;
     }
     break;
+  case "darwin":
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-apple-darwin";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-apple-darwin";
+        break;
+      default:
+        break;
+    }
+    break;
   case "win32":
-    if (process.arch === "x64") {
-      targetTriple = "x86_64-pc-windows-msvc";
+    switch (arch) {
+      case "x64":
+        targetTriple = "x86_64-pc-windows-msvc";
+        break;
+      case "arm64":
+        targetTriple = "aarch64-pc-windows-msvc";
+        break;
+      default:
+        break;
     }
     break;
   default:
@@ -41,21 +67,48 @@ switch (process.platform) {
 }
 
 if (!targetTriple) {
-  throw new Error(
-    `Unsupported platform: ${process.platform} (${process.arch}). ` +
-      "Supported targets are linux/x64, linux/arm64, and win32/x64.",
-  );
+  throw new Error(`Unsupported platform: ${platform} (${arch})`);
 }
 
 const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
+if (!platformPackage) {
+  throw new Error(`Unsupported target triple: ${targetTriple}`);
+}
+
 const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
+const localVendorRoot = path.join(__dirname, "..", "vendor");
+const localBinaryPath = path.join(
+  localVendorRoot,
+  targetTriple,
+  "codex",
+  codexBinaryName,
+);
 
 let vendorRoot;
 try {
   const packageJsonPath = require.resolve(`${platformPackage}/package.json`);
   vendorRoot = path.join(path.dirname(packageJsonPath), "vendor");
 } catch {
-  const updateCommand = "npm install -g @codexed/codex@latest";
+  if (existsSync(localBinaryPath)) {
+    vendorRoot = localVendorRoot;
+  } else {
+    const packageManager = detectPackageManager();
+    const updateCommand =
+      packageManager === "bun"
+        ? "bun install -g @codexed/codex@latest"
+        : "npm install -g @codexed/codex@latest";
+    throw new Error(
+      `Missing optional dependency ${platformPackage}. Reinstall Codex: ${updateCommand}`,
+    );
+  }
+}
+
+if (!vendorRoot) {
+  const packageManager = detectPackageManager();
+  const updateCommand =
+    packageManager === "bun"
+      ? "bun install -g @codexed/codex@latest"
+      : "npm install -g @codexed/codex@latest";
   throw new Error(
     `Missing optional dependency ${platformPackage}. Reinstall Codex: ${updateCommand}`,
   );
@@ -63,17 +116,61 @@ try {
 
 const archRoot = path.join(vendorRoot, targetTriple);
 const binaryPath = path.join(archRoot, "codex", codexBinaryName);
-if (!existsSync(binaryPath)) {
-  throw new Error(`Missing Codex binary at ${binaryPath}`);
+
+// Use an asynchronous spawn instead of spawnSync so that Node is able to
+// respond to signals (e.g. Ctrl-C / SIGINT) while the native binary is
+// executing. This allows us to forward those signals to the child process
+// and guarantees that when either the child terminates or the parent
+// receives a fatal signal, both processes exit in a predictable manner.
+
+function getUpdatedPath(newDirs) {
+  const pathSep = process.platform === "win32" ? ";" : ":";
+  const existingPath = process.env.PATH || "";
+  const updatedPath = [
+    ...newDirs,
+    ...existingPath.split(pathSep).filter(Boolean),
+  ].join(pathSep);
+  return updatedPath;
+}
+
+/**
+ * Use heuristics to detect the package manager that was used to install Codex
+ * in order to give the user a hint about how to update it.
+ */
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (/\bbun\//.test(userAgent)) {
+    return "bun";
+  }
+
+  const execPath = process.env.npm_execpath || "";
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+
+  if (
+    __dirname.includes(".bun/install/global") ||
+    __dirname.includes(".bun\\install\\global")
+  ) {
+    return "bun";
+  }
+
+  return userAgent ? "npm" : null;
 }
 
+const additionalDirs = [];
 const pathDir = path.join(archRoot, "path");
-const pathSep = process.platform === "win32" ? ";" : ":";
-const env = {
-  ...process.env,
-  PATH: [pathDir, process.env.PATH || ""].filter(Boolean).join(pathSep),
-  CODEX_MANAGED_BY_NPM: "1",
-};
+if (existsSync(pathDir)) {
+  additionalDirs.push(pathDir);
+}
+const updatedPath = getUpdatedPath(additionalDirs);
+
+const env = { ...process.env, PATH: updatedPath };
+const packageManagerEnvVar =
+  detectPackageManager() === "bun"
+    ? "CODEX_MANAGED_BY_BUN"
+    : "CODEX_MANAGED_BY_NPM";
+env[packageManagerEnvVar] = "1";
 
 const child = spawn(binaryPath, process.argv.slice(2), {
   stdio: "inherit",
@@ -81,17 +178,26 @@ const child = spawn(binaryPath, process.argv.slice(2), {
 });
 
 child.on("error", (err) => {
+  // Typically triggered when the binary is missing or not executable.
+  // Re-throwing here will terminate the parent with a non-zero exit code
+  // while still printing a helpful stack trace.
+  // eslint-disable-next-line no-console
   console.error(err);
   process.exit(1);
 });
 
+// Forward common termination signals to the child so that it shuts down
+// gracefully. In the handler we temporarily disable the default behavior of
+// exiting immediately; once the child has been signaled we simply wait for
+// its exit event which will in turn terminate the parent (see below).
 const forwardSignal = (signal) => {
-  if (!child.killed) {
-    try {
-      child.kill(signal);
-    } catch {
-      // Ignore child signal forwarding failures during teardown.
-    }
+  if (child.killed) {
+    return;
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    /* ignore */
   }
 };
 
@@ -99,6 +205,11 @@ const forwardSignal = (signal) => {
   process.on(sig, () => forwardSignal(sig));
 });
 
+// When the child exits, mirror its termination reason in the parent so that
+// shell scripts and other tooling observe the correct exit status.
+// Wrap the lifetime of the child process in a Promise so that we can await
+// its termination in a structured way. The Promise resolves with an object
+// describing how the child exited: either via exit code or due to a signal.
 const childResult = await new Promise((resolve) => {
   child.on("exit", (code, signal) => {
     if (signal) {
@@ -110,6 +221,8 @@ const childResult = await new Promise((resolve) => {
 });
 
 if (childResult.type === "signal") {
+  // Re-emit the same signal so that the parent terminates with the expected
+  // semantics (this also sets the correct exit code of 128 + n).
   process.kill(process.pid, childResult.signal);
 } else {
   process.exit(childResult.exitCode);

package/package.json

@@ -1,25 +1,28 @@
 {
   "name": "@codexed/codex",
-  "version": "0.121.0-codexed.3",
+  "version": "0.121.0-codexed.5",
   "license": "Apache-2.0",
-  "description": "Patched Codex CLI with persistent retry behavior.",
-  "bin": {
-    "codex": "bin/codex.js"
-  },
   "type": "module",
   "engines": {
     "node": ">=16"
   },
   "files": [
     "bin",
+    "scripts",
     "README.md"
   ],
-  "publishConfig": {
-    "access": "public"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openai/codex.git",
+    "directory": "codex-cli"
+  },
+  "packageManager": "pnpm@10.29.3+sha512.498e1fb4cca5aa06c1dcf2611e6fafc50972ffe7189998c409e90de74566444298ffe43e6cd2acdc775ba1aa7cc5e092a8b7054c811ba8c5770f84693d33d2dc",
+  "scripts": {
+    "postinstall": "node scripts/postinstall.mjs"
   },
   "optionalDependencies": {
-    "@codexed/codex-linux-x64": "0.121.0-codexed.3",
-    "@codexed/codex-linux-arm64": "0.121.0-codexed.3",
-    "@codexed/codex-win32-x64": "0.121.0-codexed.3"
+    "@codexed/codex-linux-x64": "0.121.0-codexed.4",
+    "@codexed/codex-linux-arm64": "0.121.0-codexed.4",
+    "@codexed/codex-win32-x64": "0.121.0-codexed.5"
   }
 }

package/scripts/postinstall.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+
+import { chmodSync, mkdirSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const codexJs = path.join(packageRoot, "bin", "codex.js");
+
+function isGlobalInstall() {
+  return (
+    process.env.npm_config_global === "true" ||
+    process.env.npm_config_location === "global"
+  );
+}
+
+function resolvePrefix() {
+  return process.env.npm_config_prefix || process.env.PREFIX || "/usr/local";
+}
+
+function replacePosixLauncher(prefix) {
+  const binDir = path.join(prefix, "bin");
+  const launcherPath = path.join(binDir, "codex");
+  const tmpPath = `${launcherPath}.codexed-tmp`;
+
+  mkdirSync(binDir, { recursive: true });
+  chmodSync(codexJs, 0o755);
+  rmSync(tmpPath, { force: true });
+  symlinkSync(codexJs, tmpPath);
+  rmSync(launcherPath, { force: true, recursive: true });
+  renameSync(tmpPath, launcherPath);
+}
+
+function replaceWindowsLauncher(prefix) {
+  const launcherDir = prefix;
+  const cmdPath = path.join(launcherDir, "codex.cmd");
+  const ps1Path = path.join(launcherDir, "codex.ps1");
+  const escapedCodexJs = codexJs.replace(/\\/g, "\\\\");
+
+  mkdirSync(launcherDir, { recursive: true });
+
+  writeFileSync(
+    cmdPath,
+    `@ECHO OFF\r\nnode "${escapedCodexJs}" %*\r\n`,
+    "utf8",
+  );
+  writeFileSync(
+    ps1Path,
+    `#!/usr/bin/env pwsh\nnode "${escapedCodexJs}" $args\n`,
+    "utf8",
+  );
+}
+
+if (!isGlobalInstall()) {
+  process.exit(0);
+}
+
+const prefix = resolvePrefix();
+
+if (os.platform() === "win32") {
+  replaceWindowsLauncher(prefix);
+} else {
+  replacePosixLauncher(prefix);
+}