clauderipple 0.5.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 0.7.0 — 2026-09-29
+
+### Added
+
+- **Worker tools** (`cli.limitWorkerTools`, off by default; a toggle in the dashboard). Generated
+  workers get only the read, edit, run, search and skill tools instead of inheriting every MCP
+  server and plugin tool of the session. One worker's first request fell from 32,942 to 8,823
+  tokens. Such a worker cannot use a browser or the iOS Simulator; keep those in an agent file of
+  your own.
+- **Images from the ChatGPT subscription.** `clauderipple image "<prompt>" -o file.png`, with
+  `--aspect square|landscape|portrait`, `--transparent`, `--format` and `--ref FILE` for reference
+  images. Underneath is `POST /api/image` on the admin port, which answers with the image itself.
+  Generated workers are told the `curl` form, so a worker with only Bash can make one. The backend
+  chooses resolution and quality; about 30 seconds an image.
+
+## 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

@@ -144,6 +144,13 @@ ClaudeRipple이 Claude에 하는 일은 작고 확인할 수 있습니다. Claud
 Claude 모델이 이름 그대로 뜹니다. Claude Code 로그인이나 Anthropic API 키로 답합니다.
 [Codex 앱과 Codex CLI](#codex-앱과-codex-cli) 절을 보세요.
 
+### 이미지도 만들 수 있나요?
+
+됩니다. API 키 없이 ChatGPT 구독으로 만듭니다: `clauderipple image "빨간 종이배" -o boat.png --aspect square`.
+`--ref 파일`로 참고 이미지를, `--transparent`로 투명 배경을 줄 수 있습니다. 한 장에 30초쯤 걸리고, 해상도와 품질은
+구독 쪽이 정합니다. ClaudeRipple이 만든 서브에이전트에도 같은 방법이 적혀 있어 워커도 이미지를 만듭니다.
+[Claude Code](#claude-code-터미널-remote-control-서브에이전트) 절을 보세요.
+
 ### Claude Code 안에서는 GPT 성능이 떨어지지 않나요?
 
 Claude Code의 시스템 프롬프트와 도구 설명은 Claude에 맞춰 쓰여 있어서, 다른 모델은 남에게 맞춘 지시를 읽는 셈이고
@@ -219,6 +226,10 @@ ClaudeRipple은 Claude Code 프로세스만 신뢰하는 작은 HTTPS 프록시
   서버 측 스레드 처리, 도구 호출과 이미지 왕복, 모델이 받는 범위로 추론 강도 클램프, 호환 벤더에는 Anthropic 전용 필드 제거.
 - **제대로 된 요청 로그.** 누가 물었고 어떤 모델이 답했는지, 입력·캐시·출력 토큰, 지연, 상태를 요청마다. 한 시간 요약 포함.
 - **서브에이전트 이름표.** 백그라운드 작업 패널에 "Agent" 대신 `Terra·high · Review`가 보입니다.
+- **ChatGPT 구독으로 이미지 생성.** `clauderipple image "<프롬프트>"`. 참고 이미지와 투명 배경도 됩니다. 서브에이전트에도
+  방법이 적혀 있어, GPT나 DeepSeek 워커가 이미지 도구 없이 이미지를 만들고 직접 확인합니다.
+- **원하면 가벼운 워커.** 스위치 하나로, 생성된 서브에이전트에 세션의 MCP·플러그인 도구 전부 대신 워커가 쓰는 도구만
+  줍니다. 워커 첫 요청이 3.3만에서 0.9만 토큰으로 줄었습니다.
 - **터미널이 싫은 사람을 위해.** 원클릭 연결 확인과 모델 자동 검색이 붙은 프로바이더 프리셋, 드롭다운 모델 매핑, 자동 저장,
   한국어·영어 UI. 런타임을 품고 첫 실행에 스스로 설치하는 메뉴 막대 앱. 서명·공증 완료.
 
@@ -280,13 +291,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은
@@ -308,7 +321,7 @@ node packages/cli/src/index.ts ui        # 브라우저에서 로컬 GUI 열기
 
 `uninstall`은 전부 되돌리고 `~/.claude/settings.json`을 백업에서 복원합니다. 그 밖의 명령: `status`, `start`, `stop`,
 `restart`, `logs -f`, `login`, `logout`, `claude-login`, `claude-logout`, `picker on|off`, `agent-title on|off`,
-`codex on|off`.
+`codex on|off`, `update`, `image "<프롬프트>"`.
 </details>
 
 ## 클라이언트
@@ -353,6 +366,22 @@ model: gpt-5.6-sol@medium
 알 수 없는 에러로 죽게 두지 않고 이름을 대고 거부합니다(`400 ClaudeRipple: no provider declares "…"`).
 Claude 모델은 언제나 그대로 통과합니다. 생성을 끄려면 `"cli": { "agentFiles": false }`.
 
+생성된 워커는 기본적으로 세션의 도구를 전부 물려받아, MCP 서버·플러그인 도구가 워커 요청마다 실립니다.
+`"cli": { "limitWorkerTools": true }`(대시보드의 **워커 도구 제한**)를 켜면 읽기·편집·실행·검색·스킬 도구만
+주어 워커 첫 요청이 약 3.3만에서 0.9만 토큰으로 줄었습니다. 대신 그 워커는 브라우저·시뮬레이터 도구를 못 씁니다.
+그런 도구가 필요한 워커는 직접 만든 에이전트 파일로 두면 되고, 그 파일은 건드리지 않습니다.
+
+ChatGPT 프로바이더가 있으면 같은 구독으로 이미지를 만들 수 있습니다.
+
+```bash
+clauderipple image "빨간 종이배, 플랫 일러스트" -o boat.png --aspect square
+```
+
+`--transparent`, `--format png|jpeg|webp`, `--ref 파일`(참고 이미지, 여러 번 가능)은 선택입니다. 한 장에 30초쯤 걸립니다.
+구독 백엔드가 해상도와 품질을 직접 정하므로, 모양은 `--aspect`로 말로 요청합니다. 이 명령은 관리 포트의
+`POST /api/image`(응답이 이미지 바이트)를 부르는 클라이언트입니다. 생성된 워커에는 그 `curl` 형태가 적혀 있어,
+Bash만 있는 워커도 이미지를 만들고 Read로 확인할 수 있습니다.
+
 Claude Code의 `WebSearch`는 작은 모델에 별도 요청을 보냅니다. ChatGPT로 라우팅한 구성에서 그 요청만
 Anthropic 한도를 쓰지 않게 하려면 `config.json`에서 같은 ChatGPT 프로바이더를 검색 백엔드로 지정합니다:
 

package/README.md

@@ -165,6 +165,15 @@ Yes. `clauderipple codex on` adds ClaudeRipple as a provider, and Claude models
 the Codex app's and CLI's model list under their own names. They answer through your
 Claude Code login or an Anthropic API key. See [Codex app and Codex CLI](#codex-app-and-codex-cli).
 
+### Can it generate images?
+
+Yes, with a ChatGPT subscription and no API key:
+`clauderipple image "a red paper boat" -o boat.png --aspect square`. `--ref FILE` adds
+a reference image and `--transparent` a transparent background. One image takes about
+30 seconds, and the subscription chooses the resolution and quality. Subagents
+ClaudeRipple generates are told the same call, so they can make images too. See
+[Claude Code](#claude-code-terminal-remote-control-subagents).
+
 ### Does GPT do worse inside Claude Code?
 
 Claude Code's system prompt and tool descriptions are written for Claude, so another model
@@ -263,6 +272,12 @@ you map go to your provider, everything else goes to Anthropic byte for byte.
   latency, status, per request, with a one-hour summary.
 - **Subagent name tags.** The background-task panel shows `Terra·high · Review`
   instead of a generic "Agent".
+- **Images from your ChatGPT subscription.** `clauderipple image "<prompt>"`, with
+  reference images and transparent backgrounds. Subagents are told how, so a GPT or
+  DeepSeek worker can make an image and look at it without an image tool.
+- **Lean workers, if you want them.** One switch gives generated subagents only the
+  tools a worker uses instead of every MCP server and plugin of the session: one
+  worker's first request fell from 33k to 9k tokens.
 - **Made for people who don't want a terminal.** Provider presets with one-click
   connection tests and model discovery, drop-down model mapping, auto-save, Korean
   and English UI. A menu-bar app that carries its own runtime and sets itself up on
@@ -328,13 +343,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
@@ -358,7 +375,7 @@ node packages/cli/src/index.ts ui        # open the local GUI in your browser
 `uninstall` reverses everything and restores `~/.claude/settings.json` from a backup.
 Other commands: `status`, `start`, `stop`, `restart`, `logs -f`, `login`, `logout`,
 `claude-login`, `claude-logout`, `picker on|off`, `agent-title on|off`,
-`codex on|off`.
+`codex on|off`, `update`, `image "<prompt>"`.
 </details>
 
 ## Clients
@@ -411,6 +428,27 @@ by name (`400 ClaudeRipple: no provider declares "…"`) instead of being sent o
 to fail somewhere less legible; native Claude models always pass through.
 Set `"cli": { "agentFiles": false }` to turn generation off.
 
+By default a generated worker inherits every tool of the session, so each MCP
+server and plugin rides along on every worker request. `"cli": {
+"limitWorkerTools": true }` (or **Worker tools** in the dashboard) gives it only
+the read, edit, run, search and skill tools, which cut one worker's first
+request from about 33k to 9k tokens. Such a worker has no browser or simulator
+tools. A worker that needs them belongs in an agent file of your own, which is
+never touched.
+
+With a ChatGPT provider configured, images come from the same subscription:
+
+```bash
+clauderipple image "a red paper boat, flat illustration" -o boat.png --aspect square
+```
+
+`--transparent`, `--format png|jpeg|webp` and `--ref FILE` (a reference image,
+repeatable) are optional. One image takes about 30 seconds. The subscription
+backend picks the resolution and quality itself, so the shape is asked for in
+words (`--aspect`). The command is a client of `POST /api/image` on the admin
+port, which answers with the image bytes. Generated workers are told the `curl`
+form of it, so a worker with only Bash can make an image and read it back.
+
 Claude Code runs `WebSearch` as a separate small-model request. To keep a
 ChatGPT-routed setup from spending Anthropic quota for that request, select the
 same ChatGPT provider as the search backend in `config.json`:

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.7.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,55 @@ function starterConfig(port) {
         log: DEFAULTS.log,
     }, null, 2) + "\n";
 }
+const IMAGE_USAGE = 'usage: clauderipple image "<prompt>" [-o FILE] [--aspect square|landscape|portrait] [--format png|jpeg|webp] [--transparent] [--ref FILE ...]';
+/**
+ * One image through the running router's ChatGPT subscription (`POST /api/image`), written to a
+ * file whose path is printed — so a worker with nothing but Bash can make and then look at one.
+ */
+async function image() {
+    const prompt = args[1];
+    if (!prompt || prompt.startsWith("-"))
+        throw new Error(IMAGE_USAGE);
+    const images = args.flatMap((a, i) => (a === "--ref" && args[i + 1] ? [args[i + 1]] : [])).map((file) => {
+        const ext = path.extname(file).slice(1).toLowerCase();
+        return `data:image/${ext === "jpg" ? "jpeg" : ext};base64,${fs.readFileSync(file).toString("base64")}`;
+    });
+    const format = opt("format") ?? "png";
+    const out = path.resolve(opt("o") ?? `image-${new Date().toISOString().replace(/[:.]/g, "-")}.${format === "jpeg" ? "jpg" : format}`);
+    const body = {
+        prompt,
+        format,
+        ...(opt("aspect") ? { aspect: opt("aspect") } : {}),
+        ...(flag("transparent") ? { background: "transparent" } : {}),
+        ...(images.length ? { images } : {}),
+    };
+    const port = adminPort(new ConfigStore(configPath()).get());
+    let res;
+    try {
+        res = await fetch(`http://127.0.0.1:${port}/api/image`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    }
+    catch {
+        throw new Error(`the router is not answering on 127.0.0.1:${port}; start it with: clauderipple start`);
+    }
+    if (!res.ok) {
+        const answer = (await res.json().catch(() => ({})));
+        throw new Error(answer.error ?? `HTTP ${res.status}`);
+    }
+    fs.mkdirSync(path.dirname(out), { recursive: true });
+    fs.writeFileSync(out, Buffer.from(await res.arrayBuffer()));
+    console.log(out);
+}
+/** 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 +235,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 +402,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,10 +453,13 @@ 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)
   claude-logout     remove every Claude subscription added to ClaudeRipple
+  image "<prompt>" [-o FILE] [--aspect square|landscape|portrait] [--transparent] [--ref FILE ...]
+                    generate an image with your ChatGPT subscription and print the file's path
   picker on|off     show your mapped models by name in the Claude Desktop picker (trusts the CA in your login keychain, routes the app through ClaudeRipple)
   codex on|off      add/remove ClaudeRipple's local OpenAI provider and selection profile for Codex CLI
   agent-title on|off|status
@@ -489,9 +592,15 @@ try {
         case "claude-logout":
             console.log(claudeLogout(homeDir()) ? "✓ ClaudeRipple Claude accounts removed" : "no ClaudeRipple Claude accounts stored");
             break;
+        case "image":
+            await image();
+            break;
         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",
     });