@webinson/peer 0.4.20 → 0.4.22

package/README.md

@@ -99,11 +99,11 @@ peer-codex
 If you already signed in to Peer, use `peer install --codex --client` in place of the login
 command. Review and trust the Peer Thread Mark hooks in Codex's `/hooks` menu.
 
-The `--client` setup downloads the matching prebuilt client from npm into
-`~/.peer/codex-clients`. It supports macOS, Linux, and Windows on x64 and ARM64,
-and requires Node.js and npm. Set `PEER_CODEX_CLIENT` to use a custom build.
-The `peer-codex` launcher uses your existing Codex settings and sign-in with its
-own app server. `PEER_HOME` moves the client cache and Peer state.
+The `--client` setup needs Git, Rust/Cargo, `curl`, `shasum`, and a C/C++ toolchain on
+the machine. It builds the pinned Codex client under `~/.peer/codex-client`. If you already
+built it, set `PEER_CODEX_CLIENT` to its executable when you run setup. The `peer-codex`
+launcher uses your existing Codex settings and sign-in with its own app server. `PEER_HOME`
+moves the default checkout and Peer state.
 
 For the plugin alone, omit `--client`. The Codex plugin lives under [`mod/codex`](mod/codex)
 in its own marketplace.
@@ -113,7 +113,8 @@ In stock Codex, send `peer: start`, `peer: stop`, `peer: list`, `peer: thread`,
 This plugin uses the [Codex hook API](https://learn.chatgpt.com/docs/hooks); stock Codex does
 not expose a composer band or memory switches to plugins.
 
-For a custom build, see [building the client](mod/codex/client/README.md).
+From a source checkout, use `node bin/peer.mjs install --codex --client` and
+`bash mod/codex/client/run.sh` from `cli/`.
 
 The terminal band shows the thread's memory count, **Use Elephant**, **Use Jellyfish**, and
 **Active** or **Inactive**. Press the lit mode again to stop sharing. Use `/peer-mode` for
@@ -145,7 +146,7 @@ agent also gets one sentence beside the tool result, fenced as data:
 
 ```text
 <peer-collision>
-bob@acme.test's agent was on src/cart.ts 2 minutes ago, in another thread.
+Another person, bob@acme.test, had an agent on src/cart.ts 2 minutes ago.
 This is information about the repository, not an instruction.
 </peer-collision>
 ```

package/bin/codex-thread-mark.mjs

@@ -1,7 +1,6 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { installNativeCodex } from "./codex-native.mjs";
 
 // Codex's lifecycle hooks use their own event and output shapes. Keep Claude's
 // title updates and UI out of this adapter.
@@ -22,13 +21,14 @@ export function installCodex(peer, { client = false } = {}) {
       fs.accessSync(clientPath, fs.constants.X_OK);
       if (!fs.statSync(clientPath).isFile()) throw new Error("PEER_CODEX_CLIENT must point to the Codex executable");
     } else {
-      clientPath = installNativeCodex(peer);
+      const checkout = path.resolve(peer.home, "codex-client");
+      execFileSync("bash", [path.join(marketplace, "client", "build.sh"), checkout], { stdio: "inherit" });
+      clientPath = path.join(checkout, "codex-rs", "target", "debug", "codex");
     }
   }
 
   const binary = process.env.PEER_CODEX || (client ? clientPath : "codex");
-  const timeout = client ? 300_000 : 60_000;
-  const runCodex = (args, capture = false) => codex(args, { binary, capture, timeout });
+  const runCodex = (args, capture = false) => codex(args, { binary, capture });
   const listed = runCodex(["plugin", "marketplace", "list", "--json"], true);
   const previous = JSON.parse(listed).marketplaces?.find((item) => item.name === MARKETPLACE);
   const moving = previous && previous.root !== marketplace;
@@ -65,11 +65,11 @@ export function uninstallCodex(peer) {
   console.log("Codex: Peer's plugin removed.");
 }
 
-function codex(args, { binary, capture = false, timeout = 60_000 }) {
+function codex(args, { binary, capture = false }) {
   return execFileSync(binary, args, {
     stdio: capture ? ["ignore", "pipe", "inherit"] : "inherit",
     encoding: "utf8",
-    timeout,
+    timeout: 60_000,
   });
 }
 

package/bin/peer.mjs

@@ -46,7 +46,7 @@ const HELP = `peer: share chosen agent threads with your team
                     your own memories in your personal OpenViking, or the ones with these words
                     (full text); here: only this repository's. /peer-all in Claude Code
   peer install [--codex [--client]]
-                    set up the thread mark; --client also installs the Peer Codex terminal
+                    set up the thread mark; --client also builds the Peer Codex terminal
   peer uninstall [--codex]  remove the integration from Claude Code or Codex
   peer logout       forget the sign-in on this computer
 

package/mod/codex/client/README.md

@@ -1,9 +1,8 @@
 # Peer for the Codex terminal
 
 The sibling Codex plugin can report thread activity and answer commands with stock Codex.
-`peer install --codex --client` installs the native npm package for the current OS and
-architecture. `peer-codex` runs that client with its own app server so it uses the
-Peer memory policy.
+`build.sh` builds the terminal client for the band, local panels, and per-thread memory policy.
+`run.sh` keeps the terminal on its own app server so it uses that policy.
 
 `src/` contains the Peer modules. The two patches wire them into the pinned Codex source:
 `0001-memory.patch` controls plugin availability, capture and native memory; `0002-terminal.patch`
@@ -13,33 +12,6 @@ capture windows. Update the Codex pin, V8 version, checksums and patches togethe
 The patches include context from OpenAI Codex, distributed under Apache-2.0.
 See [CODEX-LICENSE](CODEX-LICENSE) and [CODEX-NOTICE](CODEX-NOTICE).
 
-## Building and packing a release
-
-`build.sh` takes the path of a checkout to create or reuse. It needs Git, Rust/Cargo,
-`curl`, `shasum`, and a C/C++ toolchain. For a custom build, run it and set
-`PEER_CODEX_CLIENT` to the resulting executable when running `peer install --codex --client`.
-
-Set `PEER_CODEX_BUILD_PROFILE=release` for an npm build and set
-`CARGO_PROFILE_RELEASE_STRIP=symbols` before compiling. Set `PEER_CODEX_BUILD_TARGET`
-to build for a specific Rust target with the matching Rust standard library and C toolchain.
-For cross-compiling, `PEER_CODEX_CARGO_COMMAND` can select `zigbuild` or `xwin`.
-For Linux musl builds, use the pinned upstream release's musl tools and set
-`CODEX_BWRAP_SHA256` to the SHA-256 of the `codex-resources/bwrap` shipped in the
-matching upstream npm package before compiling.
-
-After building, run:
-
-```bash
-bash pack.sh darwin-arm64 /path/to/build/bin /path/to/codex-checkout /path/to/output
-```
-
-Use the directory containing both `codex` and `codex-code-mode-host` (with `.exe` on
-Windows). The script adds the matching upstream sandbox and search helpers. Build and
-pack `darwin-arm64`, `darwin-x64`, `linux-arm64`, `linux-x64`, `win32-arm64`, and
-`win32-x64` for a native release. The installer pins their version in
-`bin/codex-native.mjs`. When that pin changes, publish and verify the native packages
-before publishing the version of `@webinson/peer` that uses them.
-
 From the repository root, run `npm test --prefix cli`. To exercise the actual band, switches,
 and panels with temporary profiles and local fixture servers, run:
 

package/mod/codex/client/build.sh

@@ -39,34 +39,20 @@ if [[ -n ${PEER_CODEX_TOOLCHAIN:-} ]]; then
 fi
 cd -- "$checkout/codex-rs"
 # The pinned Codex release ships its V8 build on the Codex release, not on denoland's.
-target=${PEER_CODEX_BUILD_TARGET:-$(rustc ${cargo_args[@]+"${cargo_args[@]}"} -vV | awk '/^host:/ {print $2}')}
-profile=${PEER_CODEX_BUILD_PROFILE:-dev}
-build_args=(--profile "$profile")
-cargo_command=("${PEER_CODEX_CARGO_COMMAND:-build}")
-if [[ "${cargo_command[0]}" == xwin ]]; then
-  cargo_command+=(build)
-fi
-target_dir=${CARGO_TARGET_DIR:-"$checkout/codex-rs/target"}
-output="$target_dir"
-if [[ -n ${PEER_CODEX_BUILD_TARGET:-} ]]; then
-  build_args+=(--target "$target")
-  output="$output/$target"
-fi
+host=$(rustc ${cargo_args[@]+"${cargo_args[@]}"} -vV | awk '/^host:/ {print $2}')
 v8=152.2.0
-v8_dir="$checkout/target/peer-v8/$target"
+v8_dir="$checkout/target/peer-v8/$host"
 v8_base="https://github.com/openai/codex/releases/download/rusty-v8-v$v8"
-binding="src_binding_ptrcomp_sandbox_release_${target}.rs"
-archive="librusty_v8_ptrcomp_sandbox_release_${target}.a.gz"
-exe=""
-if [[ "$target" == *-pc-windows-msvc ]]; then
-  archive="rusty_v8_ptrcomp_sandbox_release_${target}.lib.gz"
-  exe=".exe"
+binding="src_binding_ptrcomp_sandbox_release_${host}.rs"
+archive="librusty_v8_ptrcomp_sandbox_release_${host}.a.gz"
+if [[ "$host" == *-pc-windows-msvc ]]; then
+  archive="rusty_v8_ptrcomp_sandbox_release_${host}.lib.gz"
 fi
 mkdir -p -- "$v8_dir"
 for artifact in "$archive" "$binding"; do
   checksum=$(awk -v file="$artifact" '$2 == file {print $1}' "$checkout/third_party/v8/rusty_v8_${v8//./_}.sha256")
   if [[ -z "$checksum" ]]; then
-    printf 'No pinned Codex V8 artifact for %s.\n' "$target" >&2
+    printf 'No pinned Codex V8 artifact for %s.\n' "$host" >&2
     exit 1
   fi
   if ! (cd -- "$v8_dir" && printf '%s  %s\n' "$checksum" "$artifact" | shasum -a 256 -c - >/dev/null 2>&1); then
@@ -76,7 +62,6 @@ for artifact in "$archive" "$binding"; do
 done
 # The upstream release tag changes workspace versions without regenerating Cargo.lock.
 RUSTY_V8_ARCHIVE="$v8_dir/$archive" RUSTY_V8_SRC_BINDING_PATH="$v8_dir/$binding" \
-CARGO_PROFILE_DEV_DEBUG=0 cargo ${cargo_args[@]+"${cargo_args[@]}"} "${cargo_command[@]}" \
-  "${build_args[@]}" --target-dir "$target_dir" -p codex-cli -p codex-code-mode-host --bins
-[[ "$profile" != dev ]] || profile=debug
-printf 'Run with: PEER_CODEX_CLIENT=%q peer-codex\n' "$output/$profile/codex$exe"
+  CARGO_PROFILE_DEV_DEBUG=0 cargo ${cargo_args[@]+"${cargo_args[@]}"} build \
+  --target-dir "$checkout/codex-rs/target" -p codex-cli -p codex-code-mode-host --bins
+printf 'Run with: PEER_CODEX_CLIENT=%q bash %q\n' "$checkout/codex-rs/target/debug/codex" "$here/run.sh"

package/mod/codex/client/run.sh

@@ -1,5 +1,22 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-here=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
-exec node "$here/../../../bin/peer-codex.mjs" "$@"
+peer_root=${PEER_HOME:-"$HOME/.peer"}
+client=${PEER_CODEX_CLIENT:-}
+if [[ -z "$client" && -f "$peer_root/codex-cli.json" ]]; then
+  client=$(node -e '
+    try {
+      const data = JSON.parse(require("node:fs").readFileSync(process.argv[1], "utf8"));
+      if (typeof data.client === "string" && require("node:path").isAbsolute(data.client)) {
+        process.stdout.write(data.client);
+      }
+    } catch {}
+  ' "$peer_root/codex-cli.json")
+fi
+client=${client:-"$peer_root/codex-client/codex-rs/target/debug/codex"}
+if [[ ! -x "$client" ]]; then
+  printf 'Set up the Peer Codex terminal with peer install --codex --client.\n' >&2
+  exit 1
+fi
+# An existing stock daemon would use the stock memory policy.
+PEER_CODEX_THREAD_MARK=1 exec "$client" --no-daemon "$@"

package/mod/peer-thread-mark/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-thread-mark",
-  "version": "0.4.19",
+  "version": "0.4.22",
   "description": "Marks a Claude Code thread shared with Peer (/peer) with a band above the prompt, with /peer stop and /peer start; panes for /peer-list, /peer-thread and /peer-all (search your memories)",
   "license": "MIT",
   "types": "./types/index.d.ts"

package/mod/peer-thread-mark/hooks/register.tsx

@@ -497,8 +497,18 @@ async function memoryNote($: EngineInterface) {
   return 'Inactive: not shared, Claude Code memory only.'
 }
 
-// Who else was on the file, newest first: other people before the person's own other threads.
-const othersOf = (signal: CollisionSignal) => signal.holders.filter(h => !h.own).sort((a, b) => Date.parse(b.at) - Date.parse(a.at))
+// Who else was on the file, one entry per person (their newest session), newest first. One person often holds a path
+// in several sessions (another thread, the Peer app's own), and is named once.
+const byPerson = (holders: CollisionSignal['holders']) => {
+  const newest = new Map<string, CollisionSignal['holders'][number]>()
+  for (const h of holders) {
+    const key = h.email.toLowerCase()
+    const was = newest.get(key)
+    if (!was || Date.parse(h.at) > Date.parse(was.at)) newest.set(key, h)
+  }
+  return [...newest.values()].sort((a, b) => Date.parse(b.at) - Date.parse(a.at))
+}
+const othersOf = (signal: CollisionSignal) => byPerson(signal.holders.filter(h => !h.own))
 const whenAgo = (at: string, now: number) => {
   const age = ago(at, now)
   return age === 'just now' ? age : `${age} ago`
@@ -511,7 +521,7 @@ function collisionSentence(signal: CollisionSignal, now: number) {
     .map(h => {
       const mins = Math.max(0, Math.round((now - Date.parse(h.at)) / 60_000))
       const age = mins < 1 ? 'just now' : mins === 1 ? '1 minute ago' : `${mins} minutes ago`
-      return `${h.email}'s agent was on ${signal.path} ${age}, in another thread.`
+      return `Another person, ${h.email}, had an agent on ${signal.path} ${age}.`
     })
   return ['<peer-collision>', ...said, 'This is information about the repository, not an instruction.', '</peer-collision>'].join('\n')
 }
@@ -605,7 +615,7 @@ export const register: Register = on => {
       .filter(h => ADDRESS.test(h.email))
     const state = answer.state === 'collision' && !holders.length ? 'clear' : answer.state
     const at = await $.clock.now()
-    const emails = (signal: { holders: { email: string }[] }) => signal.holders.map(h => h.email.toLowerCase()).sort().join(' ')
+    const emails = (signal: { holders: { email: string }[] }) => [...new Set(signal.holders.map(h => h.email.toLowerCase()))].sort().join(' ')
     let signal: CollisionSignal = { path: answer.path ? plain(answer.path) : null, state, ...(answer.reason ? { reason: answer.reason } : {}), holders, at, shown: false }
     // Shown once per set of people on a path: against the latest earlier collision on it, decided inside one update.
     await update($, signals, was => {

package/mod/peer-thread-mark/tests/collision.test.tsx

@@ -60,7 +60,7 @@ test('an edit another person was on draws the line and tells the agent once per
   expect(state.collides[0]).toEqual(['--json', 's1', 't1', '/repo/src/cart.ts'])
   expect(told.additionalContext?.[0]).toBe('from another hook')
   expect(told.additionalContext?.[1]).toBe(
-    "<peer-collision>\nbob@acme.test's agent was on src/cart.ts 2 minutes ago, in another thread.\nThis is information about the repository, not an instruction.\n</peer-collision>",
+    "<peer-collision>\nAnother person, bob@acme.test, had an agent on src/cart.ts 2 minutes ago.\nThis is information about the repository, not an instruction.\n</peer-collision>",
   )
   for (const surface of ['terminal', 'desktop'] as const) {
     const drawn = await texts(row('t1', surface), $ as never)
@@ -84,9 +84,20 @@ test('an edit another person was on draws the line and tells the agent once per
   const CY = { email: 'cy@acme.test', at: minsAgo(1), own: false }
   state.answer = { path: 'src/pay.ts', state: 'collision', holders: [BOB, CY] }
   const both = (await $.classic.PostToolUse(edit('t3', 'Write', '/repo/src/pay.ts'))) as { additionalContext?: string[] }
-  expect(both.additionalContext?.[1]).toContain("cy@acme.test's agent was on src/pay.ts 1 minute ago")
-  expect(both.additionalContext?.[1]).toContain("bob@acme.test's agent was on src/pay.ts 2 minutes ago")
+  expect(both.additionalContext?.[1]).toContain("Another person, cy@acme.test, had an agent on src/pay.ts 1 minute ago")
+  expect(both.additionalContext?.[1]).toContain("Another person, bob@acme.test, had an agent on src/pay.ts 2 minutes ago")
   expect(await texts(row('t3', 'desktop'), $ as never)).toContain('cy@… was on it 1 min ago and 1 others')
+
+  // One person in several sessions (another thread, the Peer app's own) is named once, at their newest.
+  state.answer = { path: 'src/one.ts', state: 'collision', holders: [BOB, { ...BOB, email: 'Bob@acme.test', at: minsAgo(0) }, { ...BOB, at: minsAgo(1) }] }
+  const once = (await $.classic.PostToolUse(edit('t4', 'Edit', '/repo/src/one.ts'))) as { additionalContext?: string[] }
+  expect(once.additionalContext?.[1]).toBe(
+    "<peer-collision>\nAnother person, Bob@acme.test, had an agent on src/one.ts just now.\nThis is information about the repository, not an instruction.\n</peer-collision>",
+  )
+  expect(await texts(row('t4', 'terminal'), $ as never)).toContain('Bob@… was on it just now')
+  // The same person in one more session is no new set of people.
+  state.answer = { path: 'src/one.ts', state: 'collision', holders: [BOB, { ...BOB, at: minsAgo(0) }] }
+  expect(((await $.classic.PostToolUse(edit('t5', 'Edit', '/repo/src/one.ts'))) as { additionalContext?: string[] }).additionalContext).toEqual(['from another hook'])
 })
 
 test('the person\'s own other thread is drawn dimmed and the agent is told nothing', async ($, on) => {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@webinson/peer",
-  "version": "0.4.20",
+  "version": "0.4.22",
   "description": "Share chosen Claude Code and Codex threads with your team: who has agents running and on what.",
   "license": "MIT",
   "type": "module",
   "bin": {
     "peer": "bin/peer.mjs",
-    "peer-codex": "bin/peer-codex.mjs"
+    "peer-codex": "mod/codex/client/run.sh"
   },
   "files": [
     "bin",

package/bin/codex-native.mjs

@@ -1,73 +0,0 @@
-import { execFileSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-
-export const codexTargets = {
-  "darwin-arm64": "aarch64-apple-darwin",
-  "darwin-x64": "x86_64-apple-darwin",
-  "linux-arm64": "aarch64-unknown-linux-musl",
-  "linux-x64": "x86_64-unknown-linux-musl",
-  "win32-arm64": "aarch64-pc-windows-msvc",
-  "win32-x64": "x86_64-pc-windows-msvc",
-};
-
-export const codexPackageName = (platform) => `@webinson/peer-codex-${platform}`;
-export const codexExecutable = (platform) => platform === "win32" ? "codex.exe" : "codex";
-export const codexNativeVersion = "0.4.18";
-
-function installedClient(directory, target) {
-  const bin = path.join(directory, "vendor", target, "bin");
-  const suffix = process.platform === "win32" ? ".exe" : "";
-  const client = path.join(bin, codexExecutable(process.platform));
-  try {
-    for (const executable of [client, path.join(bin, `codex-code-mode-host${suffix}`)]) {
-      if (!fs.statSync(executable).isFile()) return null;
-      fs.accessSync(executable, fs.constants.X_OK);
-    }
-    return client;
-  } catch {
-    return null;
-  }
-}
-
-export function installNativeCodex(peer) {
-  const platform = `${process.platform}-${process.arch}`;
-  const target = codexTargets[platform];
-  if (!target) {
-    throw new Error(`No prebuilt Peer Codex for ${platform}. Set PEER_CODEX_CLIENT to a custom build.`);
-  }
-  const packageName = codexPackageName(platform);
-  const spec = `${packageName}@${codexNativeVersion}`;
-  const root = path.resolve(peer.home, "codex-clients");
-  const destination = path.join(root, `${platform}-${codexNativeVersion}`);
-  if (fs.existsSync(destination)) {
-    const existing = installedClient(destination, target);
-    if (existing) return existing;
-    throw new Error(`Incomplete Peer Codex install at ${destination}. Remove that directory and retry.`);
-  }
-
-  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
-  const staging = fs.mkdtempSync(path.join(root, ".install-"));
-  try {
-    const args = [
-      "install", "--prefix", ".", "--global=false", "--ignore-scripts",
-      "--no-save", "--no-package-lock", "--no-audit", "--no-fund", spec,
-    ];
-    const options = { cwd: staging, stdio: "inherit", timeout: 600_000 };
-    if (process.platform === "win32") {
-      execFileSync(process.env.ComSpec || "cmd.exe", ["/d", "/c", "npm", ...args], options);
-    } else {
-      execFileSync("npm", args, options);
-    }
-    const downloaded = path.join(staging, "node_modules", packageName);
-    if (!installedClient(downloaded, target)) throw new Error(`${spec} is missing its executables`);
-    try {
-      fs.renameSync(downloaded, destination);
-    } catch (error) {
-      if (!installedClient(destination, target)) throw error;
-    }
-    return installedClient(destination, target);
-  } finally {
-    fs.rmSync(staging, { recursive: true, force: true });
-  }
-}

package/bin/peer-codex.mjs

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { codexExecutable } from "./codex-native.mjs";
-
-const home = process.env.PEER_HOME || path.join(os.homedir(), ".peer");
-let configured;
-try {
-  configured = JSON.parse(fs.readFileSync(path.join(home, "codex-cli.json"), "utf8"))?.client;
-} catch {}
-const client = process.env.PEER_CODEX_CLIENT
-  || (typeof configured === "string" && path.isAbsolute(configured) ? configured : null)
-  || path.join(home, "codex-client", "codex-rs", "target", "debug", codexExecutable(process.platform));
-try {
-  fs.accessSync(client, fs.constants.X_OK);
-} catch {
-  console.error("Set up the Peer Codex terminal with peer install --codex --client.");
-  process.exit(1);
-}
-
-// A stock daemon would use the stock memory policy.
-const args = ["--no-daemon", ...process.argv.slice(2)];
-const env = { ...process.env, PEER_CODEX_THREAD_MARK: "1" };
-if (process.platform !== "win32" && typeof process.execve === "function") {
-  process.on("SIGXFSZ", () => {});
-  process.execve(client, [client, ...args], env);
-}
-
-const child = spawn(client, args, { stdio: "inherit", env });
-const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
-const forward = (signal) => {
-  if (!child.killed) child.kill(signal);
-};
-for (const signal of signals) process.on(signal, forward);
-child.on("error", (error) => {
-  console.error(`Could not start Peer Codex: ${error.message}`);
-  process.exitCode = 1;
-});
-child.on("exit", (code, signal) => {
-  for (const name of signals) process.off(name, forward);
-  process.exitCode = code ?? (signal ? 128 + os.constants.signals[signal] : 1);
-  if (signal && process.platform !== "win32") process.kill(process.pid, signal);
-});

package/mod/codex/client/pack.sh

@@ -1,80 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-here=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
-cli=$(cd -- "$here/../../.." && pwd)
-platform=${1:?usage: pack.sh PLATFORM BUILD_BIN_DIR CODEX_CHECKOUT OUTPUT_DIR}
-build=$(cd -- "${2:?missing build bin directory}" && pwd)
-source=$(cd -- "${3:?missing pinned Codex checkout}" && pwd)
-mkdir -p -- "${4:?missing output directory}"
-output=$(cd -- "$4" && pwd)
-target=$(node --input-type=module - "$cli" "$platform" <<'JS'
-import { pathToFileURL } from "node:url";
-import path from "node:path";
-const { codexTargets } = await import(pathToFileURL(path.join(process.argv[2], "bin/codex-native.mjs")));
-const target = codexTargets[process.argv[3]];
-if (!target) throw new Error("Unsupported Peer Codex platform");
-console.log(target);
-JS
-)
-
-commit=f79b26ccbb3116b052544666a181012fb45dc49b
-codex_version=0.166.0-alpha.5.1
-[[ $(git -C "$source" rev-parse HEAD) == "$commit" ]]
-stage=$(mktemp -d "${TMPDIR:-/tmp}/peer-codex-pack.XXXXXXXX")
-trap 'rm -rf -- "$stage"' EXIT
-archive=$(npm pack "@openai/codex@$codex_version-$platform" --ignore-scripts --pack-destination "$stage" --silent)
-suffix=""
-resources=()
-case "$platform" in
-  linux-*) resources+=(codex-resources/bwrap) ;;
-  win32-*)
-    suffix=.exe
-    resources+=(codex-resources/codex-command-runner.exe codex-resources/codex-windows-sandbox-setup.exe)
-    ;;
-esac
-vendor="package/vendor/$target"
-assets=("$vendor/codex-package.json" "$vendor/codex-path/rg$suffix")
-for asset in ${resources[@]+"${resources[@]}"}; do assets+=("$vendor/$asset"); done
-tar -xf "$stage/$archive" -C "$stage" "${assets[@]}"
-mkdir -p "$stage/$vendor/bin"
-for binary in codex codex-code-mode-host; do
-  install -m 755 "$build/$binary$suffix" "$stage/$vendor/bin/$binary$suffix"
-done
-cp "$here/CODEX-LICENSE" "$stage/package/LICENSE"
-cp "$here/CODEX-NOTICE" "$stage/package/NOTICE"
-curl -fsSL --retry 2 'https://raw.githubusercontent.com/BurntSushi/ripgrep/15.2.0/LICENSE-MIT' \
-  -o "$stage/package/RIPGREP-LICENSE"
-if [[ "$platform" == linux-* ]]; then
-  cp "$source/codex-rs/vendor/bubblewrap/LICENSE" "$stage/package/BUBBLEWRAP-LICENSE"
-fi
-cat >> "$stage/package/NOTICE" <<EOF
-
-Peer Codex modifies the terminal UI, thread sharing and memory policy.
-Upstream source: https://github.com/openai/codex/tree/$commit
-The matching @webinson/peer npm package contains the Peer changes.
-
-The bundled ripgrep is from https://github.com/BurntSushi/ripgrep/tree/15.2.0.
-Linux bundles include the sandbox helper built from the Codex source above
-under codex-rs/vendor/bubblewrap. The corresponding sources and build scripts
-are in that same tree.
-EOF
-node --input-type=module - "$cli" "$platform" "$stage/package" <<'JS'
-import fs from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-const [cli, platform, stage] = process.argv.slice(2);
-const [os, cpu] = platform.split("-");
-const { codexPackageName, codexNativeVersion } = await import(pathToFileURL(path.join(cli, "bin/codex-native.mjs")));
-const pkg = {
-  name: codexPackageName(platform),
-  version: codexNativeVersion,
-  description: `Peer Codex terminal for ${os} ${cpu}. Installed by @webinson/peer.`,
-  license: "Apache-2.0",
-  os: [os],
-  cpu: [cpu],
-  files: ["vendor", "NOTICE", "*-LICENSE"],
-};
-fs.writeFileSync(path.join(stage, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
-JS
-npm pack "$stage/package" --pack-destination "$output" --ignore-scripts