clauderipple 0.2.0

package/dist/app/dist/main.js

@@ -0,0 +1,518 @@
+"use strict";
+// ClaudeRipple menu-bar app. It owns no logic: the router serves the GUI and the admin API on
+// 127.0.0.1; this shell adds a tray icon with live health, a window for the GUI, and shortcuts
+// for restart / logs / login. If the router is down the tray says so and offers to start it.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const home = process.env.CLAUDERIPPLE_HOME ?? node_path_1.default.join(node_os_1.default.homedir(), ".clauderipple");
+const POLL_MS = 5000;
+// ---- i18n: tray menu, dialogs, tooltips -------------------------------------------------
+const STRINGS = {
+    en: {
+        healthy: "healthy",
+        attentionNeeded: "attention needed",
+        routerNotRunning: "router not running",
+        slotsMapped: (n) => `${n} slot${n === 1 ? "" : "s"} mapped`,
+        inFlight: "in flight",
+        connected: "Claude Desktop connected",
+        notConnected: "Claude Desktop not connected",
+        percentOfWeekUsed: (percent, plan) => `ChatGPT ${plan} ${percent}% this week`,
+        cliVersion: (v) => `Claude Code CLI ${v}`,
+        restartRouter: "Restart Router",
+        startRouter: "Start Router",
+        pickerOn: "Show GPT models in the Code tab picker…",
+        pickerOff: "Stop showing GPT models in the picker…",
+        pickerState: (on) => (on ? "Picker: GPT models shown by name ✓" : "Picker: GPT models via Claude names (alias mode)"),
+        pickerOnConfirm: "macOS will ask for your login password to trust the ClaudeRipple certificate (ClaudeRipple never sees it). Then quit and reopen Claude Desktop.",
+        pickerDone: "Done. Now quit Claude Desktop completely and open it again, then check the Code tab picker.",
+        pickerOffDone: "Done. Quit and reopen Claude Desktop to apply.",
+        cancel: "Cancel",
+        agentTitleOn: "Show model names on subagents",
+        agentTitleOff: "Stop showing model names on subagents",
+        agentTitleDone: (on) => (on ? "On. New subagents will be titled like \"Terra·high · …\"." : "Off."),
+        signInChatgpt: "Sign in to ChatGPT…",
+        connectClaudeSubscription: "Connect Claude subscription…",
+        copyStatus: "Copy Status",
+        showLogs: "Show Logs",
+        rerunSetup: "Run ClaudeRipple setup again…",
+        setupTitle: "Set up ClaudeRipple",
+        setupPrompt: "ClaudeRipple will create a local certificate, connect Claude Code settings (~/.claude/settings.json), and register the background router. Continue?",
+        setupLater: "Later",
+        setupContinue: "Continue",
+        setupDone: "ClaudeRipple setup finished.",
+        setupFailed: "Setup did not finish",
+        updatedTitle: (v) => `ClaudeRipple ${v}`,
+        updatedRestarting: (from) => `The running router is ${from}. Switching it to this version…`,
+        updatedFailed: "The router could not be switched to this version",
+        problem: (code) => code === "settings" ? "Claude Code is not pointed at ClaudeRipple"
+            : code === "upstream" ? "Anthropic is unreachable"
+                : code === "picker-ca" ? "picker mode: certificate not trusted"
+                    : code === "picker-proxy" ? "picker mode: Claude Desktop proxy not set"
+                        : code.startsWith("provider:") ? `provider ${code.slice(9)} unreachable`
+                            : code,
+        about: "About ClaudeRipple",
+        aboutDetail: "Run GPT and other models inside Claude Desktop, without turning Claude off.\n\nIndependent open-source project (GPL-3.0). Not affiliated with, endorsed by, or sponsored by Anthropic or OpenAI. Claude and Claude Code are trademarks of Anthropic, PBC.",
+        quit: "Quit",
+        tooltip: (state) => `ClaudeRipple ${state}`,
+        tooltipDown: "ClaudeRipple: router not running — Claude Desktop cannot connect",
+        proxyLine: (host, port, slots, flight) => `Proxy ${host}:${port} · ${slots} · ${flight}`,
+        startAtLogin: "Start at login",
+        downNotifyTitle: "Claude Desktop cannot connect",
+        downNotifyBody: "The ClaudeRipple router is not running, so Claude Desktop has no way out. Click to start it.",
+        starting: "starting the router…",
+        openDashboard: "Open Dashboard in Browser…",
+        offlineHeading: "The router is not running",
+        offlineBody: "Claude Desktop sends all of its traffic through ClaudeRipple, so while the router is down the app shows a blank window with ERR_PROXY_CONNECTION_FAILED. Start the router and reload Claude Desktop.",
+        setupNeeded: "setup not finished",
+        setupNeededDetail: "ClaudeRipple is installed but not set up yet",
+        runSetup: "Finish setting up ClaudeRipple…",
+    },
+    ko: {
+        healthy: "정상",
+        attentionNeeded: "확인 필요",
+        routerNotRunning: "라우터가 꺼져 있음",
+        slotsMapped: (n) => `슬롯 ${n}개 매핑`,
+        inFlight: "진행 중",
+        connected: "Claude Desktop 연결됨",
+        notConnected: "Claude Desktop 연결 안 됨",
+        percentOfWeekUsed: (percent, plan) => `ChatGPT ${plan} 주간 ${percent}%`,
+        cliVersion: (v) => `Claude Code CLI ${v}`,
+        restartRouter: "라우터 재시작",
+        startRouter: "라우터 시작",
+        pickerOn: "Code 탭 피커에 GPT 모델 이름 표시…",
+        pickerOff: "피커의 GPT 모델 표시 끄기…",
+        pickerState: (on) => (on ? "피커: GPT 모델을 실명으로 표시 중 ✓" : "피커: Claude 이름으로 GPT 사용(별칭 모드)"),
+        pickerOnConfirm: "ClaudeRipple 인증서를 신뢰하기 위해 macOS가 로그인 암호를 묻습니다(ClaudeRipple은 암호를 보지 않습니다). 끝나면 Claude Desktop을 완전히 종료했다가 다시 여세요.",
+        pickerDone: "완료. 이제 Claude Desktop을 완전히 종료한 뒤 다시 열고 Code 탭 피커를 확인하세요.",
+        pickerOffDone: "완료. Claude Desktop을 종료했다가 다시 열면 적용됩니다.",
+        cancel: "취소",
+        agentTitleOn: "서브에이전트에 모델 이름 표시",
+        agentTitleOff: "서브에이전트 모델 이름 표시 끄기",
+        agentTitleDone: (on) => (on ? "켰습니다. 새로 뜨는 서브에이전트 제목이 \"Terra·high · …\"처럼 보입니다." : "껐습니다."),
+        signInChatgpt: "ChatGPT 로그인…",
+        connectClaudeSubscription: "Claude 구독 연결…",
+        copyStatus: "상태 복사",
+        showLogs: "로그 보기",
+        rerunSetup: "ClaudeRipple 설정 다시 실행…",
+        setupTitle: "ClaudeRipple을 설정합니다",
+        setupPrompt: "로컬 인증서 생성, Claude Code 설정(~/.claude/settings.json) 연결, 백그라운드 라우터 등록을 진행합니다. 계속할까요?",
+        setupLater: "나중에",
+        setupContinue: "계속",
+        setupDone: "ClaudeRipple 설정이 완료되었습니다.",
+        setupFailed: "설정을 마치지 못했습니다",
+        updatedTitle: (v) => `ClaudeRipple ${v}`,
+        updatedRestarting: (from) => `지금 떠 있는 라우터는 ${from}입니다. 이 버전으로 바꿉니다…`,
+        updatedFailed: "라우터를 이 버전으로 바꾸지 못했습니다",
+        problem: (code) => code === "settings" ? "Claude Code가 ClaudeRipple을 거치지 않음"
+            : code === "upstream" ? "Anthropic에 연결 안 됨"
+                : code === "picker-ca" ? "피커 모드: 인증서 미신뢰"
+                    : code === "picker-proxy" ? "피커 모드: Claude Desktop 프록시 미설정"
+                        : code.startsWith("provider:") ? `프로바이더 ${code.slice(9)} 연결 안 됨`
+                            : code,
+        about: "ClaudeRipple 정보",
+        aboutDetail: "Claude Desktop을 끄지 않고 그 안에서 GPT 등 다른 모델을 씁니다.\n\n독립 오픈소스 프로젝트(GPL-3.0)이며 Anthropic·OpenAI와 제휴·보증·후원 관계가 없습니다. Claude와 Claude Code는 Anthropic, PBC의 상표입니다.",
+        quit: "종료",
+        tooltip: (state) => `ClaudeRipple ${state}`,
+        tooltipDown: "ClaudeRipple: 라우터가 꺼져 있어 Claude Desktop이 연결되지 않습니다",
+        proxyLine: (host, port, slots, flight) => `프록시 ${host}:${port} · ${slots} · ${flight}`,
+        startAtLogin: "로그인 시 자동 시작",
+        downNotifyTitle: "Claude Desktop이 연결되지 않습니다",
+        downNotifyBody: "ClaudeRipple 라우터가 꺼져 있어 Claude Desktop이 밖으로 나가지 못합니다. 눌러서 시작하세요.",
+        starting: "라우터를 시작하는 중…",
+        openDashboard: "브라우저에서 대시보드 열기…",
+        offlineHeading: "라우터가 꺼져 있습니다",
+        offlineBody: "Claude Desktop은 모든 통신을 ClaudeRipple로 보냅니다. 그래서 라우터가 꺼져 있는 동안에는 앱이 흰 화면과 ERR_PROXY_CONNECTION_FAILED만 보여줍니다. 라우터를 시작한 뒤 Claude Desktop을 새로고침하세요.",
+        setupNeeded: "설정이 끝나지 않았습니다",
+        setupNeededDetail: "설치는 됐지만 아직 설정하지 않았습니다",
+        runSetup: "ClaudeRipple 설정 마치기…",
+    },
+};
+let L = STRINGS.en;
+function readConfigPorts() {
+    try {
+        const c = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(home, "config.json"), "utf8"));
+        const proxy = c.listen?.port ?? 8790;
+        return { proxy, admin: c.admin?.port ?? proxy + 1 };
+    }
+    catch {
+        return { proxy: 8790, admin: 8791 };
+    }
+}
+let tray = null;
+let last = null;
+let lastError = null;
+let starting = false;
+let downSince = null;
+let downNotified = false;
+// Long enough that a router still coming up after login does not fire a notification.
+const DOWN_NOTIFY_AFTER_MS = 20_000;
+// ---- login item ------------------------------------------------------------------------
+// The tray app has to be running before the user opens Claude Desktop: with the router down the
+// app shows nothing but ERR_PROXY_CONNECTION_FAILED, and the tray is the only place that says why.
+const stateFile = node_path_1.default.join(home, "app.json");
+function appState() {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(stateFile, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeAppState(patch) {
+    try {
+        node_fs_1.default.mkdirSync(home, { recursive: true });
+        node_fs_1.default.writeFileSync(stateFile, `${JSON.stringify({ ...appState(), ...patch }, null, 2)}\n`);
+    }
+    catch {
+        /* a read-only home only costs us the remembered default */
+    }
+}
+function loginItemOn() {
+    try {
+        return electron_1.app.getLoginItemSettings().openAtLogin;
+    }
+    catch {
+        return false;
+    }
+}
+function setLoginItem(on) {
+    try {
+        electron_1.app.setLoginItemSettings({ openAtLogin: on });
+    }
+    catch {
+        /* macOS may refuse in an unsigned development build */
+    }
+    writeAppState({ loginItemInitialized: true });
+}
+function adminUrl() {
+    return `http://127.0.0.1:${readConfigPorts().admin}/`;
+}
+/**
+ * The language the user actually set in the OS. `app.getLocale()` is Chromium's app locale and
+ * reads `en-US` on a Korean Windows (measured 2026-09-14), so the tray, notifications and the GUI
+ * came up in English there. macOS happened to agree, which hid it.
+ */
+function uiLang() {
+    const candidates = [...electron_1.app.getPreferredSystemLanguages(), electron_1.app.getSystemLocale(), electron_1.app.getLocale()];
+    const first = candidates.find((l) => typeof l === "string" && l.length > 0) ?? "en";
+    return first.toLowerCase().startsWith("ko") ? "ko" : "en";
+}
+/** The GUI follows the OS language by default; a language the user picked in the GUI itself wins (it is stored in the page). */
+function guiUrl() {
+    return `${adminUrl()}?lang=${uiLang()}`;
+}
+async function poll() {
+    try {
+        const res = await fetch(`${adminUrl()}api/status`, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        last = (await res.json());
+        lastError = null;
+        downSince = null;
+        downNotified = false;
+        void reconcileRouter(last);
+    }
+    catch (e) {
+        last = null;
+        lastError = e.message;
+        downSince ??= Date.now();
+        if (!downNotified && Date.now() - downSince >= DOWN_NOTIFY_AFTER_MS) {
+            downNotified = true;
+            notifyDown();
+        }
+    }
+    render();
+}
+/** The router being down means Claude Desktop is dead in the water, so say so out loud. */
+function notifyDown() {
+    if (!electron_1.Notification.isSupported())
+        return;
+    const n = new electron_1.Notification({ title: L.downNotifyTitle, body: L.downNotifyBody });
+    n.on("click", () => void startRouter());
+    n.show();
+}
+/** Idempotent: `clauderipple start` leaves a router that is already coming up alone. */
+async function startRouter() {
+    if (starting)
+        return L.starting;
+    starting = true;
+    try {
+        return await runCli(["start"]);
+    }
+    finally {
+        starting = false;
+        void poll();
+    }
+}
+function healthy(s) {
+    if (!s)
+        return "down";
+    const proxyOk = s.settings.HTTPS_PROXY === `http://127.0.0.1:${s.listen.port}`;
+    const providersOk = Object.values(s.providers).every((p) => p.reachable !== false);
+    if (!proxyOk || s.consecutiveUpstreamFailures > 0)
+        return "warn";
+    return providersOk ? "ok" : "warn";
+}
+const isMac = process.platform === "darwin";
+/**
+ * macOS tints template images (black + alpha) to match the menu bar. Windows does not, so the same
+ * mark would vanish on a dark taskbar — it gets a coloured variant instead, which also lets the
+ * state read as a colour rather than only a shape.
+ */
+function icon(state) {
+    const mac = { ok: "trayTemplate.png", warn: "trayWarnTemplate.png", down: "trayDownTemplate.png" };
+    const win = { ok: "trayWin.png", warn: "trayWinWarn.png", down: "trayWinDown.png" };
+    const img = electron_1.nativeImage.createFromPath(node_path_1.default.join(__dirname, "..", "assets", (isMac ? mac : win)[state]));
+    if (isMac)
+        img.setTemplateImage(true);
+    return img;
+}
+/**
+ * The dashboard is a web page served by the router, so it opens in the user's own browser. With
+ * the router down there is nothing to open: start it (or run setup, when that is what is missing)
+ * and open the page once it answers, rather than sending the browser to a refused connection.
+ */
+async function openDashboard() {
+    if (last) {
+        void electron_1.shell.openExternal(guiUrl());
+        return;
+    }
+    // Before setup there is no router to start, so offer the step that is actually missing.
+    const message = needsSetup() ? (await setup(), "") : await startRouter();
+    // startRouter() returns once the CLI has finished; ask the router itself rather than waiting
+    // for the next tick, since the user is standing in front of the menu.
+    await poll();
+    if (last) {
+        void electron_1.shell.openExternal(guiUrl());
+        return;
+    }
+    await electron_1.dialog.showMessageBox({ type: "warning", message: L.offlineHeading, detail: [L.offlineBody, message].filter(Boolean).join("\n\n") });
+}
+// ---- update handling -------------------------------------------------------------------
+// Installing a new version replaces files, not the process: the supervisor started the router at
+// logon from the previous files, and `start` leaves a running router alone. So after an update
+// the old router kept serving — the 0.1.1 fixes never ran on the Windows install that reported
+// the bugs (2026-09-15). A zip unpacked next to the old folder is worse: the supervisor and
+// paths.json still name the old folder, so even a restart brings the old code back.
+//
+// Once per app run, when the router answers: if it runs another version, restart it; if this
+// installation's files are not the ones recorded, re-run `install` first so the supervisor
+// points here. A source checkout recorded in paths.json is a developer's choice and is left alone.
+let reconciled = false;
+function savedPaths() {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(home, "paths.json"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** A router path inside a packaged app (macOS .app bundle or electron-builder resources). */
+function looksPackaged(routerPath) {
+    return /\.app[\\/]Contents[\\/]Resources[\\/]clauderipple[\\/]/.test(routerPath) || /[\\/]resources[\\/]clauderipple[\\/]/i.test(routerPath);
+}
+function samePath(a, b) {
+    const norm = (p) => (process.platform === "win32" ? node_path_1.default.resolve(p).toLowerCase() : node_path_1.default.resolve(p));
+    return norm(a) === norm(b);
+}
+async function reconcileRouter(s) {
+    if (reconciled)
+        return;
+    const packaged = packagedRuntime();
+    if (!packaged?.router)
+        return; // development shell: never touch a checkout's router
+    const saved = savedPaths();
+    if (!saved?.router || !looksPackaged(saved.router))
+        return;
+    const installedElsewhere = !samePath(saved.router, packaged.router);
+    const runningElsewhere = !!s.runtime?.router && !samePath(s.runtime.router, packaged.router);
+    const otherVersion = s.version !== electron_1.app.getVersion();
+    if (!installedElsewhere && !runningElsewhere && !otherVersion)
+        return;
+    reconciled = true;
+    const from = `${s.version}${s.runtime?.router ? ` (${s.runtime.router})` : ""}`;
+    if (electron_1.Notification.isSupported())
+        new electron_1.Notification({ title: L.updatedTitle(electron_1.app.getVersion()), body: L.updatedRestarting(from) }).show();
+    const outputs = [];
+    if (installedElsewhere || runningElsewhere)
+        outputs.push(await runCli(["install"]));
+    outputs.push(await runCli(["restart"]));
+    const out = outputs.join("\n\n");
+    if (/✗|error|failed|not restarted|start failed/i.test(out)) {
+        await electron_1.dialog.showMessageBox({ type: "warning", message: L.updatedFailed, detail: out });
+    }
+    void poll();
+}
+/**
+ * The sources this app carries, when it is a packaged build. macOS keeps them inside the .app;
+ * electron-builder puts them next to app.asar everywhere else.
+ *
+ * This used to match only the macOS bundle path, so on Windows it returned null — which made
+ * needsSetup() answer false and the first-run setup prompt never appear. The app installed, said
+ * "router not running", and left the user with no way to find out what to do (2026-09-14).
+ */
+function packagedRuntime() {
+    const macBundle = process.execPath.match(/^(.*\.app)\/Contents\/MacOS\//)?.[1];
+    const resources = macBundle
+        ? node_path_1.default.join(macBundle, "Contents", "Resources", "clauderipple")
+        : node_path_1.default.join(process.resourcesPath ?? "", "clauderipple");
+    const cli = node_path_1.default.join(resources, "packages", "cli", "src", "index.ts");
+    if (!node_fs_1.default.existsSync(cli))
+        return null;
+    return { node: process.execPath, env: { ELECTRON_RUN_AS_NODE: "1" }, cli, router: node_path_1.default.join(resources, "packages", "router", "src", "index.ts") };
+}
+/** Prefer this app's bundled Electron runtime; existing installations retain their recorded runtime. */
+function cliPaths() {
+    const packaged = packagedRuntime();
+    if (packaged && node_fs_1.default.existsSync(packaged.cli))
+        return packaged;
+    try {
+        const p = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(home, "paths.json"), "utf8"));
+        if (p.node && p.cli && node_fs_1.default.existsSync(p.node) && node_fs_1.default.existsSync(p.cli))
+            return { node: p.node, env: p.env ?? {}, cli: p.cli };
+    }
+    catch {
+        /* fall through to the development layout */
+    }
+    // process.execPath is Electron: without ELECTRON_RUN_AS_NODE it launches a second app instead of
+    // running the CLI, and that instance never exits (observed 2026-09-14 with no paths.json).
+    // A checkout keeps the CLI two levels up as TypeScript; an npm install has the built JavaScript
+    // in the same place, since the tray is copied into the same tree it was built beside.
+    const nearby = [node_path_1.default.resolve(__dirname, "..", "..", "cli", "src", "index.ts"), node_path_1.default.resolve(__dirname, "..", "..", "cli", "src", "index.js")];
+    const cli = nearby.find((candidate) => node_fs_1.default.existsSync(candidate)) ?? nearby[0];
+    return { node: process.execPath, env: { ELECTRON_RUN_AS_NODE: "1" }, cli };
+}
+function runCli(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());
+        });
+    });
+}
+// 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() {
+    const current = packagedRuntime();
+    if (!current)
+        return false;
+    try {
+        const saved = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(home, "paths.json"), "utf8"));
+        const usable = !!saved.node && !!saved.router && node_fs_1.default.existsSync(saved.node) && node_fs_1.default.existsSync(saved.router);
+        return !usable;
+    }
+    catch {
+        return true;
+    }
+}
+async function setup() {
+    const out = await runCli(["install"]);
+    // `install` marks each step with ✓ or ✗ and ends on a failed probe; saying "finished" over a
+    // failure would send the user away believing it worked.
+    const failed = out.includes("✗") || /error|failed/i.test(out);
+    await electron_1.dialog.showMessageBox({
+        type: failed ? "warning" : "info",
+        message: failed ? L.setupFailed : L.setupDone,
+        detail: out,
+    });
+    void poll();
+}
+async function promptForSetup() {
+    const choice = await electron_1.dialog.showMessageBox({
+        title: "ClaudeRipple",
+        message: L.setupTitle,
+        detail: L.setupPrompt,
+        buttons: [L.setupContinue, L.setupLater],
+        defaultId: 0,
+        cancelId: 1,
+    });
+    if (choice.response === 0)
+        await setup();
+}
+function render() {
+    if (!tray)
+        return;
+    const state = healthy(last);
+    tray.setImage(icon(state));
+    const s = last;
+    const quota = Object.values(s?.chatgpt?.quota ?? {}).find((q) => q);
+    const quotaLine = quota?.rate_limits?.primary
+        ? L.percentOfWeekUsed(quota.rate_limits.primary.used_percent ?? "?", quota.plan_type ?? "")
+        : null;
+    // Two status lines (clickable: they open the window), then only the actions that need the tray.
+    // Everything else lives in the GUI window. Disabled items render grey, so the status lines stay enabled.
+    const connected = !!s && s.settings.HTTPS_PROXY === `http://127.0.0.1:${s.listen.port}`;
+    // "Router not running" is useless advice to someone who has never set it up — that reads as a
+    // fault when the truth is there is one step left. Separate the two states everywhere.
+    const unconfigured = !s && needsSetup();
+    const headline = s
+        ? `ClaudeRipple · ${state === "ok" ? L.healthy : L.attentionNeeded}`
+        : `ClaudeRipple · ${unconfigured ? L.setupNeeded : L.routerNotRunning}`;
+    // What is actually in the way, not only that something is: the router's readiness list names it.
+    const problems = (s?.readiness?.problems ?? []).map((code) => L.problem(code));
+    const detail = s
+        ? [connected ? L.connected : L.notConnected, ...problems, quotaLine].filter(Boolean).join(" · ")
+        : unconfigured
+            ? L.setupNeededDetail
+            : L.downNotifyTitle;
+    const template = [
+        { label: headline, click: () => void openDashboard() },
+        ...(detail ? [{ label: detail, click: () => void openDashboard() }] : []),
+        { type: "separator" },
+        // Enabled even when the router is down: it is started first, then the page is opened.
+        { label: L.openDashboard, click: () => void openDashboard() },
+        { label: L.startAtLogin, type: "checkbox", checked: loginItemOn(), click: (item) => setLoginItem(item.checked) },
+        { type: "separator" },
+        { label: unconfigured ? L.runSetup : L.rerunSetup, click: () => void setup() },
+        ...(unconfigured
+            ? []
+            : [
+                {
+                    label: s ? L.restartRouter : L.startRouter,
+                    click: async () => void electron_1.dialog.showMessageBox({ message: s ? await runCli(["restart"]) : await startRouter() }),
+                },
+            ]),
+        // Only offered while a ChatGPT provider has no usable credentials (own login or a reused Codex CLI login).
+        ...(s && Object.values(s.chatgpt?.signedIn ?? {}).some((ok) => !ok)
+            ? [{ label: L.signInChatgpt, click: async () => void electron_1.dialog.showMessageBox({ message: await runCli(["login"]) }) }]
+            : []),
+        { 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.quit, role: "quit" },
+    ];
+    tray.setContextMenu(electron_1.Menu.buildFromTemplate(template));
+    tray.setToolTip(s ? L.tooltip(state) : L.tooltipDown);
+}
+electron_1.app.whenReady().then(() => {
+    L = STRINGS[uiLang()];
+    // Without this, Windows attributes our notifications to "Electron" instead of ClaudeRipple.
+    if (process.platform === "win32")
+        electron_1.app.setAppUserModelId("com.clauderipple.app");
+    // macOS keeps its application menu (it owns Cmd-Q and the edit shortcuts); elsewhere it is noise.
+    if (!isMac)
+        electron_1.Menu.setApplicationMenu(null);
+    if (isMac)
+        electron_1.app.dock?.hide();
+    // Default to starting at login on first run; after that the user's choice stands.
+    if (!appState().loginItemInitialized)
+        setLoginItem(true);
+    tray = new electron_1.Tray(icon("down"));
+    tray.on("click", () => tray?.popUpContextMenu());
+    render();
+    void poll();
+    setInterval(() => void poll(), POLL_MS);
+    if (needsSetup())
+        void promptForSetup();
+});
+// A tray-only app owns no windows; without this Electron would quit the moment a dialog closes.
+electron_1.app.on("window-all-closed", () => {
+    /* keep running in the tray */
+});

package/dist/cli/src/browser.js

@@ -0,0 +1,21 @@
+// Opens a URL in the user's default browser. Shared by the CLI (sign-in commands, `ui`) and the
+// router's admin API (sign-in started from the GUI).
+import { execFileSync } from "node:child_process";
+/** Returns false if the platform command failed; the caller then shows the URL instead. */
+export function openBrowser(url) {
+    try {
+        if (process.platform === "win32") {
+            // Not `cmd /c start`: cmd treats & as a command separator, so an OAuth URL arrives truncated
+            // at its first parameter and the provider answers "missing_required_parameter" (observed
+            // 2026-09-14). Start-Process takes the URL as one argument, quoted PowerShell-style.
+            const quoted = `'${url.replace(/'/g, "''")}'`;
+            execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `Start-Process ${quoted}`], { stdio: "ignore", windowsHide: true });
+        }
+        else
+            execFileSync("open", [url], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/src/bundle.js

@@ -0,0 +1,51 @@
+// macOS attributes a launchd background item to the code signer of the executable it runs.
+// Running `node` directly makes System Settings say "Node.js Foundation". So the agent runs a
+// tiny app bundle named ClaudeRipple instead: an ad-hoc signed launcher script that execs node
+// with the router. Login Items and the background-activity notice then show "ClaudeRipple".
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+export const BUNDLE_ID = "com.clauderipple.router";
+export function bundlePath(home) {
+    return path.join(home, "ClaudeRipple.app");
+}
+export function launcherPath(home) {
+    return path.join(bundlePath(home), "Contents", "MacOS", "ClaudeRipple");
+}
+export function writeBundle(opts) {
+    const app = bundlePath(opts.home);
+    const macos = path.join(app, "Contents", "MacOS");
+    fs.mkdirSync(macos, { recursive: true });
+    fs.writeFileSync(path.join(app, "Contents", "Info.plist"), `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key><string>ClaudeRipple</string>
+  <key>CFBundleDisplayName</key><string>ClaudeRipple</string>
+  <key>CFBundleIdentifier</key><string>${BUNDLE_ID}</string>
+  <key>CFBundleVersion</key><string>${opts.version}</string>
+  <key>CFBundleShortVersionString</key><string>${opts.version}</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleExecutable</key><string>ClaudeRipple</string>
+  <key>LSUIElement</key><true/>
+  <key>LSBackgroundOnly</key><true/>
+</dict>
+</plist>
+`);
+    const launcher = launcherPath(opts.home);
+    fs.writeFileSync(launcher, `#!/bin/sh
+# ClaudeRipple router launcher (generated by \`clauderipple install\`).
+export CLAUDERIPPLE_HOME="${opts.home}"
+exec "${opts.node}" "${opts.script}"
+`, { mode: 0o755 });
+    try {
+        execFileSync("codesign", ["--force", "--sign", "-", "--identifier", BUNDLE_ID, app], { stdio: "ignore" });
+    }
+    catch {
+        /* ad-hoc signing is best effort; the launcher still runs unsigned */
+    }
+    return launcher;
+}
+export function removeBundle(home) {
+    fs.rmSync(bundlePath(home), { recursive: true, force: true });
+}

package/dist/cli/src/certs.js

@@ -0,0 +1,33 @@
+// Generate the local CA and the api.anthropic.com leaf certificate. Pure node:crypto (see
+// ../../router/src/x509.ts) so this works wherever Node runs, including Windows, which ships no
+// openssl. Nothing is installed in any trust store; the CA is handed to Node only, through
+// NODE_EXTRA_CA_CERTS (picker mode additionally trusts it in the login keychain).
+import fs from "node:fs";
+import path from "node:path";
+import { createCa, createLeaf } from "../../router/src/x509.js";
+export function certPaths(home) {
+    return {
+        caPem: path.join(home, "ca.pem"),
+        caKey: path.join(home, "ca.key"),
+        leafPem: path.join(home, "leaf.pem"),
+        leafKey: path.join(home, "leaf.key"),
+    };
+}
+export function generateCerts(home, upstream = "api.anthropic.com", days = 3650) {
+    fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+    const p = certPaths(home);
+    const ca = createCa({ days });
+    fs.writeFileSync(p.caPem, ca.certPem);
+    fs.writeFileSync(p.caKey, ca.keyPem, { mode: 0o600 });
+    const leaf = createLeaf({ host: upstream, caCertPem: ca.certPem, caKeyPem: ca.keyPem, days: Math.min(days, 825) });
+    fs.writeFileSync(p.leafPem, leaf.certPem);
+    fs.writeFileSync(p.leafKey, leaf.keyPem, { mode: 0o600 });
+    // Pre-existing installs were written before the mode argument; make sure the keys are private.
+    for (const f of [p.caKey, p.leafKey])
+        fs.chmodSync(f, 0o600);
+    return p;
+}
+export function certsExist(home) {
+    const p = certPaths(home);
+    return [p.caPem, p.caKey, p.leafPem, p.leafKey].every((f) => fs.existsSync(f));
+}