@webinson/peer 0.4.18 → 0.4.20

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 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.
+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.
 
 For the plugin alone, omit `--client`. The Codex plugin lives under [`mod/codex`](mod/codex)
 in its own marketplace.
@@ -113,8 +113,7 @@ 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.
 
-From a source checkout, use `node bin/peer.mjs install --codex --client` and
-`bash mod/codex/client/run.sh` from `cli/`.
+For a custom build, see [building the client](mod/codex/client/README.md).
 
 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

package/bin/codex-native.mjs

@@ -0,0 +1,73 @@
+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/codex-thread-mark.mjs

@@ -1,6 +1,7 @@
 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.
@@ -21,14 +22,13 @@ 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 {
-      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");
+      clientPath = installNativeCodex(peer);
     }
   }
 
   const binary = process.env.PEER_CODEX || (client ? clientPath : "codex");
-  const runCodex = (args, capture = false) => codex(args, { binary, capture });
+  const timeout = client ? 300_000 : 60_000;
+  const runCodex = (args, capture = false) => codex(args, { binary, capture, timeout });
   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 }) {
+function codex(args, { binary, capture = false, timeout = 60_000 }) {
   return execFileSync(binary, args, {
     stdio: capture ? ["ignore", "pipe", "inherit"] : "inherit",
     encoding: "utf8",
-    timeout: 60_000,
+    timeout,
   });
 }
 

package/bin/peer-codex.mjs

@@ -0,0 +1,45 @@
+#!/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/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 builds the Peer Codex terminal
+                    set up the thread mark; --client also installs the Peer Codex terminal
   peer uninstall [--codex]  remove the integration from Claude Code or Codex
   peer logout       forget the sign-in on this computer
 
@@ -450,6 +450,12 @@ function installMark() {
       } catch {}
       install();
     }
+    // `plugin install` leaves an installed version alone, so an upgrade of this package re-reads its marketplace and
+    // moves the mark to the version it ships.
+    try {
+      claudeCli(["plugin", "marketplace", "update", MARKETPLACE]);
+      claudeCli(["plugin", "update", `${MOD}@${MARKETPLACE}`]);
+    } catch {}
     console.log(`Claude Code: the thread mark (${MOD}), a band above the prompt in shared threads, from ${MOD_DIR}.`);
   } catch (error) {
     const reason = String(error.stderr || error.message).trim().split("\n").pop();

package/mod/codex/client/README.md

@@ -1,8 +1,9 @@
 # Peer for the Codex terminal
 
 The sibling Codex plugin can report thread activity and answer commands with stock Codex.
-`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.
+`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.
 
 `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`
@@ -12,6 +13,33 @@ 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,20 +39,34 @@ 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.
-host=$(rustc ${cargo_args[@]+"${cargo_args[@]}"} -vV | awk '/^host:/ {print $2}')
+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
 v8=152.2.0
-v8_dir="$checkout/target/peer-v8/$host"
+v8_dir="$checkout/target/peer-v8/$target"
 v8_base="https://github.com/openai/codex/releases/download/rusty-v8-v$v8"
-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"
+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"
 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' "$host" >&2
+    printf 'No pinned Codex V8 artifact for %s.\n' "$target" >&2
     exit 1
   fi
   if ! (cd -- "$v8_dir" && printf '%s  %s\n' "$checksum" "$artifact" | shasum -a 256 -c - >/dev/null 2>&1); then
@@ -62,6 +76,7 @@ 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[@]}"} 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"
+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"

package/mod/codex/client/pack.sh

@@ -0,0 +1,80 @@
+#!/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

package/mod/codex/client/run.sh

@@ -1,22 +1,5 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-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 "$@"
+here=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+exec node "$here/../../../bin/peer-codex.mjs" "$@"

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

@@ -1,6 +1,6 @@
 {
   "name": "peer-thread-mark",
-  "version": "0.4.18",
+  "version": "0.4.19",
   "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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@webinson/peer",
-  "version": "0.4.18",
+  "version": "0.4.20",
   "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": "mod/codex/client/run.sh"
+    "peer-codex": "bin/peer-codex.mjs"
   },
   "files": [
     "bin",