claude-code-infinite 1.0.19 → 1.0.21

package/README.md

@@ -256,6 +256,30 @@ features, and their output, often the biggest source of tokens, is exactly what
 For `ccc --resume <id>`, an automatic, best-effort repair can unblock a transcript whose last response already exceeds Claude Code’s local refusal limit. It changes only that response’s usage totals and the iteration Claude Code counts, after writing an exclusive, uniquely named backup under `~/.claude-code-infinite/transcript-backups`. Earlier iterations and conversation content stay intact. The installed Claude Code 2.1.288 computes its blocking limit as the context window minus the output allowance (capped at 20,000) minus 3,000 tokens: 977,000 for the supported 1M models. Other versions use the conservative full-window threshold. The window comes from ccc’s model table, explicit `[1m]` transcript model signals, and any `--model` or `ANTHROPIC_MODEL` override, conservatively keeping the largest supported window. A successful response with input already beyond that inferred window disproves the inference and is never repaired. Unknown model overrides (including unresolved aliases), models or usage shapes, threshold overrides, possible running writers, changed snapshots, backup collisions, and filesystem errors all skip repair and continue the original resume. Process and file checks are bounded; other running JavaScript runtimes may conservatively prevent repair.
 
 
+## Releasing
+
+Releases are staged by GitHub Actions through npm Trusted Publishing (OIDC), so no npm
+token, passkey or browser is needed to build and upload them, and each one is approved by a
+maintainer before it goes live:
+
+1. On a clean `main`, run `./publish.sh` (or `./publish.sh minor` / `major`). It builds,
+   checks that `dist/` is committed, runs `npm version`, and pushes the commit and the
+   `vX.Y.Z` tag.
+2. The tag push runs [`.github/workflows/publish.yml`](.github/workflows/publish.yml): `npm ci`,
+   the test suite with `NO_COLOR=1` and with `FORCE_COLOR=1`, a check that the rebuilt
+   `dist/` matches the commit and that the tag equals `package.json`'s version, then
+   `npm stage publish --provenance`.
+3. Approve the staged version (2FA) on
+   [npmjs.com](https://www.npmjs.com/package/claude-code-infinite) under the **Staged
+   Packages** tab, or with `npm stage list claude-code-infinite` and
+   `npm stage approve <stage-id>`. Until then it is not installable.
+
+The trusted publisher on npmjs.com is bound to the workflow file name `publish.yml` with no
+GitHub environment, and allows only staged publishing; renaming the workflow breaks it.
+`./publish.sh --local` is the fallback: it publishes directly from your machine with npm web
+auth, then pushes the commit and tag; the workflow still tests that tag but skips staging,
+since the version is already published.
+
 ## Troubleshooting
 
 ### Anthropic auth errors (401s, login prompts)
@@ -268,12 +292,78 @@ If you see an inline "⚠ MemTree degraded — this turn ran uncompressed" notic
 
 ## Upgrading
 
-`ccc` checks npm at startup (bounded to two seconds, silent if offline) and, when a
-newer release exists, shows one line under the MemTree banner inside Claude Code with
-the upgrade command. Upgrading is never automatic:
+`ccc` checks npm at startup (bounded to 1.5 seconds, silent if offline, and cached for a
+day in `~/.claude-code-infinite/update-check.json`). Prereleases are never offered, and
+print (`-p`) or non-TTY runs skip the check. When a newer release exists and `ccc` can
+update itself, it does (see [Automatic updates](#automatic-updates)); otherwise it shows
+one line under the MemTree banner inside Claude Code, e.g.
+`• ccc 1.0.21 is available (you have 1.0.20) · npm i -g claude-code-infinite@latest`.
+To upgrade by hand:
 
 ```bash
-npm install -g claude-code-infinite
+npm i -g claude-code-infinite@latest
+```
+
+Set `CCC_NO_UPDATE_CHECK=1` (or the older `CCC_SKIP_UPDATE_CHECK=1`), or add
+`"updateCheck": false` to `~/.claude-code-infinite/config.json`, to disable the check
+(air-gapped or CI runs). That also turns off automatic updates.
+
+## Automatic updates
+
+Like Claude Code, `ccc` installs a newer release for you in the background. A few
+seconds after an interactive session starts, if the update check found a newer
+release, `ccc` runs
+
+```bash
+npm install --global --prefix=<your npm prefix> claude-code-infinite@<that version> --no-fund --no-audit
+```
+
+in a detached process, so the session never waits for it and quitting `ccc` does not
+stop it. When it has finished, the next session start inside Claude Code (a new
+conversation, `/clear`, or a resume) shows, once:
+
+```
+✔ ccc 1.0.21 installed · restart ccc to use it
 ```
 
-Set `CCC_SKIP_UPDATE_CHECK=1` to disable the check (air-gapped or CI runs).
+The session keeps running the version it started with until you restart `ccc`. If the
+install fails, you get the usual `• ccc 1.0.21 is available … · npm i -g
+claude-code-infinite@latest` line instead, and `ccc` waits a day before trying again; it
+tries each version at most twice. The npm output of the last attempt is in
+`~/.claude-code-infinite/auto-update.log`, and its result in `update-state.json` next to
+it. Only one session installs at a time (`update.lock.d` there). If an installer was
+killed in a way `ccc` cannot verify, that lock stays held rather than risk two installs
+at once; after an hour `ccc` shows the update line instead, and deleting
+`~/.claude-code-infinite/update.lock.d` clears it.
+
+**When it doesn't.** `ccc` updates itself only when it is a plain global npm install
+(`npm i -g`) whose files are in `npm root -g` and writable by you. It never uses `sudo`.
+In every other case it only shows the update line:
+
+- `npm link`ed or git checkouts (a development copy is never touched),
+- `npx` and project-local installs,
+- pnpm, yarn, bun and Volta global installs (update with your tool's own command),
+- a global prefix that needs `sudo` to write, or `ccc` running as root,
+- Windows,
+- print (`-p`) and non-TTY runs, which never install anything.
+
+`ccc --debug` prints which install method was detected and what it decided.
+
+**Sessions running during an update.** npm replaces `ccc`'s files while other `ccc`
+sessions may be running. They are unaffected: each `ccc` loads all of its code when it
+starts, and the Claude Code hooks it registers either call into that running `ccc` over
+localhost or run files in its own temporary plugin directory, never the installed
+package. The one exception is the `memtree` MCP server, which Claude Code starts from the
+installed files: a server started after the update (for example, Claude Code restarting
+it with `/mcp`) runs the new version against the old session. It keeps working, and if a
+tool call fails it says that the versions differ and to restart `ccc`. If Claude Code
+starts it in the few seconds while npm is writing the files, it can fail to start; `/mcp`
+reconnects it.
+
+**Turning it off.** Any of these keeps the update line but never installs:
+
+- `CCC_DISABLE_AUTOUPDATE=1`,
+- `"autoUpdate": false` in `~/.claude-code-infinite/config.json`,
+- Claude Code's own `DISABLE_AUTOUPDATER=1`.
+
+The update-check opt-outs above turn off both the check and automatic updates.

package/dist/auto-update-runner.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The detached background installer for auto-update.ts, as source text that
+ * ccc runs with `node -e RUNNER_SOURCE <config json>`.
+ *
+ * Self-contained on purpose: it requires only Node built-ins and reads no file
+ * from the ccc package, because the npm install it runs replaces that package.
+ * It outlives the ccc that started it (detached, own process group), records
+ * the result in update-state.json and releases the lock by its token.
+ *
+ * Ownership: the launcher created this runner's lock entry and records the
+ * runner's pid in it right after spawning; the runner waits for that handoff,
+ * exits without touching anything if the entry is gone, and re-checks the
+ * entry before every npm command. Once stopping (abort or lost lock) it never
+ * starts another command.
+ *
+ * Steps: re-validate the version; confirm `npm root -g` is the directory this
+ * ccc lives in and that the entry there is not a symlink (an `npm link`); run
+ * `npm install --global --prefix=<that prefix> claude-code-infinite@<version>
+ * --no-fund --no-audit` (argv, never a shell); confirm the package.json now
+ * says that version. Any failure is recorded with a short reason.
+ *
+ * Bounded: each npm command runs in its own process group, recorded in the
+ * lock entry. When it ends (or times out) the whole group is reaped: SIGTERM,
+ * then SIGKILL, until no member is left, so a descendant that outlives npm
+ * cannot go on writing the package. The lock is released only once the group
+ * is confirmed gone; otherwise the entry stays live for as long as the group
+ * is (update-lock.ts). A hard deadline and SIGTERM/SIGINT/SIGHUP to the runner
+ * kill the group, record a failure and exit, so the lock's stale age is never
+ * reached by a live runner.
+ */
+/** What ccc passes the runner, as JSON in argv[1]. */
+export interface RunnerConfig {
+    npm: string;
+    packageName: string;
+    version: string;
+    packageDir: string;
+    npmRoot: string;
+    prefix: string;
+    stateFile: string;
+    /** update-lock.ts directory; this runner owns `<lockDir>/<token>.json`. */
+    lockDir: string;
+    logFile: string;
+    token: string;
+    timeoutMs: number;
+    /** Test-only: how long to wait for the launcher's handoff (default 10 s). */
+    handoffMs?: number;
+    /** Test-only: SIGTERM→SIGKILL and SIGKILL→give-up waits (default 10 s, 5 s). */
+    killGraceMs?: number;
+    pipeGraceMs?: number;
+}
+export declare const RUNNER_SOURCE: string;
+//# sourceMappingURL=auto-update-runner.d.ts.map

package/dist/auto-update-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-update-runner.d.ts","sourceRoot":"","sources":["../src/auto-update-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,aAAa,QAmRzB,CAAC"}

package/dist/auto-update-runner.js

@@ -0,0 +1,307 @@
+/**
+ * The detached background installer for auto-update.ts, as source text that
+ * ccc runs with `node -e RUNNER_SOURCE <config json>`.
+ *
+ * Self-contained on purpose: it requires only Node built-ins and reads no file
+ * from the ccc package, because the npm install it runs replaces that package.
+ * It outlives the ccc that started it (detached, own process group), records
+ * the result in update-state.json and releases the lock by its token.
+ *
+ * Ownership: the launcher created this runner's lock entry and records the
+ * runner's pid in it right after spawning; the runner waits for that handoff,
+ * exits without touching anything if the entry is gone, and re-checks the
+ * entry before every npm command. Once stopping (abort or lost lock) it never
+ * starts another command.
+ *
+ * Steps: re-validate the version; confirm `npm root -g` is the directory this
+ * ccc lives in and that the entry there is not a symlink (an `npm link`); run
+ * `npm install --global --prefix=<that prefix> claude-code-infinite@<version>
+ * --no-fund --no-audit` (argv, never a shell); confirm the package.json now
+ * says that version. Any failure is recorded with a short reason.
+ *
+ * Bounded: each npm command runs in its own process group, recorded in the
+ * lock entry. When it ends (or times out) the whole group is reaped: SIGTERM,
+ * then SIGKILL, until no member is left, so a descendant that outlives npm
+ * cannot go on writing the package. The lock is released only once the group
+ * is confirmed gone; otherwise the entry stays live for as long as the group
+ * is (update-lock.ts). A hard deadline and SIGTERM/SIGINT/SIGHUP to the runner
+ * kill the group, record a failure and exit, so the lock's stale age is never
+ * reached by a live runner.
+ */
+export const RUNNER_SOURCE = String.raw `"use strict";
+const { spawn } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const VERSION_RE = /^(0|[1-9]\d{0,8})\.(0|[1-9]\d{0,8})\.(0|[1-9]\d{0,8})$/;
+const ROOT_TIMEOUT_MS = 60000;
+const cfg = JSON.parse(process.argv[1]);
+const KILL_GRACE_MS = cfg.killGraceMs || 10000;
+const PIPE_GRACE_MS = cfg.pipeGraceMs || 5000;
+const ENTRY = path.join(cfg.lockDir, cfg.token + ".json");
+const HANDOFF_MS = cfg.handoffMs || 10000;
+let logFd = null;
+let group = null;
+let done = false;
+// Set first thing on abort or a lost lock: no command starts after it.
+let stopping = null;
+
+// Hard deadline: whatever npm does, this process kills its group, records a
+// result and exits, so a live holder never outlasts the lock's stale age.
+const DEADLINE_MS = ROOT_TIMEOUT_MS + cfg.timeoutMs + 2 * (2 * KILL_GRACE_MS + 2 * PIPE_GRACE_MS) + 30000;
+setTimeout(() => abort("runner deadline passed"), DEADLINE_MS);
+for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+  process.on(signal, () => abort("runner stopped by " + signal));
+}
+
+function note(line) {
+  try {
+    if (logFd !== null) fs.writeSync(logFd, "[" + new Date().toISOString() + "] " + line + "\n");
+  } catch {}
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function groupAlive(pgid) {
+  try {
+    process.kill(-pgid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+
+function signalGroup(pgid, signal) {
+  try { process.kill(-pgid, signal); } catch {}
+}
+
+async function goneWithin(pgid, ms) {
+  const until = Date.now() + ms;
+  while (groupAlive(pgid)) {
+    if (Date.now() >= until) return false;
+    await sleep(100);
+  }
+  return true;
+}
+
+// Every member of the command's group, not only npm: SIGTERM, then SIGKILL.
+async function reapGroup(pgid) {
+  if (!groupAlive(pgid)) return true;
+  signalGroup(pgid, "SIGTERM");
+  if (await goneWithin(pgid, KILL_GRACE_MS)) return true;
+  signalGroup(pgid, "SIGKILL");
+  return goneWithin(pgid, PIPE_GRACE_MS);
+}
+
+// The lock entry names the group while it may be alive (update-lock.ts).
+// "spawning" is set before every npm spawn and cleared only once its group is
+// recorded: if this runner dies in between, the entry stays live (fail
+// closed) because an unrecorded npm may be running (update-lock.ts).
+function recordGroup(pgid, spawning) {
+  const entry = readEntry();
+  if (!entry) {
+    stopping = stopping || "lost the install lock";
+    if (pgid !== null) signalGroup(pgid, "SIGKILL"); // started without the lock: stop it
+    return false;
+  }
+  try {
+    entry.pid = process.pid;
+    entry.runner = process.pid;
+    if (pgid === null) delete entry.group; else entry.group = pgid;
+    if (spawning) entry.spawning = true; else delete entry.spawning;
+    const tmp = path.join(cfg.lockDir, "." + cfg.token + "." + process.pid + ".tmp");
+    fs.writeFileSync(tmp, JSON.stringify(entry), { mode: 0o600 });
+    fs.renameSync(tmp, ENTRY);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readEntry() {
+  try {
+    const entry = JSON.parse(fs.readFileSync(ENTRY, "utf8"));
+    return entry && entry.token === cfg.token ? entry : null;
+  } catch {
+    return null;
+  }
+}
+
+// The launcher records this runner's pid in the entry right after spawning
+// it; until then the entry is not provably ours. Gone means another session
+// took the lock: leave everything to it.
+async function awaitHandoff() {
+  const until = Date.now() + HANDOFF_MS;
+  for (;;) {
+    const entry = readEntry();
+    if (!entry) return "lost";
+    if (entry.runner === process.pid) return "ok";
+    if (Date.now() >= until) return "timeout";
+    await sleep(50);
+  }
+}
+
+// Resolves when the command is over: it closed, it exited (its pipes are not
+// waited on for long), or it timed out. The caller then reaps its group.
+function run(command, args, timeoutMs, capture) {
+  return new Promise((resolve) => {
+    let out = "";
+    let settled = false;
+    let child;
+    const timers = [];
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      timers.forEach(clearTimeout);
+      resolve(Object.assign({ out, pgid: child ? child.pid : null }, result));
+    };
+    if (stopping || !recordGroup(null, true)) {
+      finish({ code: null, error: stopping || "lost the install lock" });
+      return;
+    }
+    try {
+      child = spawn(command, args, {
+        cwd: os.homedir(),
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true,
+      });
+    } catch (err) {
+      recordGroup(null, false);
+      finish({ code: null, error: String(err) });
+      return;
+    }
+    if (child.pid) {
+      group = child.pid;
+      recordGroup(group, false);
+    } else {
+      recordGroup(null, false); // spawn failed; its 'error' event follows
+    }
+    timers.push(setTimeout(() => finish({ code: null, timedOut: true }), timeoutMs));
+    const logChunk = (chunk) => {
+      try { if (logFd !== null) fs.writeSync(logFd, chunk); } catch {}
+    };
+    child.stdout.on("data", (chunk) => {
+      if (capture && out.length < 65536) out += chunk.toString("utf8");
+      logChunk(chunk);
+    });
+    child.stderr.on("data", logChunk);
+    child.on("error", (err) => finish({ code: null, error: String(err) }));
+    child.on("exit", (code, signal) => {
+      timers.push(setTimeout(() => finish({ code, signal }), PIPE_GRACE_MS));
+    });
+    child.on("close", (code, signal) => finish({ code, signal }));
+  });
+}
+
+// Run a command and make sure nothing it started is left running.
+async function runReaped(command, args, timeoutMs, capture) {
+  const result = await run(command, args, timeoutMs, capture);
+  if (result.pgid) {
+    if (!(await reapGroup(result.pgid))) {
+      const err = new Error("could not stop npm's processes (group " + result.pgid + ")");
+      err.groupAlive = true;
+      throw err;
+    }
+    group = null;
+    recordGroup(null, false);
+  }
+  return result;
+}
+
+function realpath(p) {
+  try { return fs.realpathSync(p); } catch { return null; }
+}
+
+function describe(result, what) {
+  if (result.error) return what + " could not run: " + result.error;
+  if (result.timedOut) return what + " timed out";
+  if (result.code !== 0) return what + " exited with " + (result.code === null ? result.signal : result.code);
+  return null;
+}
+
+async function install() {
+  if (!VERSION_RE.test(cfg.version)) throw new Error("refusing version " + JSON.stringify(cfg.version));
+  const rootRun = await runReaped(cfg.npm, ["root", "--global"], ROOT_TIMEOUT_MS, true);
+  const rootFailure = describe(rootRun, "npm root -g");
+  if (rootFailure) throw new Error(rootFailure);
+  const npmRoot = realpath(rootRun.out.trim());
+  if (npmRoot === null || npmRoot !== realpath(cfg.npmRoot)) {
+    throw new Error("npm root -g is " + rootRun.out.trim() + ", not " + cfg.npmRoot + ": wrong prefix");
+  }
+  const entry = path.join(npmRoot, cfg.packageName);
+  if (fs.lstatSync(entry).isSymbolicLink()) throw new Error(entry + " is a symlink (npm link)");
+  if (realpath(entry) !== realpath(cfg.packageDir)) throw new Error(entry + " is not this ccc");
+  const spec = cfg.packageName + "@" + cfg.version;
+  const args = ["install", "--global", "--prefix=" + cfg.prefix, spec, "--no-fund", "--no-audit"];
+  note("npm " + args.join(" "));
+  const failure = describe(await runReaped(cfg.npm, args, cfg.timeoutMs, false), "npm install");
+  if (failure) throw new Error(failure);
+  const pkg = JSON.parse(fs.readFileSync(path.join(cfg.packageDir, "package.json"), "utf8"));
+  if (pkg.version !== cfg.version) throw new Error("installed version is " + pkg.version);
+}
+
+function record(status, error) {
+  let state = {};
+  try { state = JSON.parse(fs.readFileSync(cfg.stateFile, "utf8")) || {}; } catch {}
+  state.last = { version: cfg.version, status, at: Date.now(), packageDir: cfg.packageDir };
+  if (error) state.last.error = String(error).slice(0, 300);
+  const tmp = cfg.stateFile + "." + process.pid + ".tmp";
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(state), { mode: 0o600 });
+    fs.renameSync(tmp, cfg.stateFile);
+  } catch {
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+  }
+}
+
+// Record, release the lock unless npm's group may still be alive (its entry
+// then stays live exactly as long as the group: update-lock.ts), and exit.
+function finishRun(status, error) {
+  if (done) return;
+  done = true;
+  note(status === "ok" ? "installed " + cfg.version : "failed: " + error);
+  // Without the lock the state belongs to whoever holds it now.
+  if (readEntry()) record(status, error);
+  if (group === null || !groupAlive(group)) {
+    try { fs.rmSync(ENTRY, { force: true }); } catch {}
+  } else {
+    note("npm's processes are still exiting; the lock stays held until they are gone");
+  }
+  try { if (logFd !== null) fs.closeSync(logFd); } catch {}
+  process.exit(status === "ok" ? 0 : 1);
+}
+
+async function abort(reason) {
+  if (done || stopping) return;
+  stopping = reason;
+  if (group !== null) {
+    signalGroup(group, "SIGKILL");
+    await goneWithin(group, 2000);
+  }
+  finishRun("failed", reason);
+}
+
+(async () => {
+  const handoff = await awaitHandoff();
+  if (handoff === "lost") process.exit(1); // not ours: record nothing, touch nothing
+  if (handoff === "timeout") {
+    stopping = "the launcher never handed over the install lock";
+    finishRun("failed", stopping);
+    return;
+  }
+  recordGroup(null, false); // the lock's holder is this runner from now on
+  try { logFd = fs.openSync(cfg.logFile, "w", 0o600); } catch {}
+  note("installing " + cfg.packageName + "@" + cfg.version + " into " + cfg.prefix);
+  try {
+    await install();
+    finishRun("ok");
+  } catch (err) {
+    finishRun("failed", err && err.message ? err.message : String(err));
+  }
+})();
+`;
+//# sourceMappingURL=auto-update-runner.js.map

package/dist/auto-update-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-update-runner.js","sourceRoot":"","sources":["../src/auto-update-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAuBH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmRtC,CAAC"}

package/dist/auto-update-setup.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Launch-time glue for auto-update.ts: decide what this interactive launch
+ * does about an available update, what the SessionStart banner says now, and
+ * when the background install starts (after Claude Code is up, never on the
+ * startup path).
+ */
+import { AutoUpdateNotices, type AutoUpdateConfig, type AutoUpdateDecision, type InstallMethod, type SpawnLike, type StartInstallResult } from "./auto-update.js";
+import type { UpdateAvailable } from "./update-check.js";
+export interface AutoUpdateSetupOptions {
+    update: UpdateAvailable | null;
+    currentVersion: string;
+    config: AutoUpdateConfig;
+    configDir: string;
+    color: boolean;
+    env?: NodeJS.ProcessEnv;
+    packageDir?: string;
+    now?: () => number;
+    spawnImpl?: SpawnLike;
+    platform?: NodeJS.Platform;
+    uid?: number;
+}
+export interface AutoUpdateSetup {
+    decision: AutoUpdateDecision;
+    /** Detected only when there is an update to act on. */
+    method: InstallMethod | null;
+    /** The banner's hint line: shown unless an install is about to run. */
+    bannerUpdate: UpdateAvailable | null;
+    /** The banner's "✔ installed" line, when an earlier install already landed. */
+    bannerInstalled: string | null;
+    /** The SessionStart line for later hooks in this process (proxy option). */
+    notices: AutoUpdateNotices;
+    /** Start the planned install after `delayMs`; a no-op unless planned. */
+    scheduleInstall(delayMs?: number, onResult?: (result: StartInstallResult) => void): void;
+    /** One line naming the install method and the decision, for --debug. */
+    debugLine: string;
+}
+export declare function setupAutoUpdate(opts: AutoUpdateSetupOptions): AutoUpdateSetup;
+//# sourceMappingURL=auto-update-setup.d.ts.map

package/dist/auto-update-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-update-setup.d.ts","sourceRoot":"","sources":["../src/auto-update-setup.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAEL,iBAAiB,EASjB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,uDAAuD;IACvD,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7B,uEAAuE;IACvE,YAAY,EAAE,eAAe,GAAG,IAAI,CAAC;IACrC,+EAA+E;IAC/E,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,4EAA4E;IAC5E,OAAO,EAAE,iBAAiB,CAAC;IAC3B,yEAAyE;IACzE,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,GAAG,IAAI,CAAC;IACzF,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,eAAe,CA4C7E"}

package/dist/auto-update-setup.js

@@ -0,0 +1,72 @@
+/**
+ * Launch-time glue for auto-update.ts: decide what this interactive launch
+ * does about an available update, what the SessionStart banner says now, and
+ * when the background install starts (after Claude Code is up, never on the
+ * startup path).
+ */
+import { spawn } from "node:child_process";
+import { AUTO_UPDATE_DELAY_MS, AutoUpdateNotices, PACKAGE_DIR, detectInstallMethod, liveLockSince, planAutoUpdate, readInstalledVersion, readUpdateState, startAutoUpdateInstall, updateFiles, } from "./auto-update.js";
+import { updateInstalledNoticeText, updateNoticeText } from "./notices.js";
+export function setupAutoUpdate(opts) {
+    const env = opts.env ?? process.env;
+    const packageDir = opts.packageDir ?? PACKAGE_DIR;
+    const now = opts.now ?? Date.now;
+    const files = updateFiles(opts.configDir);
+    const method = opts.update ? detectMethod(opts, env, packageDir) : null;
+    const decision = method
+        ? planAutoUpdate({
+            update: opts.update,
+            method,
+            state: readUpdateState(files.stateFile),
+            env,
+            config: opts.config,
+            now: now(),
+            installedVersion: readInstalledVersion(method.packageDir),
+            lockHeldSince: liveLockSince(files.lockDir, now()),
+        })
+        : { action: "skip", reason: "no update available" };
+    const notices = new AutoUpdateNotices({
+        currentVersion: opts.currentVersion,
+        packageDir: method?.packageDir ?? packageDir,
+        stateFile: files.stateFile,
+        startedAt: now(),
+        installedText: (version) => updateInstalledNoticeText(version, opts.color),
+        hintText: (update) => updateNoticeText(update, opts.color),
+    });
+    if (decision.action === "installed")
+        notices.markShown();
+    return {
+        decision,
+        method,
+        bannerUpdate: decision.action === "skip" ? opts.update : null,
+        bannerInstalled: decision.action === "installed" ? decision.version : null,
+        notices,
+        scheduleInstall(delayMs = AUTO_UPDATE_DELAY_MS, onResult) {
+            if (decision.action !== "install")
+                return;
+            const spawnImpl = opts.spawnImpl ?? spawn;
+            const timer = setTimeout(() => {
+                const result = startAutoUpdateInstall({ decision, files, spawnImpl, env, now });
+                onResult?.(result);
+            }, delayMs);
+            timer.unref();
+        },
+        debugLine: debugLine(method, decision),
+    };
+}
+function detectMethod(opts, env, packageDir) {
+    return detectInstallMethod({
+        packageDir,
+        env,
+        platform: opts.platform,
+        uid: opts.uid ?? process.getuid?.(),
+    });
+}
+function debugLine(method, decision) {
+    const how = method ? `install method ${method.kind} (${method.detail})` : "no update to install";
+    const what = decision.action === "install" ? `installing ${decision.version} in the background`
+        : decision.action === "installed" ? `${decision.version} already installed, restart to use it`
+            : `not installing: ${decision.reason}`;
+    return `Auto-update: ${how}; ${what}`;
+}
+//# sourceMappingURL=auto-update-setup.js.map

package/dist/auto-update-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-update-setup.js","sourceRoot":"","sources":["../src/auto-update-setup.ts"],"names":[],"mappings":"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"}