cxstatusline 0.9.1 → 0.10.1

package/README.md

@@ -31,7 +31,7 @@
 - [🚀 Install](#-install)
 - [🎛️ Configure](#️-configure)
 - [🧩 Widgets Catalog](#widgets)
-- [🔄 Update & Revert](#update)
+- [🔄 Update, Upgrade & Revert](#update)
 - [🔍 How it Works](#-how-it-works)
 - [🏷️ Supported Versions](#supported-versions)
 - [🩺 Troubleshooting](#-troubleshooting)
@@ -81,7 +81,7 @@ cxstatusline doctor
 
 `cxstatusline install` downloads the verified prebuilt binary matching your Codex version, verifies checksums against `manifest.json`, and activates it.
 - **Interactive selection**: Running `cxstatusline install` opens a keyboard-driven version picker. Use ↑/↓ and Enter to select, or Escape/Ctrl+C to cancel. Prebuilt availability is shown per version; source-only choices require confirmation (unless you already passed `--compile`).
-- **Update choices**: `cxstatusline update` uses the same keyboard controls to choose the latest supported prebuilt, a supported source build, or cancellation. It does not update upstream Codex first.
+- **Upgrade choices**: `cxstatusline upgrade` uses the same keyboard controls to choose the latest supported prebuilt, a supported source build, or cancellation. It does not update upstream Codex first.
 - **Live progress**: Ink renders download progress in terminals while completed stages remain in the transcript. Source builds report their phases; redirected output retains plain milestone logs.
 - **Target a specific version**: `cxstatusline install --codex-version <version>` (e.g. `cxstatusline install --codex-version 0.154.0`).
 - **Non-interactive / CI**: Pass `-y` or `--yes` to accept the default without prompting.
@@ -147,19 +147,35 @@ Type IDs match ccstatusline's, so a ccstatusline preset imports without translat
 👉 The full catalog, and how Custom Command handles timeouts, colours and background caching, are in
 the **[Usage guide](docs/usage.md)**.
 
-## Update
+## Update & Upgrade
+
+cxstatusline follows the Homebrew paradigm for managing updates:
+- **`cxstatusline update`**: Updates the **cxstatusline CLI tool itself** to the latest release (via npm, bun, or git).
+- **`cxstatusline upgrade`**: Upgrades the **patched Codex binary pair** to the latest supported release.
+
+### Updating cxstatusline (The Tool)
+
+```sh
+cxstatusline update          # Updates cxstatusline to the latest version
+cxstatusline update --check  # Checks for available tool updates without installing
+```
+
+`cxstatusline update` automatically detects your install method (`npm`, `bun`, or `git checkout`) and updates the CLI tool.
+
+### Upgrading Patched Codex
 
 ```sh
-cxstatusline update
+cxstatusline upgrade
 ```
 
-`cxstatusline update` downloads and verifies the latest published prebuilt supported by your cxstatusline package, then activates the complete patched Codex pair. It does not run Codex's self-updater or modify your original Codex installation. Open a new Codex session afterward.
+`cxstatusline upgrade` downloads and verifies the latest published prebuilt supported by your cxstatusline package, then activates the complete patched Codex pair. It does not run Codex's self-updater or modify your original Codex installation. Open a new Codex session afterward.
 
-The same Codex version is checked for rebuilt patch assets; a newer installed version is never downgraded. If discovery or verification fails, the active pair stays in place. Update the cxstatusline npm package to pick up support for newer Codex versions.
+The same Codex version is checked for rebuilt patch assets; a newer installed version is never downgraded. If discovery or verification fails, the active pair stays in place. When running `upgrade`, if a newer version of `cxstatusline` is available, it will display a friendly reminder to run `cxstatusline update` first.
 
 Options:
-- `cxstatusline update --compile`: builds the latest locally supported Codex patch from source instead.
+- `cxstatusline upgrade --compile`: builds the latest locally supported Codex patch from source instead.
 - `--force`, `-y`, and `--yes` remain accepted for compatibility; updates already run without a prompt and always verify the pair.
+- Note: Running `cxstatusline update --compile` or `--force` will automatically forward to `cxstatusline upgrade` with a notice.
 
 Session-start updates also leave a newer patched pair in place when the original Codex installation is older, including under the `every` policy.
 

package/dist/cxstatusline.js

@@ -59007,8 +59007,8 @@ function runRefreshCommand(cacheKey2, deps) {
   return 0;
 }
 // src/version-info.ts
-var VERSION = "0.9.1";
-var SOURCE_COMMIT = /^[0-9a-f]{40}$/.test("be615bc225cb654e68b5e29a312762d0572f1281") ? "be615bc225cb654e68b5e29a312762d0572f1281" : null;
+var VERSION = "0.10.1";
+var SOURCE_COMMIT = /^[0-9a-f]{40}$/.test("cb2f6799d53ce95398331bae1cea4f96d2c9641e") ? "cb2f6799d53ce95398331bae1cea4f96d2c9641e" : null;
 var SOURCE_DIRTY = false;
 
 // src/context.ts
@@ -59149,7 +59149,7 @@ function realContext(env3, io) {
 }
 
 // src/patch/run.ts
-import { appendFileSync, mkdirSync as mkdirSync8 } from "node:fs";
+import { appendFileSync, mkdirSync as mkdirSync8, rmSync as rmSync6 } from "node:fs";
 import { join as join18 } from "node:path";
 
 // src/lock.ts
@@ -63147,7 +63147,7 @@ function unchangedPair(ctx, manifest, artifact, tag) {
   if (!release || release.tag !== tag || release.archiveSha256 !== artifact.sha256)
     return null;
   const installed = release.manifest;
-  const identical = record2.codexVersion === manifest.codexVersion && record2.provenance.cxVersion === manifest.cxVersion && record2.provenance.platform === artifact.platform && record2.provenance.patchVersion === manifest.patchVersion && record2.provenance.patchSha256 === manifest.patchSha256 && record2.provenance.upstreamCommit === manifest.upstreamCommit && installed.cxVersion === manifest.cxVersion && installed.codexVersion === manifest.codexVersion && installed.patchSha256 === manifest.patchSha256 && installed.upstreamCommit === manifest.upstreamCommit;
+  const identical = record2.codexVersion === manifest.codexVersion && (manifest.cxVersion === undefined || record2.provenance.cxVersion === manifest.cxVersion) && record2.provenance.platform === artifact.platform && record2.provenance.patchVersion === manifest.patchVersion && record2.provenance.patchSha256 === manifest.patchSha256 && record2.provenance.upstreamCommit === manifest.upstreamCommit && (manifest.cxVersion === undefined || installed.cxVersion === manifest.cxVersion) && installed.codexVersion === manifest.codexVersion && installed.patchSha256 === manifest.patchSha256 && installed.upstreamCommit === manifest.upstreamCommit;
   if (!identical)
     return null;
   const directory = activeGeneration(ctx.paths);
@@ -64202,7 +64202,7 @@ function wrapperScript(patchedBin, cxBin) {
     WRAPPER_MARKER,
     "# Managed by cxstatusline. `cxstatusline revert` restores stock Codex.",
     `if [ "$1" = "update" ]; then`,
-    `  exec ${sq(cxBin)} update`,
+    `  exec ${sq(cxBin)} upgrade`,
     "fi",
     `CXSTATUSLINE_COMMAND=${sq(`${sq(cxBin)} render`)}`,
     "export CXSTATUSLINE_COMMAND",
@@ -64217,7 +64217,7 @@ function generationWrapperScript(currentGeneration, cxBin) {
     WRAPPER_MARKER_V2,
     "# Managed by cxstatusline. `cxstatusline revert` restores stock Codex.",
     `if [ "$1" = "update" ]; then`,
-    `  exec ${sq(cxBin)} update`,
+    `  exec ${sq(cxBin)} upgrade`,
     "fi",
     `CXSTATUSLINE_COMMAND=${sq(`${sq(cxBin)} render`)}`,
     "export CXSTATUSLINE_COMMAND",
@@ -65006,11 +65006,37 @@ async function runUpdate(ctx, opts = {}, transport = {}) {
   }
   const installed = readInstallation(ctx.paths)?.codexVersion ?? loadState(ctx).patched_from;
   const current = installed ? parseSemver(installed) : null;
-  if (current && compareSemver(current, parseSemver(target)) > 0) {
+  const targetSemver = parseSemver(target);
+  if (current && compareSemver(current, targetSemver) > 0) {
     ctx.say(`Installed Codex ${installed} is newer than the latest supported ${opts.compile ? "patch" : "prebuilt"} (${target}); leaving it unchanged.`);
     return 0;
   }
-  if (opts.isTTY && !opts.force && !opts.compile) {
+  if (current && compareSemver(current, targetSemver) === 0 && !opts.force) {
+    const record2 = readInstallation(ctx.paths);
+    if (!opts.compile && record2 && record2.provenance.source === "prebuilt") {
+      try {
+        const expected = {
+          codexVersion: target,
+          platform: platformFor(process.platform, process.arch)
+        };
+        const prepared = await preparePrebuilt(ctx, expected, transport);
+        if (prepared.kind === "unchanged") {
+          ctx.say(`Codex is already up to date (${installed}).`);
+          return 0;
+        }
+        rmSync6(prepared.pair.directory, { recursive: true, force: true });
+      } catch {}
+    } else if (opts.compile && record2 && record2.provenance.source === "compiled") {
+      const patchRef = resolvePatch(manifest, targetSemver);
+      const currentPatch = record2.provenance.patchVersion ?? 1;
+      const targetPatch = patchRef?.patchVersion ?? 1;
+      if (currentPatch >= targetPatch) {
+        ctx.say(`Codex is already up to date (${installed}).`);
+        return 0;
+      }
+    }
+  }
+  if (opts.isTTY && !opts.force && !opts.compile && (!current || compareSemver(current, targetSemver) < 0)) {
     const action = await (opts.promptUpdate ?? promptUpdate)({ latest: target, highestAvailable: target });
     if (action === "cancel") {
       ctx.say("Update cancelled.");
@@ -65863,7 +65889,7 @@ function runPolicy(ctx, argv, io2) {
 }
 
 // src/commands/revert.ts
-import { existsSync as existsSync15, lstatSync as lstatSync7, readdirSync as readdirSync4, rmSync as rmSync6, symlinkSync as symlinkSync2 } from "node:fs";
+import { existsSync as existsSync15, lstatSync as lstatSync7, readdirSync as readdirSync4, rmSync as rmSync7, symlinkSync as symlinkSync2 } from "node:fs";
 import { join as join21 } from "node:path";
 function safeIsSymlink(p2) {
   try {
@@ -65886,7 +65912,7 @@ function revert(ctx) {
 function removeGenerations(ctx, actions) {
   const { currentGeneration, generationsDir } = ctx.paths;
   if (existsSync15(currentGeneration) || safeIsSymlink(currentGeneration)) {
-    rmSync6(currentGeneration, { recursive: true, force: true });
+    rmSync7(currentGeneration, { recursive: true, force: true });
     actions.push(`removed generation pointer ${currentGeneration}`);
   }
   if (!existsSync15(generationsDir))
@@ -65897,12 +65923,12 @@ function removeGenerations(ctx, actions) {
       actions.push(`${dir} is not a cxstatusline generation; left in place`);
       continue;
     }
-    rmSync6(dir, { recursive: true, force: true });
+    rmSync7(dir, { recursive: true, force: true });
     removed += 1;
   }
   actions.push(`removed ${removed} cxstatusline generation${removed === 1 ? "" : "s"} from ${generationsDir}`);
   if (readdirSync4(generationsDir).length === 0)
-    rmSync6(generationsDir, { recursive: true, force: true });
+    rmSync7(generationsDir, { recursive: true, force: true });
 }
 var OWNED_LIBEXEC_PREFIXES = ["current.", "staging-", "download-", "compiled-"];
 function removeStagingDebris(ctx, actions) {
@@ -65911,7 +65937,7 @@ function removeStagingDebris(ctx, actions) {
     return;
   const debris = readdirSync4(libexecDir).filter((n) => OWNED_LIBEXEC_PREFIXES.some((p2) => n.startsWith(p2)));
   for (const name of debris)
-    rmSync6(join21(libexecDir, name), { recursive: true, force: true });
+    rmSync7(join21(libexecDir, name), { recursive: true, force: true });
   if (debris.length > 0) {
     actions.push(`removed ${debris.length} leftover staging entr${debris.length === 1 ? "y" : "ies"} from ${libexecDir}`);
   }
@@ -65925,7 +65951,7 @@ function revertLocked(ctx) {
   const w2 = ctx.paths.wrapperPath;
   if (existsSync15(w2) || safeIsSymlink(w2)) {
     if (isOurWrapper(w2)) {
-      rmSync6(w2);
+      rmSync7(w2);
       actions.push(`removed wrapper ${w2}`);
       if (state.launcher_restore?.kind === "symlink") {
         symlinkSync2(state.launcher_restore.target, w2);
@@ -65940,11 +65966,11 @@ function revertLocked(ctx) {
   removeGenerations(ctx, actions);
   removeStagingDebris(ctx, actions);
   if (existsSync15(ctx.paths.patchedBin)) {
-    rmSync6(ctx.paths.patchedBin);
+    rmSync7(ctx.paths.patchedBin);
     actions.push(`removed patched binary ${ctx.paths.patchedBin}`);
   }
   if (existsSync15(ctx.paths.patchedCodeModeHost)) {
-    rmSync6(ctx.paths.patchedCodeModeHost);
+    rmSync7(ctx.paths.patchedCodeModeHost);
     actions.push(`removed Code Mode host ${ctx.paths.patchedCodeModeHost}`);
   }
   try {
@@ -68465,6 +68491,154 @@ function readMemoryUsage(deps, nowMs) {
   }
 }
 
+// src/commands/update-tool.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { existsSync as existsSync17, realpathSync as realpathSync4 } from "node:fs";
+import { dirname as dirname11, join as join23 } from "node:path";
+async function defaultFetchLatestVersion() {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), 5000);
+  try {
+    const res = await fetch("https://registry.npmjs.org/cxstatusline/latest", {
+      headers: { Accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function detectInstallType(binaryPath = process.argv[1]) {
+  if (!binaryPath)
+    return { type: "npm" };
+  try {
+    let resolved = binaryPath;
+    try {
+      resolved = realpathSync4(binaryPath);
+    } catch {}
+    let dir = dirname11(resolved);
+    for (let i = 0;i < 5; i++) {
+      if (existsSync17(join23(dir, ".git")) && existsSync17(join23(dir, "package.json"))) {
+        return { type: "git", repoDir: dir };
+      }
+      const parent = dirname11(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+    if (binaryPath.includes(".bun") || resolved.includes(".bun")) {
+      return { type: "bun" };
+    }
+    if (binaryPath.includes("pnpm") || resolved.includes("pnpm")) {
+      return { type: "pnpm" };
+    }
+  } catch {}
+  return { type: "npm" };
+}
+function defaultExecCommand(cmd, args) {
+  const res = spawnSync5(cmd, args, { encoding: "utf8" });
+  return {
+    status: res.status ?? (res.error ? 1 : 0),
+    stdout: res.stdout || "",
+    stderr: res.stderr || (res.error ? res.error.message : "")
+  };
+}
+async function runUpdateTool(flags, io2, deps = {}) {
+  const checkOnly = flags.includes("--check");
+  const currentVersionStr = deps.currentVersion ?? VERSION;
+  const currentSemver = parseSemver(currentVersionStr);
+  if (!currentSemver) {
+    io2.stderr(`Invalid current version: ${currentVersionStr}
+`);
+    return 1;
+  }
+  io2.stdout(`Checking for cxstatusline updates...
+`);
+  const fetcher = deps.fetchLatestVersion ?? defaultFetchLatestVersion;
+  const latest = await fetcher();
+  if (!latest) {
+    io2.stderr(`Failed to check for updates: could not reach npm registry.
+`);
+    return 1;
+  }
+  const latestSemver = parseSemver(latest);
+  if (!latestSemver) {
+    io2.stderr(`Invalid version received from registry: ${latest}
+`);
+    return 1;
+  }
+  if (compareSemver(latestSemver, currentSemver) <= 0) {
+    io2.stdout(`cxstatusline is already up to date (${currentVersionStr}).
+`);
+    return 0;
+  }
+  if (checkOnly) {
+    io2.stdout(`Update available: ${currentVersionStr} -> ${latest}
+`);
+    io2.stdout("Run `cxstatusline update` to upgrade the tool.\n");
+    return 0;
+  }
+  const detector = deps.detectInstallType ?? (() => detectInstallType());
+  const installInfo = detector();
+  const exec2 = deps.execCommand ?? defaultExecCommand;
+  if (installInfo.type === "git" && installInfo.repoDir) {
+    io2.stdout(`Updating cxstatusline from git repository at ${installInfo.repoDir}...
+`);
+    const pull2 = exec2("git", ["-C", installInfo.repoDir, "pull", "origin", "main"]);
+    if (pull2.status !== 0) {
+      io2.stderr(`Failed to update cxstatusline via git pull:
+${pull2.stderr || pull2.stdout}
+`);
+      return 1;
+    }
+    const install2 = exec2("bun", ["--cwd", installInfo.repoDir, "install", "--frozen-lockfile"]);
+    if (install2.status !== 0) {
+      io2.stderr(`Failed to run bun install in repo:
+${install2.stderr || install2.stdout}
+`);
+      return 1;
+    }
+    const build = exec2("bun", ["--cwd", installInfo.repoDir, "run", "build"]);
+    if (build.status !== 0) {
+      io2.stderr(`Failed to build cxstatusline in repo:
+${build.stderr || build.stdout}
+`);
+      return 1;
+    }
+    io2.stdout(`Successfully updated cxstatusline from git checkout.
+`);
+    return 0;
+  }
+  let command = "npm";
+  let args = ["install", "-g", "cxstatusline@latest"];
+  if (installInfo.type === "bun") {
+    command = "bun";
+    args = ["add", "-g", "cxstatusline@latest"];
+  } else if (installInfo.type === "pnpm") {
+    command = "pnpm";
+    args = ["add", "-g", "cxstatusline@latest"];
+  }
+  io2.stdout(`Updating cxstatusline via ${command} (${command} ${args.join(" ")})...
+`);
+  const result2 = exec2(command, args);
+  if (result2.status !== 0) {
+    io2.stderr(`Failed to update cxstatusline:
+${result2.stderr || result2.stdout}
+`);
+    io2.stderr(`You can try updating manually with: ${command} ${args.join(" ")}
+`);
+    return 1;
+  }
+  io2.stdout(`Successfully updated cxstatusline to ${latest}.
+`);
+  return 0;
+}
+
 // src/main.ts
 var USAGE = `usage: cxstatusline [command]
 
@@ -68474,7 +68648,8 @@ var USAGE = `usage: cxstatusline [command]
                               install the published Codex pair (--compile builds it from source)
   patch [--force]             build and install the patched Codex from source
   patch --simulate-drift <v>  record <v> as the installed version so the next session sees drift
-  update [--compile|--force]  install the latest supported patched Codex pair
+  update [--check]            update cxstatusline tool to the latest version
+  upgrade [--compile|--force] upgrade the patched Codex pair to the latest supported version
   hook [install|uninstall]    manage the SessionStart entry; bare 'hook' is what Codex runs
   doctor                      report toolchain, drift, hook and wrapper state
   policy [get|set <policy>]   view or update policy (every, stable-minors, manual)
@@ -68617,12 +68792,44 @@ async function installCommand(argv, io2, deps) {
   return runInstall(ctx, { compile: compile3, codexVersion }, deps.transport);
 }
 async function updateCommand(argv, io2, deps) {
+  const flags = argv.slice(1);
+  const codexFlags = new Set(["--compile", "--force", "-y", "--yes"]);
+  if (flags.some((f2) => codexFlags.has(f2) || f2.startsWith("--codex-version"))) {
+    io2.stdout(`Notice: 'cxstatusline upgrade' is now used to upgrade the patched Codex pair.
+Forwarding to 'upgrade'...
+
+`);
+    return upgradeCommand(argv, io2, deps);
+  }
+  const allowed = new Set(["--check", "-h", "--help"]);
+  if (flags.some((f2) => !allowed.has(f2))) {
+    io2.stderr(USAGE);
+    return 2;
+  }
+  const updater = deps.updateTool ?? runUpdateTool;
+  return updater(flags, io2, { fetchLatestVersion: deps.fetchLatestToolVersion });
+}
+async function upgradeCommand(argv, io2, deps) {
   const flags = argv.slice(1);
   const allowed = new Set(["--compile", "--force", "-y", "--yes"]);
   if (flags.some((f2) => !allowed.has(f2))) {
     io2.stderr(USAGE);
     return 2;
   }
+  try {
+    const latest = await (deps.fetchLatestToolVersion ?? defaultFetchLatestVersion)();
+    if (latest) {
+      const parsedLatest = parseSemver(latest);
+      const parsedCurrent = parseSemver(VERSION);
+      if (parsedLatest && parsedCurrent && compareSemver(parsedLatest, parsedCurrent) === 1) {
+        io2.stdout(`
+\uD83D\uDCA1 Note: A newer version of cxstatusline is available (${VERSION} → ${latest}).
+   Run 'cxstatusline update' to update the tool for the newest Codex patches.
+
+`);
+      }
+    }
+  } catch {}
   return runUpdate(contextFor(io2, deps), {
     compile: flags.includes("--compile"),
     force: flags.includes("--force") || flags.includes("-y") || flags.includes("--yes"),
@@ -68693,6 +68900,8 @@ async function main(argv, io2, deps = {}) {
     return patchCommand(argv, io2, deps);
   if (cmd === "update")
     return updateCommand(argv, io2, deps);
+  if (cmd === "upgrade")
+    return upgradeCommand(argv, io2, deps);
   if (cmd === "install")
     return installCommand(argv, io2, deps);
   if (cmd === "hook" && (argv[1] === "install" || argv[1] === "uninstall")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cxstatusline",
-  "version": "0.9.1",
+  "version": "0.10.1",
   "description": "Customizable statusline for OpenAI Codex CLI",
   "license": "MIT",
   "repository": {