clauderipple 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.6.0 — 2026-09-28
+
+Both suggested in #8 by @artisthanbohee-del.
+
+### Added
+
+- **Updates from the tray and the CLI** (#39). The tray checks for a new version at start and
+  twice a day and offers it in its menu; **Check for Updates…** asks on demand. In a terminal:
+  `clauderipple update` (`--check` only reports). It updates the way ClaudeRipple was
+  installed — the install script again, or npm into the same prefix — and restarts the router
+  on the new version. The standalone app points to the releases page instead.
+- **Usage of each Claude subscription account** (#40): the five-hour and weekly limits of the
+  current Claude login and of every account added in ClaudeRipple, on the Health screen, in the
+  Claude provider's Accounts tab and in the tray menu. Read from the same endpoint Claude
+  Code's `/usage` uses, so an account that has not answered anything yet still has a number.
+- **The version in the tray's About box.**
+
+### Fixed
+
+- **Re-running the installer now restarts a router still running the old version.** Before,
+  the files changed but the router kept the old code until the next login — on Windows and
+  Linux always, since an unchanged task or service is not registered again.
+- **The tray survives updates.** Its Electron (~270MB) was fetched into the package folder, and
+  every update deleted it; on Windows a running tray could make the update fail. It now lives in
+  `~/.clauderipple/tray-runtime`, and the install scripts move an existing copy there instead of
+  fetching it again. An install made with plain `npm install -g` fetches it once more with
+  `clauderipple tray --install`.
+- **The tray installed from npm reports its own version**, not Electron's: its package manifest
+  carried none.
+
 ## 0.5.1 — 2026-09-28
 
 ### Fixed

package/README.ko.md

@@ -280,13 +280,15 @@ clauderipple tray
 Electron으로 도는데 용량이 270MB라 기본 설치에는 넣지 않았습니다. `clauderipple tray --install`이 한 번만
 받아 옵니다. 나머지 기능은 Electron 없이도 다 돕니다.
 
-**업데이트.**
+**업데이트.** 새 버전이 나오면 트레이가 알려 줍니다(**업데이트 확인…**). 터미널에서는:
 
 ```sh
-npm install -g clauderipple@latest
-clauderipple restart
+clauderipple update
 ```
 
+설치한 방식 그대로(설치 스크립트 또는 npm) 업데이트하고, 라우터를 새 버전으로 다시 시작합니다. 트레이용
+Electron은 업데이트해도 그대로 남습니다.
+
 선택 사항, Desktop 피커에 실제 이름을 띄우려면: **클라이언트 → Claude Desktop → 모델 피커 → 켜기**. 그다음 Claude
 Desktop을 완전히 종료했다가 다시 엽니다. 로컬 인증서를 사용자 범위로만 신뢰시키는데, 이때 macOS는 로그인 암호를
 묻고 Windows는 지문이 적힌 확인 창을 띄웁니다. Linux는 묻지 않고 NSS 데이터베이스에 등록합니다. ClaudeRipple은

package/README.md

@@ -328,13 +328,15 @@ clauderipple tray
 It runs on Electron, which is about 270MB and is therefore not installed by default.
 `clauderipple tray --install` fetches it once; everything else works without it.
 
-**Updating.**
+**Updating.** The tray offers a new version when there is one (**Check for Updates…**), or:
 
 ```sh
-npm install -g clauderipple@latest
-clauderipple restart
+clauderipple update
 ```
 
+It updates the way you installed — the install script again, or npm — and restarts the router
+on the new version. The tray's Electron is kept across updates.
+
 Optional, for real names in the Desktop picker: **Clients → Claude Desktop → Model
 picker → on**, then quit and reopen Claude Desktop. To trust the local certificate
 for your user only, macOS asks for your login password and Windows shows a

package/dist/app/dist/main.js

@@ -73,6 +73,23 @@ const STRINGS = {
         setupNeeded: "setup not finished",
         setupNeededDetail: "ClaudeRipple is installed but not set up yet",
         runSetup: "Finish setting up ClaudeRipple…",
+        claudeCurrent: "current login",
+        claudeUsage: (label, windows) => `Claude ${label} · ${windows}`,
+        window5h: "5h",
+        windowWeek: "weekly",
+        checkUpdates: "Check for Updates…",
+        updateAvailableItem: (v) => `Update to ClaudeRipple ${v}…`,
+        upToDate: (v) => `ClaudeRipple ${v} is the latest version.`,
+        updateAvailable: (latest, current) => `ClaudeRipple ${latest} is available (you have ${current}).`,
+        updateDetail: "The router restarts on the new version once requests in flight have finished. The tray reopens by itself.",
+        updateNow: "Update",
+        later: "Later",
+        updating: (v) => `Updating to ClaudeRipple ${v}…`,
+        updateDone: (v) => `Updated to ClaudeRipple ${v}`,
+        updateFailed: "The update did not finish",
+        updateCheckFailed: "Could not check for updates",
+        updatePackaged: "This is the standalone app. Download the new version from the releases page.",
+        updateCheckout: "This is a source checkout. Update it with git pull.",
     },
     ko: {
         healthy: "정상",
@@ -132,6 +149,23 @@ const STRINGS = {
         setupNeeded: "설정이 끝나지 않았습니다",
         setupNeededDetail: "설치는 됐지만 아직 설정하지 않았습니다",
         runSetup: "ClaudeRipple 설정 마치기…",
+        claudeCurrent: "현재 로그인",
+        claudeUsage: (label, windows) => `Claude ${label} · ${windows}`,
+        window5h: "5시간",
+        windowWeek: "주간",
+        checkUpdates: "업데이트 확인…",
+        updateAvailableItem: (v) => `새 버전 업데이트: ClaudeRipple ${v}…`,
+        upToDate: (v) => `최신 버전입니다: ClaudeRipple ${v}`,
+        updateAvailable: (latest, current) => `새 버전이 나왔습니다: ClaudeRipple ${latest} (지금 ${current})`,
+        updateDetail: "진행 중인 요청이 끝나면 라우터가 새 버전으로 다시 시작합니다. 트레이는 저절로 다시 열립니다.",
+        updateNow: "업데이트",
+        later: "나중에",
+        updating: (v) => `ClaudeRipple ${v} 업데이트 중…`,
+        updateDone: (v) => `ClaudeRipple ${v} 업데이트 완료`,
+        updateFailed: "업데이트를 마치지 못했습니다",
+        updateCheckFailed: "업데이트를 확인하지 못했습니다",
+        updatePackaged: "독립 실행 앱입니다. 릴리스 페이지에서 새 버전을 받으세요.",
+        updateCheckout: "소스 체크아웃입니다. git pull로 업데이트하세요.",
     },
 };
 let L = STRINGS.en;
@@ -223,7 +257,8 @@ async function poll() {
         last = null;
         lastError = e.message;
         downSince ??= Date.now();
-        if (!downNotified && Date.now() - downSince >= DOWN_NOTIFY_AFTER_MS) {
+        // An update restarts the router on purpose; that is not the outage the notification is for.
+        if (!downNotified && !updating && Date.now() - downSince >= DOWN_NOTIFY_AFTER_MS) {
             downNotified = true;
             notifyDown();
         }
@@ -390,13 +425,77 @@ function cliPaths() {
     return { node: process.execPath, env: { ELECTRON_RUN_AS_NODE: "1" }, cli };
 }
 function runCli(args) {
+    return runCliResult(args).then((r) => r.output);
+}
+function runCliResult(args) {
     const { node, env, cli } = cliPaths();
     return new Promise((resolve) => {
-        (0, node_child_process_1.execFile)(node, [cli, ...args], { env: { ...process.env, ...env, CLAUDERIPPLE_HOME: home } }, (err, stdout, stderr) => {
-            resolve(`${stdout}${stderr}${err ? `\n${err.message}` : ""}`.trim());
+        // An update prints npm's and the installer's own lines; the default 1MB buffer is not for that.
+        (0, node_child_process_1.execFile)(node, [cli, ...args], { env: { ...process.env, ...env, CLAUDERIPPLE_HOME: home }, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
+            resolve({ ok: !err, output: `${stdout}${stderr}${err ? `\n${err.message}` : ""}`.trim() });
         });
     });
 }
+let availableUpdate = null;
+let updating = false;
+const UPDATE_CHECK_MS = 12 * 60 * 60 * 1000;
+async function checkForUpdate() {
+    const r = await runCliResult(["update", "--check", "--json"]);
+    try {
+        const check = JSON.parse(r.output.split("\n").pop() ?? "");
+        availableUpdate = check.newer ? check : null;
+        render();
+        return check;
+    }
+    catch {
+        return null;
+    }
+}
+async function checkUpdatesInteractive() {
+    const check = await checkForUpdate();
+    if (!check) {
+        await electron_1.dialog.showMessageBox({ type: "warning", message: L.updateCheckFailed });
+        return;
+    }
+    if (!check.newer) {
+        await electron_1.dialog.showMessageBox({ message: L.upToDate(check.current) });
+        return;
+    }
+    await offerUpdate(check);
+}
+async function offerUpdate(check) {
+    if (check.kind === "packaged") {
+        const choice = await electron_1.dialog.showMessageBox({ message: L.updateAvailable(check.latest ?? "?", check.current), detail: L.updatePackaged, buttons: [L.updateNow, L.later], defaultId: 0, cancelId: 1 });
+        if (choice.response === 0)
+            void electron_1.shell.openExternal("https://github.com/PBJ-2/clauderipple/releases/latest");
+        return;
+    }
+    if (check.kind === "checkout") {
+        await electron_1.dialog.showMessageBox({ message: L.updateAvailable(check.latest ?? "?", check.current), detail: L.updateCheckout });
+        return;
+    }
+    const choice = await electron_1.dialog.showMessageBox({ message: L.updateAvailable(check.latest ?? "?", check.current), detail: L.updateDetail, buttons: [L.updateNow, L.later], defaultId: 0, cancelId: 1 });
+    if (choice.response !== 0 || updating)
+        return;
+    updating = true;
+    render();
+    const version = check.latest ?? "";
+    if (electron_1.Notification.isSupported())
+        new electron_1.Notification({ title: "ClaudeRipple", body: L.updating(version) }).show();
+    const r = await runCliResult(["update"]);
+    updating = false;
+    if (!r.ok) {
+        render();
+        await electron_1.dialog.showMessageBox({ type: "warning", message: L.updateFailed, detail: r.output.slice(-4000) });
+        return;
+    }
+    availableUpdate = null;
+    if (electron_1.Notification.isSupported())
+        new electron_1.Notification({ title: "ClaudeRipple", body: L.updateDone(version) }).show();
+    // A new tray from the new files, then this one goes.
+    await runCliResult(["tray"]);
+    electron_1.app.quit();
+}
 // Offer setup only when there is no working installation at all. A developer who runs the router
 // from a source checkout keeps that; switching to the app's bundled runtime is a menu action.
 function needsSetup() {
@@ -436,6 +535,14 @@ async function promptForSetup() {
     if (choice.response === 0)
         await setup();
 }
+/** "5h 14% · weekly 10%", the same reading the dashboard gives. */
+function windowsText(quota) {
+    const limits = quota?.rate_limits;
+    return [limits?.primary, limits?.secondary]
+        .filter((w) => !!w && typeof w.used_percent === "number")
+        .map((w) => `${w.window_minutes === 300 ? L.window5h : L.windowWeek} ${Math.round(w.used_percent)}%`)
+        .join(" · ");
+}
 function render() {
     if (!tray)
         return;
@@ -462,9 +569,18 @@ function render() {
         : unconfigured
             ? L.setupNeededDetail
             : L.downNotifyTitle;
+    // One line per Claude subscription account, current login first (#40).
+    const claudeLines = (s?.claude?.accounts ?? [])
+        .map((account) => ({ account, windows: windowsText(account.quota) }))
+        .filter(({ windows }) => windows)
+        .map(({ account, windows }) => ({ label: L.claudeUsage(account.id === "current" ? L.claudeCurrent : account.label, windows), click: () => void openDashboard() }));
     const template = [
         { label: headline, click: () => void openDashboard() },
         ...(detail ? [{ label: detail, click: () => void openDashboard() }] : []),
+        ...claudeLines,
+        ...(availableUpdate
+            ? [{ label: updating ? L.updating(availableUpdate.latest ?? "") : L.updateAvailableItem(availableUpdate.latest ?? ""), enabled: !updating, click: () => void offerUpdate(availableUpdate) }]
+            : []),
         { type: "separator" },
         // Enabled even when the router is down: it is started first, then the page is opened.
         { label: L.openDashboard, click: () => void openDashboard() },
@@ -485,7 +601,8 @@ function render() {
             : []),
         { label: L.connectClaudeSubscription, click: async () => void electron_1.dialog.showMessageBox({ message: await runCli(["claude-login"]) }) },
         { type: "separator" },
-        { label: L.about, click: () => void electron_1.dialog.showMessageBox({ title: "ClaudeRipple", message: "ClaudeRipple", detail: L.aboutDetail }) },
+        { label: L.checkUpdates, enabled: !updating, click: () => void checkUpdatesInteractive() },
+        { label: L.about, click: () => void electron_1.dialog.showMessageBox({ title: "ClaudeRipple", message: `ClaudeRipple ${electron_1.app.getVersion()}`, detail: L.aboutDetail }) },
         { label: L.quit, role: "quit" },
     ];
     tray.setContextMenu(electron_1.Menu.buildFromTemplate(template));
@@ -511,6 +628,9 @@ electron_1.app.whenReady().then(() => {
     setInterval(() => void poll(), POLL_MS);
     if (needsSetup())
         void promptForSetup();
+    // Not at the very start: a tray opened at login shares the first minute with everything else.
+    setTimeout(() => void checkForUpdate(), 60_000);
+    setInterval(() => void checkForUpdate(), UPDATE_CHECK_MS);
 });
 // A tray-only app owns no windows; without this Electron would quit the moment a dialog closes.
 electron_1.app.on("window-all-closed", () => {

package/dist/app/package.json

@@ -1,4 +1,5 @@
 {
   "private": true,
+  "version": "0.6.0",
   "type": "commonjs"
 }

package/dist/cli/src/index.js

@@ -22,7 +22,8 @@ import { codexOff, codexOn } from "./codex.js";
 import { ingressModels } from "../../router/src/ingress/models.js";
 import { claudeLogin, claudeLogout, desktopClaudeCodeDirs } from "./claude-auth.js";
 import { openBrowser } from "./browser.js";
-import { installTrayRuntime, startTray } from "./tray.js";
+import { electronPath, installTrayRuntime, startTray } from "./tray.js";
+import { installKind, isNewer, latestVersion, PACKAGE, runUpdate } from "./update.js";
 import { ClaudeOAuthSession } from "../../router/src/providers/claude-oauth.js";
 function setPickerEnabled(enabled) {
     const file = configPath();
@@ -119,6 +120,17 @@ function starterConfig(port) {
         log: DEFAULTS.log,
     }, null, 2) + "\n";
 }
+/** The version the router on this admin port reports, or null when it does not answer. */
+async function runningVersion(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/status`, { signal: AbortSignal.timeout(10_000) });
+        const version = res.ok ? (await res.json()).version : null;
+        return typeof version === "string" ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
 function proxyUrlFor(port) {
     return `http://127.0.0.1:${port}`;
 }
@@ -185,6 +197,16 @@ async function install() {
     // its logon trigger, so the router would only appear after the next sign-in. Start it either way.
     const started = startAgent();
     console.log(started === "failed" ? `✗ could not start the router (${supervisorName()})` : `✓ router ${started === "already-running" ? "already running" : "started"}`);
+    // Running the installer again is how an update arrives, and it replaces files, not the process:
+    // a router left alone keeps serving the old code until the next login. Restart one that
+    // answers with another version.
+    if (started === "already-running") {
+        const running = await runningVersion(adminPort(cfg));
+        if (running && running !== VERSION) {
+            console.log(`  the running router is ${running}; restarting it on ${VERSION}`);
+            console.log(describeRestart(restartAgent({ onProgress: (m) => console.log(`  ${m}`) })));
+        }
+    }
     const p = await probeWithRetry({ host: cfg.listen.host, port: cfg.listen.port, caPem: caPath, upstream: cfg.upstream });
     console.log(p.ok ? `✓ end-to-end probe passed (${p.detail}, ${p.ms}ms)` : `✗ probe failed: ${p.detail}`);
     if (!p.ok) {
@@ -342,6 +364,46 @@ function logs() {
         offset = size;
     });
 }
+/**
+ * `update --check [--json]` reports; `update` installs the latest version the way this copy was
+ * installed (update.ts) and fetches the tray's Electron again if the old copy had it.
+ */
+async function update() {
+    const kind = installKind(installedRuntime);
+    // CLAUDERIPPLE_PACKAGE names what to install instead of the registry's latest (a tarball, say).
+    const override = process.env.CLAUDERIPPLE_PACKAGE;
+    const latest = override ? null : await latestVersion();
+    const newer = latest ? isNewer(latest, VERSION) : true;
+    if (flag("check")) {
+        if (flag("json"))
+            console.log(JSON.stringify({ current: VERSION, latest, newer, kind: kind.kind }));
+        else
+            console.log(newer ? `ClaudeRipple ${latest} is available (this is ${VERSION}). Update with: clauderipple update` : `ClaudeRipple ${VERSION} is the latest version`);
+        return;
+    }
+    if (kind.kind !== "script" && kind.kind !== "npm") {
+        process.exitCode = 1;
+        console.log(kind.kind === "packaged" ? "This is the standalone app. Download the new version from https://github.com/PBJ-2/clauderipple/releases"
+            : kind.kind === "checkout" ? "This is a source checkout. Update it with git pull."
+                : `ClaudeRipple is installed at ${kind.root}, which is not a global npm install. Update it the way you installed it.`);
+        return;
+    }
+    if (!newer && !flag("force")) {
+        console.log(`✓ ClaudeRipple ${VERSION} is the latest version`);
+        return;
+    }
+    const hadTray = electronPath() !== null;
+    const spec = override ?? `${PACKAGE}@${latest}`;
+    console.log(`Updating ClaudeRipple ${VERSION} → ${latest ?? spec} (${kind.kind === "script" ? "install script" : "npm"}, ${kind.prefix})…`);
+    const result = runUpdate(kind, installedRuntime, spec);
+    if (result.ok && hadTray) {
+        // The new files decide where Electron lives; ask them, not this process's copy.
+        execFileSync(installedRuntime.node, [installedRuntime.cli, "tray", "--install"], { env: { ...process.env, ...installedRuntime.env }, stdio: "inherit" });
+    }
+    console.log(result.message);
+    if (!result.ok)
+        process.exitCode = 1;
+}
 function help() {
     console.log(`clauderipple <command>
 
@@ -353,6 +415,7 @@ function help() {
   config            print the config file path
   ui                open the dashboard in your browser
   tray [--install]  start the menu-bar / tray app (--install fetches Electron, ~270MB, once)
+  update [--check]  install the latest version the way this one was installed (--check only reports)
   login             add a ChatGPT account (opens your browser; run again to add another — they take turns when one runs out)
   logout            forget every ChatGPT account added with "login" (the Codex CLI's own login is left alone)
   claude-login      connect a Claude subscription in the browser (--setup-token: via \`claude setup-token\`; --manual: paste the code)
@@ -492,6 +555,9 @@ try {
         case "ui":
             ui();
             break;
+        case "update":
+            await update();
+            break;
         case "tray": {
             const result = args.includes("--install") ? installTrayRuntime() : startTray();
             console.log(result.message);

package/dist/cli/src/tray.js

@@ -9,21 +9,34 @@ import { createRequire } from "node:module";
 import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { homeDir } from "../../router/src/config.js";
 import { runtime } from "./runtime.js";
 /** Electron version to fetch on request. Kept in step with the one the app is developed against. */
 const ELECTRON_RANGE = "^38.1.0";
-/** The Electron executable installed alongside us, or null when the optional dependency is absent. */
-export function electronPath() {
+/**
+ * Where Electron is fetched to: ClaudeRipple's home, not the package. Until 0.6 it went into the
+ * installed package's own node_modules, and every update replaced that folder — measured
+ * 2026-09-28, `npm install -g` of another version left no trace of it, so the tray was gone after
+ * each update, and on Windows a running tray held electron.exe inside the folder being replaced.
+ */
+export function trayRuntimeDir() {
+    return path.join(homeDir(), "tray-runtime");
+}
+/** The electron package exports the path to its binary as its module value. */
+function resolveElectron(from) {
     try {
-        const require = createRequire(import.meta.url);
-        // The electron package exports the path to its binary as its module value.
-        const value = require("electron");
+        const value = createRequire(from)("electron");
         return typeof value === "string" && fs.existsSync(value) ? value : null;
     }
     catch {
         return null;
     }
 }
+/** The Electron executable to run the tray with, or null when none has been fetched. */
+export function electronPath() {
+    // A checkout or an install from before 0.6 resolves it next to us.
+    return resolveElectron(path.join(trayRuntimeDir(), "package.json")) ?? resolveElectron(import.meta.url);
+}
 /**
  * Our environment without ELECTRON_RUN_AS_NODE, so Electron starts as the tray rather than as a
  * plain Node process. The variable has to be removed, not emptied: macOS Electron reads an empty
@@ -87,8 +100,9 @@ export function installTrayRuntime() {
     const cli = npmCli();
     if (!cli)
         return { ok: false, message: `found no npm next to ${process.execPath}; install Electron yourself: npm install electron` };
-    const target = runtime().repo;
-    const result = spawnSync(process.execPath, [cli, "install", "--no-save", "--loglevel", "error", `electron@${ELECTRON_RANGE}`], {
+    const target = trayRuntimeDir();
+    fs.mkdirSync(target, { recursive: true });
+    const result = spawnSync(process.execPath, [cli, "install", "--prefix", target, "--no-package-lock", "--loglevel", "error", `electron@${ELECTRON_RANGE}`], {
         cwd: target,
         stdio: "inherit",
     });

package/dist/cli/src/update.js

@@ -0,0 +1,104 @@
+// `clauderipple update`: bring this installation to the latest published version, the way it
+// was installed.
+//
+// Until now an update meant running the install command again by hand, and the tray could not
+// offer it (#39). What "again" means depends on how ClaudeRipple arrived:
+//   * The install scripts put it under their own prefix (~/.clauderipple by default) with their own
+//     command shims — a wrapper naming the Node they downloaded, and on Windows no .ps1. A plain
+//     `npm install -g` would put npm's default shims back, which find no Node on a machine where
+//     the script's Node is the only one. So a script install is updated by running its script.
+//   * An `npm install -g` is updated by npm, into the same prefix.
+//   * A packaged app or a source checkout is not updated from here.
+// Either way `install` runs afterwards from the new files; it restarts a router still running
+// the old version, which re-running the installer never did before.
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { windowsPowerShellEnv } from "./windows-powershell.js";
+export const PACKAGE = "clauderipple";
+const SCRIPT_BASE = "https://raw.githubusercontent.com/PBJ-2/clauderipple/main/scripts";
+/** Numeric x.y.z comparison; a pre-release suffix is ignored. */
+export function isNewer(latest, current) {
+    const parse = (v) => v.replace(/^v/, "").split("-")[0].split(".").map((n) => Number(n) || 0);
+    const a = parse(latest);
+    const b = parse(current);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    }
+    return false;
+}
+/** The default prefix of both install scripts, or the one they were told to use. */
+export function scriptPrefix(env = process.env, home = os.homedir()) {
+    return env.CLAUDERIPPLE_PREFIX || path.join(home, ".clauderipple");
+}
+/**
+ * How the running copy was installed, read from where its files are. A global npm package lives
+ * at <prefix>/lib/node_modules/<name> on macOS and Linux and <prefix>\node_modules\<name> on Windows.
+ */
+export function installKind(rt, opts = {}) {
+    if (rt.packaged)
+        return { kind: "packaged" };
+    if (rt.cli.endsWith(".ts"))
+        return { kind: "checkout" };
+    const p = (opts.platform ?? process.platform) === "win32" ? path.win32 : path.posix;
+    const root = rt.repo;
+    const modules = p.dirname(root);
+    if (p.basename(modules) !== "node_modules")
+        return { kind: "unknown", root };
+    const parent = p.dirname(modules);
+    const prefix = (opts.platform ?? process.platform) === "win32" ? parent : p.basename(parent) === "lib" ? p.dirname(parent) : null;
+    if (!prefix)
+        return { kind: "unknown", root };
+    const same = (a, b) => (opts.platform ?? process.platform) === "win32" ? p.resolve(a).toLowerCase() === p.resolve(b).toLowerCase() : p.resolve(a) === p.resolve(b);
+    return same(prefix, scriptPrefix(opts.env, opts.home)) ? { kind: "script", prefix } : { kind: "npm", prefix };
+}
+/** The version npm would install now. */
+export async function latestVersion(fetchImpl = fetch) {
+    const res = await fetchImpl(`https://registry.npmjs.org/${PACKAGE}/latest`, { signal: AbortSignal.timeout(10_000), headers: { accept: "application/json" } });
+    if (!res.ok)
+        throw new Error(`npm registry answered HTTP ${res.status}`);
+    const version = (await res.json()).version;
+    if (typeof version !== "string")
+        throw new Error("npm registry answered without a version");
+    return version;
+}
+/** The npm that came with the Node running us, as a script that same Node can run. */
+function npmCli() {
+    const candidates = [
+        path.resolve(path.dirname(process.execPath), "../lib/node_modules/npm/bin/npm-cli.js"),
+        path.resolve(path.dirname(process.execPath), "node_modules/npm/bin/npm-cli.js"),
+    ];
+    return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
+}
+/**
+ * Installs `spec` over this installation and runs `install` from the new files. Output goes to
+ * our stdout as it happens, so the tray's dialog and a terminal show the installer's own lines.
+ */
+export function runUpdate(target, rt, spec) {
+    const env = { ...process.env, CLAUDERIPPLE_PREFIX: target.prefix, CLAUDERIPPLE_PACKAGE: spec };
+    if (target.kind === "script") {
+        // A local path stands in for the published script when checking an update before release.
+        const script = process.env.CLAUDERIPPLE_INSTALLER;
+        const result = process.platform === "win32"
+            ? spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script ? `& ${psQuote(script)}` : `irm ${SCRIPT_BASE}/install.ps1 | iex`], { env: { ...windowsPowerShellEnv(), ...env }, stdio: "inherit", windowsHide: true })
+            : spawnSync("sh", ["-c", script ? `sh ${shQuote(script)}` : `curl -fsSL ${SCRIPT_BASE}/install.sh | sh`], { env, stdio: "inherit" });
+        // The script ends by running `install` itself.
+        return result.status === 0 ? { ok: true, message: "✓ updated" } : { ok: false, message: `the installer exited with ${result.status ?? result.signal}` };
+    }
+    const npm = npmCli();
+    if (!npm)
+        return { ok: false, message: `found no npm next to ${process.execPath}; update with: npm install -g ${PACKAGE}@latest` };
+    const installed = spawnSync(process.execPath, [npm, "install", "--global", "--prefix", target.prefix, "--loglevel", "error", spec], { env, stdio: "inherit" });
+    if (installed.status !== 0)
+        return { ok: false, message: `npm could not install ${spec}` };
+    const setup = spawnSync(rt.node, [rt.cli, "install"], { env: { ...process.env, ...rt.env }, stdio: "inherit" });
+    return setup.status === 0 ? { ok: true, message: "✓ updated" } : { ok: false, message: "the new version is installed, but `clauderipple install` did not finish" };
+}
+function psQuote(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/router/src/admin.js

@@ -48,6 +48,32 @@ const MIME = {
     ".png": "image/png",
     ".ico": "image/x-icon",
 };
+/** Claude usage is looked up only where a Claude subscription provider is configured. */
+function hasClaudeSubscription(cfg) {
+    return Object.values(cfg.providers).some((p) => p.type === "anthropic" && p.auth === "claude-code");
+}
+/**
+ * One row per Claude account with a known usage, current login first. Labels only: the status is
+ * polled every few seconds and has no use for an email address.
+ */
+async function claudeAccountUsage(deps) {
+    let usage;
+    try {
+        usage = (await deps.claudeUsage?.()) ?? {};
+    }
+    catch {
+        return [];
+    }
+    const rows = [];
+    if (usage.current)
+        rows.push({ id: "current", label: "Current Claude login", quota: usage.current });
+    for (const account of listClaudeAccounts(homeDir())) {
+        const quota = usage[account.id];
+        if (quota)
+            rows.push({ id: account.id, label: account.label, quota });
+    }
+    return rows;
+}
 const ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high", "max"];
 const CHATGPT_DEFAULT_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 let chatgptLogin = { running: false };
@@ -317,6 +343,7 @@ async function buildStatus(deps, opts = {}) {
         // `quota` stays one snapshot per provider (the account in use) for the readers that want one
         // number; `accounts` is the per-account view, read after the refresh above so it is as fresh.
         chatgpt: { ...chatgpt, signedIn, accounts: chatgpt.accounts?.() ?? {}, ...(stale ? { stale: true, staleReason: staleReasons } : {}) },
+        ...(deps.claudeUsage && hasClaudeSubscription(cfg) ? { claude: { accounts: await claudeAccountUsage(deps) } } : {}),
         // Only present for providers that declare a pool; a provider with one credential has nothing
         // to report and would only add a row that never changes.
         credentials: deps.credentials?.() ?? {},
@@ -1236,9 +1263,12 @@ export function startAdmin(deps) {
             // ClaudeRipple accounts can be renamed or removed by their local opaque id.
             if (pathname === "/api/claude-accounts" && method === "GET") {
                 const source = claudeAuthStore(deps).describeSource();
+                let usage = {};
+                if (hasClaudeSubscription(deps.config()))
+                    usage = (await deps.claudeUsage?.().catch(() => null)) ?? {};
                 sendJson(res, 200, {
-                    current: source ? { id: "current", label: "Current Claude login", source, external: true } : null,
-                    accounts: listClaudeAccounts(homeDir()),
+                    current: source ? { id: "current", label: "Current Claude login", source, external: true, ...(usage.current ? { quota: usage.current } : {}) } : null,
+                    accounts: listClaudeAccounts(homeDir()).map((account) => (usage[account.id] ? { ...account, quota: usage[account.id] } : account)),
                 });
                 return;
             }

package/dist/router/src/index.js

@@ -153,6 +153,7 @@ proxy
         credentials: () => proxy.credentialHealth(),
         picker: () => ({ enabled: !!store.get().picker?.enabled, hosts: terminateHosts(store.get()).slice(1), last: proxy.lastPickerInjection }),
         observedClaudeCodeAuth,
+        claudeUsage: () => proxy.claudeUsage.snapshot(),
         shutdown: () => beginDrain("shutdown requested"),
     });
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);

package/dist/router/src/providers/anthropic-usage.js

@@ -0,0 +1,98 @@
+// How much of each Claude subscription account's limits is used, for the dashboard and the tray.
+//
+// Response headers would only describe the account that last answered, so an idle second account
+// would never show a number. Claude Code's own `/usage` asks `GET /api/oauth/usage` with the
+// account's OAuth headers instead, and so does this. Shape measured 2026-09-28 (CLI 2.1.281):
+//   {"five_hour": {"utilization": 14.0, "resets_at": "2026-09-28T08:30:00.581181+00:00", …},
+//    "seven_day": {"utilization": 10.0, "resets_at": "…"}, "seven_day_opus": null, …}
+// `utilization` is a percentage. It is mapped onto the Codex snapshot shape
+// (`rate_limits.primary/secondary` with `used_percent`, `window_minutes`, `reset_at` in seconds)
+// so the GUI and the tray read one format for every account.
+const FIVE_HOURS = 5 * 60;
+const WEEK = 7 * 24 * 60;
+export function claudeUsageFromBody(body) {
+    const b = body;
+    const win = (w, minutes) => {
+        if (!w || typeof w.utilization !== "number" || !Number.isFinite(w.utilization))
+            return null;
+        const out = { used_percent: w.utilization, window_minutes: minutes };
+        const at = typeof w.resets_at === "string" ? Date.parse(w.resets_at) : NaN;
+        if (Number.isFinite(at))
+            out.reset_at = Math.round(at / 1000);
+        return out;
+    };
+    const primary = win(b?.five_hour, FIVE_HOURS);
+    const secondary = win(b?.seven_day, WEEK);
+    if (!primary && !secondary)
+        return null;
+    return { type: "claude.usage", rate_limits: { primary: primary ?? secondary, secondary: primary ? secondary : null }, at: Date.now() };
+}
+/**
+ * Per-account snapshots, fetched at most once per `ttlMs` per account. The GUI polls the status
+ * every five seconds and the tray as often; a limit that moves by a percent in minutes does not
+ * need more. A failed lookup keeps the last good numbers rather than blanking them.
+ */
+export class ClaudeUsage {
+    last = new Map();
+    inFlight = null;
+    fetchedAt = Number.NEGATIVE_INFINITY;
+    source;
+    opts;
+    constructor(source, opts) {
+        this.source = source;
+        this.opts = opts;
+    }
+    /** Snapshots by account owner id ("current" for the Claude Code login). */
+    snapshot() {
+        const now = (this.opts.now ?? Date.now)();
+        if (now - this.fetchedAt < (this.opts.ttlMs ?? 5 * 60_000))
+            return Promise.resolve(Object.fromEntries(this.last));
+        this.inFlight ??= this.fetchAll().finally(() => {
+            this.fetchedAt = (this.opts.now ?? Date.now)();
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    async fetchAll() {
+        let credentials;
+        try {
+            credentials = await this.source.credentials();
+        }
+        catch (e) {
+            this.opts.warn?.(`claude usage: no credentials: ${e.message}`);
+            return Object.fromEntries(this.last);
+        }
+        await Promise.all(credentials.map(async (credential) => {
+            const owner = credential.ownerId ?? credential.id;
+            const snapshot = await this.fetchOne(credential);
+            if (snapshot)
+                this.last.set(owner, snapshot);
+        }));
+        // An account that was removed must not keep its old numbers on the screen.
+        const owners = new Set(credentials.map((c) => c.ownerId ?? c.id));
+        for (const owner of [...this.last.keys()])
+            if (!owners.has(owner))
+                this.last.delete(owner);
+        return Object.fromEntries(this.last);
+    }
+    async fetchOne(credential) {
+        const owner = (credential.ownerId ?? credential.id).slice(0, 8);
+        try {
+            const res = await (this.opts.fetch ?? fetch)(`https://${this.opts.upstream()}/api/oauth/usage`, {
+                method: "GET",
+                headers: { ...credential.headers, accept: "application/json" },
+                signal: AbortSignal.timeout(this.opts.timeoutMs ?? 5000),
+            });
+            if (!res.ok) {
+                // The status alone: the body of an auth failure is not worth the risk of echoing.
+                this.opts.warn?.(`claude usage ${owner}: HTTP ${res.status}`);
+                return null;
+            }
+            return claudeUsageFromBody(await res.json());
+        }
+        catch (e) {
+            this.opts.warn?.(`claude usage ${owner}: ${e.message}`);
+            return null;
+        }
+    }
+}

package/dist/router/src/proxy.js

@@ -35,6 +35,7 @@ import { injectPickerModels, isBootstrapPath } from "./picker.js";
 import { ResponseUsageTap } from "./requestlog.js";
 import { credentialHeaderValues, redactErrorText, redactHeaders } from "./redact.js";
 import { ClaudeAccountAuthPool } from "./providers/anthropic-account-pool.js";
+import { ClaudeUsage } from "./providers/anthropic-usage.js";
 import { dropForeignThinking } from "./thinking.js";
 const MAX_BODY = 64 * 1024 * 1024;
 const HOP_BY_HOP = new Set(["connection", "keep-alive", "proxy-connection", "transfer-encoding", "upgrade", "host", "content-length"]);
@@ -177,6 +178,8 @@ export class Proxy {
     chatgptAdapters = new Map();
     openaiAdapters = new Map();
     claudeAccounts;
+    /** Each Claude subscription account's usage, for the admin status (never a token). */
+    claudeUsage;
     deps;
     /**
      * Cooldowns, quarantines and conversation stickiness for provider credentials. In memory: a
@@ -282,6 +285,10 @@ export class Proxy {
             log: deps.log,
             ...(deps.observedClaudeCodeAuth ? { observed: deps.observedClaudeCodeAuth } : {}),
         });
+        this.claudeUsage = new ClaudeUsage(this.claudeAccounts, {
+            upstream: () => this.deps.config().upstream,
+            warn: (message) => deps.log.warn(message),
+        });
         this.httpServer = http.createServer({ maxHeaderSize: 64 * 1024 }, (req, res) => {
             void this.handle(req, res);
         });

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.5.1";
+export const VERSION = "0.6.0";

package/dist/ui/app.js

@@ -335,6 +335,16 @@ function renderHealthProviders() {
     ].filter(Boolean));
     const quota = quotaLine(name);
     if (quota) line.appendChild(el("div", { class: "small", text: quota }));
+    // Claude subscription accounts, one line each: the current login and every account added here.
+    // Before the config has loaded the rows come from the status, which names the sign-in source
+    // rather than the auth mode.
+    if (provider.type === "anthropic" && (provider.auth === "claude-code" || (live && live.authSource))) {
+      const usage = ((status && status.claude && status.claude.accounts) || [])
+        .map((account) => ({ account, text: chatgptQuotaText(account.quota) }))
+        .filter(({ text }) => text)
+        .map(({ account, text }) => el("div", { text: `${claudeAccountLabel(account)} · ${text}` }));
+      if (usage.length) line.appendChild(el("div", { class: "small account-usage" }, usage));
+    }
     const pool = credentialLine(name);
     if (pool) line.appendChild(pool);
     return line;
@@ -1002,11 +1012,22 @@ async function saveAnthropicRotation(name, provider, enabled, control, message)
   } finally { control.disabled = false; }
 }
 
+/** The current login is named by the router in English; everything else carries the user's own label. */
+function claudeAccountLabel(account) {
+  return account.id === "current" ? t("providers.anthropicCurrent") : account.label;
+}
+
+/** "5h 14% · weekly 10%" under a Claude account, or nothing while its usage is unknown. */
+function claudeQuotaNode(account) {
+  const text = chatgptQuotaText(account && account.quota);
+  return text ? el("p", { class: "small account-quota", text }) : null;
+}
+
 function renderClaudeAccountRows(target, data, name, generation) {
   if (generation !== providerDetailGeneration) return;
   const rows = [];
   if (data.current) rows.push(el("article", { class: "account-card current" }, [
-    el("div", { class: "account-card-copy" }, [el("strong", { text: data.current.label }), el("span", { class: "small", text: anthropicSourceText(data.current.source) }), hint(t("providers.currentAccountHelp"))]),
+    el("div", { class: "account-card-copy" }, [el("strong", { text: data.current.label }), el("span", { class: "small", text: anthropicSourceText(data.current.source) }), claudeQuotaNode(data.current), hint(t("providers.currentAccountHelp"))].filter(Boolean)),
     el("span", { class: "badge ok", text: t("providers.anthropicCurrent") }),
   ]));
   for (const account of Array.isArray(data.accounts) ? data.accounts : []) {
@@ -1031,7 +1052,7 @@ function renderClaudeAccountRows(target, data, name, generation) {
       actions.unshift(reauth);
     }
     rows.push(el("article", { class: "account-card" }, [
-      el("div", { class: "account-card-copy" }, [el("strong", { text: account.label }), account.email && account.email !== account.label ? el("span", { class: "small", text: account.email }) : null, hint(t("providers.addedAccountHelp"))]),
+      el("div", { class: "account-card-copy" }, [el("strong", { text: account.label }), account.email && account.email !== account.label ? el("span", { class: "small", text: account.email }) : null, claudeQuotaNode(account), hint(t("providers.addedAccountHelp"))].filter(Boolean)),
       el("span", { class: `badge ${unavailable ? "bad" : "ok"}`, text: unavailable ? t("providers.anthropicReauth") : t("pool.ready") }),
       el("div", { class: "account-card-actions" }, actions),
     ]));

package/dist/ui/style.css

@@ -355,6 +355,7 @@ label.check input { width: auto; }
 button.btn.compact { padding: 4px 9px; font-size: 14px; }
 .provider-status { display: grid; grid-template-columns: minmax(120px, 1fr) auto; gap: 8px; align-items: center; padding: 7px 0; border-bottom: 1px solid var(--border); }
 .provider-status:last-child { border-bottom: none; }
+.provider-status .account-usage { grid-column: 1 / -1; display: grid; gap: 2px; }
 .empty-card { color: var(--muted); padding: 28px 16px; border: 1px dashed var(--border); border-radius: 8px; text-align: center; }
 .toast-raw { margin-top: 5px; color: var(--muted); font: 10.5px/1.35 var(--mono); word-break: break-word; }
 .modal-backdrop { position: fixed; inset: 0; z-index: 20; display: grid; place-items: center; padding: 18px; background: color-mix(in srgb, #000 38%, transparent); }

package/docs/ARCHITECTURE.md

@@ -836,6 +836,8 @@ what we do not have yet — so that adding a provider does not start with readin
 | The same relay 403 kept reaching the user after that fix, because it was the wrong layer: DeepSeek runs on `openai-compatible`, whose adapter was **never** retried at all — the in-turn retry lives only in the anthropic-compatible wire path (`nextCredential`), and `credentialsOf` gives a translated provider exactly one credential and no fallback. So a relay hiccup had nowhere to go but the user (2026-09-21, root cause of the day's repeated "authentication failed") | Every translated adapter retries the `fetch` **before** any status or byte is written, so the turn is still replaceable (§4 "the first byte commits the turn"). `fetchWithRetry` retries only `transient` verdicts — connect failures, 5xx, and a 403 reporting a broken upstream — to the ceiling of 10 attempts the CLI itself uses, with a 250ms→2s backoff. A 401/429 is **not** retried: the adapter holds one credential, so asking the key that just refused the identical request again only delays the error. `classify` is reused for the judgement, with `kind === "transient"` narrowing a pool's answer to an adapter's. |
 | Workers on muse-spark-1.3 "stalled for minutes, then died": 84 of 1,815 turns (2026-09-18..22) waited a median 58s — five exactly 300s — and then the upstream closed the stream with **no** `response.completed`, no usage, no text. Both translated adapters finished such a stream as `end_turn` with whatever had arrived (the ChatGPT one by a comment saying so), so Claude Code received an empty, successful turn, did not retry, and the subagent ended with nothing. Same shape on `chatgpt` (gpt-6-astra, 12 turns, median 105s) and DeepSeek. A non-streaming failure was likewise answered 200 with the fragment | A turn is finished only when the vendor says so: `response.completed`/`response.incomplete` on Responses, a `finish_reason` or `[DONE]` on Chat. A stream that closes without one, or breaks mid-read, ends in an SSE `overloaded_error` — the one mid-stream error Claude Code retries on its own (CLI 2.1.278 matches `"type":"overloaded_error"` in the message; `api_error` is final). Non-streaming turns answer 529 with the same error, and the request record says the turn failed. The upstream stall itself is the vendor's; what must not happen here is turning it into an answer. |
 | A session switched from gpt-6-astra to claude-opus-5-5 failed every turn with `400 messages.2.content.0.thinking: each thinking block must contain thinking`: the translated adapters hand the CLI reasoning as `thinking` blocks with no signature (and no text when the reasoning item had no summary), the CLI keeps them, and passthrough replayed them to Anthropic (2026-09-28) | Before a request reaches Anthropic (`PASS` and the account-pool provider), assistant `thinking` blocks without a signature are dropped (`thinking.ts`) — Anthropic's own always carry one — and a turn left empty goes with them. Passthrough stays byte-exact when there is nothing to drop. |
+| Re-running the installer — the documented update — replaced the files and left the router running the old code: `install` treats a running router as done, and on Windows and Linux an unchanged supervisor definition is not re-registered, so nothing restarted it until the next login (found 2026-09-28 while building `update`; the tray's own restart covered only the packaged app) | `install` asks a router that is already running for its version and restarts one that differs. Measured in the Windows 11 VM: 0.5.1 running, installer run with 0.6.0 → "restarting it on 0.6.0", status 0.6.0. |
+| The tray's Electron (~270MB) was fetched into the installed package's own `node_modules`, and `npm install -g` of any other version deleted it with the old files (measured 2026-09-28): every update silently took the tray away, and on Windows a running tray held `electron.exe` inside the folder npm had to replace | Electron lives in `<home>/tray-runtime`, outside anything an update replaces. Both install scripts move one found in the old place there before installing (Windows first stops a tray running from it, and starts it again after setup) — checked on macOS and in the VM with a locked `electron.exe`. |
 
 ## 6. Blocked paths (measured, do not retry)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Use GPT (ChatGPT Plus/Pro), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [