clauderipple 0.10.0 → 0.11.1

package/dist/app/dist/main.js

@@ -1,7 +1,12 @@
 "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.
+// ClaudeRipple menu-bar app. The router owns the logic and the admin API on 127.0.0.1; this shell
+// adds a tray icon with live health, the dashboard window, and shortcuts for restart / logs / login.
+//
+// The window draws the dashboard from the app's own copy of packages/ui (protocol.ts) and only asks
+// the router for data, so it opens with the router dead — which is when it is needed: on
+// 2026-10-20 a broken launch entry took the router down, and the router-served dashboard with it,
+// and nothing was left to fix it from. A preload bridge lets the dashboard repair the router or
+// switch Claude to its default connection through the CLI (`doctor` / `repair` / `direct`).
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -11,6 +16,10 @@ 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 claude_desktop_1 = require("./claude-desktop");
+const protocol_1 = require("./protocol");
+const status_model_1 = require("./status-model");
+const window_1 = require("./window");
 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 -------------------------------------------------
@@ -65,11 +74,17 @@ const STRINGS = {
         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.",
+        open: "Open ClaudeRipple…",
+        directHeadline: "Claude's default connection (Ripple off)",
+        tooltipDirect: "ClaudeRipple: using Claude's default connection",
+        notifyDownTitle: "Ripple is not responding",
+        notifyDownBody: "Claude cannot reach AI right now. Repair Ripple, or switch to Claude's default connection.",
+        actRepair: "Repair",
+        actDirectOn: "Use Claude's default connection",
+        restartConfirm: "Quit and reopen the Claude app?",
+        restartConfirmDetail: "Open conversations and any work in progress in the Claude app will stop.",
+        restartNow: "Reopen",
         setupNeeded: "setup not finished",
         setupNeededDetail: "ClaudeRipple is installed but not set up yet",
         runSetup: "Finish setting up ClaudeRipple…",
@@ -94,78 +109,84 @@ const STRINGS = {
     ko: {
         healthy: "정상",
         attentionNeeded: "확인 필요",
-        routerNotRunning: "라우터가 꺼져 있음",
-        slotsMapped: (n) => `슬롯 ${n}개 매핑`,
+        routerNotRunning: "리플 꺼짐",
+        slotsMapped: (n) => `슬롯 ${n}개 연결`,
         inFlight: "진행 중",
         connected: "Claude Desktop 연결됨",
         notConnected: "Claude Desktop 연결 안 됨",
-        percentOfWeekUsed: (percent, plan) => `ChatGPT ${plan} 주간 ${percent}%`,
+        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을 종료했다가 다시 열면 적용됩니다.",
+        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 · …\"처럼 보입니다." : "껐습니다."),
+        agentTitleOff: "서브에이전트 모델 이름 숨기기",
+        agentTitleDone: (on) => (on ? "켰습니다. 새로 시작하는 서브에이전트 제목이 \"Terra·high · …\"처럼 표시됩니다." : "껐습니다."),
         signInChatgpt: "ChatGPT 로그인…",
         connectClaudeSubscription: "Claude 구독 연결…",
         copyStatus: "상태 복사",
         showLogs: "로그 보기",
         rerunSetup: "ClaudeRipple 설정 다시 실행…",
-        setupTitle: "ClaudeRipple을 설정합니다",
-        setupPrompt: "로컬 인증서 생성, Claude Code 설정(~/.claude/settings.json) 연결, 백그라운드 라우터 등록을 진행합니다. 계속할까요?",
+        setupTitle: "ClaudeRipple 설정",
+        setupPrompt: "로컬 인증서를 만들고, Claude Code 설정(~/.claude/settings.json)을 연결하고, 리플이 백그라운드에서 돌도록 등록합니다. 계속하시겠습니까?",
         setupLater: "나중에",
         setupContinue: "계속",
         setupDone: "ClaudeRipple 설정이 완료되었습니다.",
-        setupFailed: "설정을 마치지 못했습니다",
+        setupFailed: "ClaudeRipple 설정을 완료하지 못했습니다",
         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 프록시 미설정"
+        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의 상표입니다.",
+        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이 연결되지 않습니다",
+        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 설정 마치기…",
+        starting: "리플을 시작하는 중…",
+        open: "ClaudeRipple 열기…",
+        directHeadline: "Claude 기본 연결 사용 중 (리플 꺼짐)",
+        tooltipDirect: "ClaudeRipple: Claude 기본 연결 사용 중",
+        notifyDownTitle: "리플이 응답하지 않습니다",
+        notifyDownBody: "지금 Claude가 AI에 연결되지 않습니다. 리플을 복구하거나 Claude 기본 연결로 전환할 수 있습니다.",
+        actRepair: "복구",
+        actDirectOn: "Claude 기본 연결로 전환",
+        restartConfirm: "Claude 앱을 종료했다가 다시 여시겠습니까?",
+        restartConfirmDetail: "Claude 앱의 열린 대화와 진행 중인 작업이 중단됩니다.",
+        restartNow: "다시 열기",
+        setupNeeded: "설정 필요",
+        setupNeededDetail: "ClaudeRipple이 설치되었지만 아직 설정이 완료되지 않았습니다.",
+        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: "진행 중인 요청이 끝나면 라우터가 새 버전으로 다시 시작합니다. 트레이는 저절로 다시 열립니다.",
+        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로 업데이트하세요.",
+        updateFailed: "업데이트를 완료하지 못했습니다",
+        updateCheckFailed: "업데이트 정보를 확인하지 못했습니다",
+        updatePackaged: "설치형 앱입니다. 릴리스 페이지에서 최신 버전을 다운로드해 주십시오.",
+        updateCheckout: "소스 코드로 실행 중입니다. git pull 명령으로 업데이트해 주십시오.",
     },
     zh: {
         healthy: "运行正常",
@@ -217,11 +238,17 @@ const STRINGS = {
         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。",
+        open: "打开 ClaudeRipple…",
+        directHeadline: "正在使用 Claude 默认连接（Ripple 已关闭）",
+        tooltipDirect: "ClaudeRipple：正在使用 Claude 默认连接",
+        notifyDownTitle: "Ripple 没有响应",
+        notifyDownBody: "Claude 现在无法连接 AI。可以修复 Ripple，或切换到 Claude 默认连接。",
+        actRepair: "修复",
+        actDirectOn: "切换到 Claude 默认连接",
+        restartConfirm: "要退出并重新打开 Claude 应用吗？",
+        restartConfirmDetail: "Claude 应用中打开的对话和进行中的工作会停止。",
+        restartNow: "重新打开",
         setupNeeded: "设置未完成",
         setupNeededDetail: "ClaudeRipple 已安装，但尚未完成设置",
         runSetup: "完成 ClaudeRipple 设置…",
@@ -293,11 +320,17 @@ const STRINGS = {
         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を再読み込みしてください。",
+        open: "ClaudeRippleを開く…",
+        directHeadline: "Claude の標準接続を使用中（Ripple はオフ）",
+        tooltipDirect: "ClaudeRipple：Claude の標準接続を使用中",
+        notifyDownTitle: "Ripple が応答しません",
+        notifyDownBody: "現在 Claude は AI に接続できません。Ripple を修復するか、Claude の標準接続に切り替えられます。",
+        actRepair: "修復",
+        actDirectOn: "Claude の標準接続に切り替え",
+        restartConfirm: "Claude アプリを終了して開き直しますか？",
+        restartConfirmDetail: "Claude アプリで開いている会話や進行中の作業は止まります。",
+        restartNow: "開き直す",
         setupNeeded: "セットアップ未完了",
         setupNeededDetail: "ClaudeRippleはインストール済みですが、まだセットアップされていません",
         runSetup: "ClaudeRippleのセットアップを完了…",
@@ -369,11 +402,17 @@ const STRINGS = {
         proxyLine: (host, port, slots, flight) => `Proxy ${host}:${port} · ${slots} · ${flight}`,
         startAtLogin: "Abrir al iniciar sesión",
         downNotifyTitle: "Claude Desktop no puede conectarse",
-        downNotifyBody: "El router de ClaudeRipple no está en ejecución, así que Claude Desktop no puede conectarse. Haz clic para iniciarlo.",
         starting: "iniciando el router…",
-        openDashboard: "Abrir el panel en el navegador…",
-        offlineHeading: "El router no está en ejecución",
-        offlineBody: "Claude Desktop envía todo su tráfico a través de ClaudeRipple, así que mientras el router esté detenido la app muestra una ventana en blanco con ERR_PROXY_CONNECTION_FAILED. Inicia el router y recarga Claude Desktop.",
+        open: "Abrir ClaudeRipple…",
+        directHeadline: "Conexión predeterminada de Claude (Ripple apagado)",
+        tooltipDirect: "ClaudeRipple: usando la conexión predeterminada de Claude",
+        notifyDownTitle: "Ripple no responde",
+        notifyDownBody: "Claude no puede conectarse a la IA ahora mismo. Repara Ripple o usa la conexión predeterminada de Claude.",
+        actRepair: "Reparar",
+        actDirectOn: "Usar la conexión predeterminada de Claude",
+        restartConfirm: "¿Cerrar y volver a abrir la app de Claude?",
+        restartConfirmDetail: "Las conversaciones abiertas y el trabajo en curso en la app de Claude se detendrán.",
+        restartNow: "Reabrir",
         setupNeeded: "configuración pendiente",
         setupNeededDetail: "ClaudeRipple está instalado, pero aún no está configurado",
         runSetup: "Terminar de configurar ClaudeRipple…",
@@ -445,11 +484,17 @@ const STRINGS = {
         proxyLine: (host, port, slots, flight) => `Proxy ${host}:${port} · ${slots} · ${flight}`,
         startAtLogin: "Iniciar ao fazer login",
         downNotifyTitle: "O Claude Desktop não consegue se conectar",
-        downNotifyBody: "O roteador do ClaudeRipple não está rodando, então o Claude Desktop não consegue acessar a rede. Clique para iniciá-lo.",
         starting: "iniciando o roteador…",
-        openDashboard: "Abrir painel no navegador…",
-        offlineHeading: "O roteador não está rodando",
-        offlineBody: "O Claude Desktop envia todo o tráfego pelo ClaudeRipple, então, enquanto o roteador estiver parado, o app mostra uma janela em branco com ERR_PROXY_CONNECTION_FAILED. Inicie o roteador e recarregue o Claude Desktop.",
+        open: "Abrir o ClaudeRipple…",
+        directHeadline: "Conexão padrão do Claude (Ripple desligado)",
+        tooltipDirect: "ClaudeRipple: usando a conexão padrão do Claude",
+        notifyDownTitle: "O Ripple não está respondendo",
+        notifyDownBody: "O Claude não consegue acessar a IA agora. Repare o Ripple ou use a conexão padrão do Claude.",
+        actRepair: "Reparar",
+        actDirectOn: "Usar a conexão padrão do Claude",
+        restartConfirm: "Encerrar e reabrir o app do Claude?",
+        restartConfirmDetail: "As conversas abertas e o trabalho em andamento no app do Claude vão parar.",
+        restartNow: "Reabrir",
         setupNeeded: "configuração não concluída",
         setupNeededDetail: "O ClaudeRipple está instalado, mas ainda não foi configurado",
         runSetup: "Concluir a configuração do ClaudeRipple…",
@@ -489,6 +534,8 @@ let lastError = null;
 let starting = false;
 let downSince = null;
 let downNotified = false;
+/** Whether the last health poll got an answer; null before the first poll. */
+let answered = null;
 // Long enough that a router still coming up after login does not fire a notification.
 const DOWN_NOTIFY_AFTER_MS = 20_000;
 // ---- login item ------------------------------------------------------------------------
@@ -539,7 +586,16 @@ function setLoginItem(on) {
     }
     writeAppState({ loginItemInitialized: true });
 }
+// Overrides for running this app against stand-ins instead of the real installation (tests, and
+// trying a change without touching the router someone depends on):
+//   CLAUDERIPPLE_APP_ADMIN_URL  the admin API base the health poll and the dashboard use
+//   CLAUDERIPPLE_APP_CLI        a CLI script to run instead of the installed one
+//   CLAUDERIPPLE_APP_USER_DATA  Electron's data folder, which also keys the one-tray lock
+// CLAUDERIPPLE_HOME (logs, app.json, config.json) is honoured as everywhere else.
 function adminUrl() {
+    const override = process.env.CLAUDERIPPLE_APP_ADMIN_URL;
+    if (override)
+        return override.endsWith("/") ? override : `${override}/`;
     return `http://127.0.0.1:${readConfigPorts().admin}/`;
 }
 /**
@@ -554,11 +610,8 @@ function uiLang() {
     const base = first.toLowerCase().split(/[-_]/)[0];
     return base in STRINGS ? base : "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() {
+    const before = answered;
     try {
         const res = await fetch(`${adminUrl()}api/status`, { signal: AbortSignal.timeout(3000) });
         if (!res.ok)
@@ -567,27 +620,57 @@ async function poll() {
         lastError = null;
         downSince = null;
         downNotified = false;
+        answered = true;
         void reconcileRouter(last);
     }
     catch (e) {
         last = null;
         lastError = e.message;
+        answered = false;
         downSince ??= Date.now();
-        // 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) {
+        // An update or one of the window's own actions restarts the router on purpose; that is not
+        // the outage the notification is for. Neither is the direct mode, where the router being off
+        // is the point — so doctor is asked first, and once per outage. With the window on screen the
+        // user is already looking at the same news.
+        if ((0, status_model_1.shouldNotifyDown)({ downForMs: Date.now() - downSince, graceMs: DOWN_NOTIFY_AFTER_MS, alreadyNotified: downNotified, updating, busy: !!rec.busy || (0, window_1.windowVisible)(), mode: rec.doctor?.mode ?? null })) {
             downNotified = true;
-            notifyDown();
+            void refreshDoctor().then(() => {
+                if (!last && rec.doctor?.mode !== "direct")
+                    notifyDown();
+            });
         }
     }
+    // Up or down changed: what doctor said about the rest (direct, mixed) may have changed with it.
+    if (before !== null && before !== answered && !rec.busy)
+        void refreshDoctor();
     render();
 }
-/** The router being down means Claude Desktop is dead in the water, so say so out loud. */
+// Held so the handlers are not collected with it before the user gets to the notification.
+let downNotification = null;
+/** The router being down means Claude is silent, so say so out loud, with the two ways out. */
 function notifyDown() {
-    if (!electron_1.Notification.isSupported())
+    if (!electron_1.Notification.isSupported()) {
+        // Nothing else would tell the user; the window does.
+        showWindow("health");
         return;
-    const n = new electron_1.Notification({ title: L.downNotifyTitle, body: L.downNotifyBody });
-    n.on("click", () => void startRouter());
+    }
+    const n = new electron_1.Notification({
+        title: L.notifyDownTitle,
+        body: L.notifyDownBody,
+        icon: notifyIcon(),
+        // macOS shows these as buttons on the notification (an Options menu when there are two).
+        actions: [
+            { type: "button", text: L.actRepair },
+            { type: "button", text: L.actDirectOn },
+        ],
+    });
+    n.on("click", () => showWindow("health"));
+    n.on("action", (_event, index) => {
+        showWindow("health");
+        void act(index === 0 ? "repair" : "direct-on");
+    });
     n.show();
+    downNotification = n;
 }
 /** Idempotent: `clauderipple start` leaves a router that is already coming up alone. */
 async function startRouter() {
@@ -618,33 +701,28 @@ const isMac = process.platform === "darwin";
  * 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 mac = { ok: "trayTemplate.png", warn: "trayWarnTemplate.png", down: "trayDownTemplate.png", direct: "trayDirectTemplate.png" };
+    const win = { ok: "trayWin.png", warn: "trayWinWarn.png", down: "trayWinDown.png", direct: "trayWinDirect.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 app icon on notifications: macOS uses the bundle's own; elsewhere Electron would show its default. */
+function notifyIcon() {
+    return isMac ? undefined : node_path_1.default.join(__dirname, "..", "assets", "icon.png");
+}
 /**
- * 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.
+ * The dashboard window. It opens with the router down too (its page is the app's own), and then on
+ * Status, where the way back is. Before setup there is no router to ask anything of, so the step
+ * that is actually missing comes first.
  */
 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;
+    if (!last && needsSetup()) {
+        await setup();
+        await poll();
     }
-    await electron_1.dialog.showMessageBox({ type: "warning", message: L.offlineHeading, detail: [L.offlineBody, message].filter(Boolean).join("\n\n") });
+    showWindow(last ? undefined : "health");
 }
 // ---- update handling -------------------------------------------------------------------
 // Installing a new version replaces files, not the process: the supervisor started the router at
@@ -690,7 +768,7 @@ async function reconcileRouter(s) {
     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();
+        new electron_1.Notification({ title: L.updatedTitle(electron_1.app.getVersion()), body: L.updatedRestarting(from), icon: notifyIcon() }).show();
     const outputs = [];
     if (installedElsewhere || runningElsewhere)
         outputs.push(await runCli(["install"]));
@@ -721,6 +799,9 @@ function packagedRuntime() {
 }
 /** Prefer this app's bundled Electron runtime; existing installations retain their recorded runtime. */
 function cliPaths() {
+    const override = process.env.CLAUDERIPPLE_APP_CLI;
+    if (override)
+        return { node: process.execPath, env: { ELECTRON_RUN_AS_NODE: "1" }, cli: override };
     const packaged = packagedRuntime();
     if (packaged && node_fs_1.default.existsSync(packaged.cli))
         return packaged;
@@ -743,15 +824,204 @@ function cliPaths() {
 function runCli(args) {
     return runCliResult(args).then((r) => r.output);
 }
-function runCliResult(args) {
+/**
+ * Runs the CLI without blocking anything. `stdout` is kept apart for the `--json` commands, whose
+ * one object must not be mixed with warnings on stderr. With `timeoutMs` a CLI that hangs (a
+ * supervisor that never answers) is ended rather than left holding a button down.
+ */
+function runCliResult(args, timeoutMs = 0) {
     const { node, env, cli } = cliPaths();
     return new Promise((resolve) => {
         // 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() });
+        (0, node_child_process_1.execFile)(node, [cli, ...args], { env: { ...process.env, ...env, CLAUDERIPPLE_HOME: home }, maxBuffer: 16 * 1024 * 1024, timeout: timeoutMs, windowsHide: true }, (err, stdout, stderr) => {
+            const timedOut = !!err && timeoutMs > 0 && err.killed === true;
+            resolve({ ok: !err, output: `${stdout}${stderr}${err ? `\n${err.message}` : ""}`.trim(), stdout: String(stdout), timedOut });
         });
     });
 }
+// ---- recovery: doctor, repair, direct -----------------------------------------------------
+// The CLI does the work and answers in JSON; this keeps what it last said and what is running,
+// and hands both to the dashboard (window.rippleApp) to draw its connection card.
+const ACTION_TIMEOUT_MS = 40_000;
+const DOCTOR_TIMEOUT_MS = 15_000;
+/** Background check, mainly to notice the direct mode while the router is still answering. */
+const DOCTOR_EVERY_MS = 5 * 60_000;
+/** While the window is open it should not show something a minute old. */
+const DOCTOR_WHILE_OPEN_MS = 10_000;
+const LOG_LINES = 40;
+const rec = {
+    doctor: null,
+    doctorFailed: false,
+    busy: null,
+    result: null,
+    restartClaude: false,
+};
+let doctorRun = null;
+/** One `doctor` at a time; callers that arrive while one runs share it. */
+function refreshDoctor() {
+    doctorRun ??= (async () => {
+        const r = await runCliResult(["doctor", "--json"], DOCTOR_TIMEOUT_MS);
+        const d = (0, status_model_1.parseJsonOutput)(r.stdout);
+        rec.doctor = d;
+        rec.doctorFailed = !d;
+    })().finally(() => {
+        doctorRun = null;
+        render();
+    });
+    return doctorRun;
+}
+/** The end of router.log, read from disk: it is there to look at precisely when the router is not. */
+function logTail() {
+    const file = node_path_1.default.join(home, "logs", "router.log");
+    try {
+        const size = node_fs_1.default.statSync(file).size;
+        const length = Math.min(size, 16 * 1024);
+        const fd = node_fs_1.default.openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(length);
+            node_fs_1.default.readSync(fd, buf, 0, length, size - length);
+            return (0, status_model_1.tailLines)(buf.toString("utf8"), LOG_LINES).map((l) => (l.length > 400 ? `${l.slice(0, 400)}…` : l));
+        }
+        finally {
+            node_fs_1.default.closeSync(fd);
+        }
+    }
+    catch {
+        return [];
+    }
+}
+/** What the dashboard's connection card is drawn from. */
+function bridgeState() {
+    return {
+        doctor: rec.doctor,
+        doctorFailed: rec.doctorFailed,
+        routerAnswering: answered,
+        busy: rec.busy,
+        result: rec.result,
+        restartClaude: rec.restartClaude,
+        loginItem: loginItemOn(),
+        appVersion: electron_1.app.getVersion(),
+        platform: process.platform,
+    };
+}
+let lastSent = "";
+/** Tells the open window, if any, when the state changed (render() runs on every poll). */
+function pushState() {
+    if (!(0, window_1.mainWindow)())
+        return;
+    const state = bridgeState();
+    const key = JSON.stringify(state);
+    if (key === lastSent)
+        return;
+    lastSent = key;
+    (0, window_1.sendToWindow)("ripple-app:state", state);
+}
+function showWindow(view) {
+    (0, window_1.openWindow)({
+        lang: uiLang(),
+        savedBounds: () => appState().window ?? null,
+        saveBounds: (bounds) => writeAppState({ window: bounds }),
+        shown: () => {
+            lastSent = "";
+            if (!rec.busy)
+                void refreshDoctor();
+        },
+    }, view);
+}
+const BRIDGE_ACTIONS = new Set(["repair", "direct-on", "direct-off", "restart-claude", "refresh", "login-item", "logs"]);
+/** Only our own page may drive the bridge, never something it navigated to. */
+function fromOurPage(event) {
+    return (event.senderFrame?.url ?? "").startsWith(`${protocol_1.ORIGIN}/`);
+}
+function wireBridge() {
+    electron_1.ipcMain.handle("ripple-app:state", (event) => (fromOurPage(event) ? bridgeState() : null));
+    electron_1.ipcMain.handle("ripple-app:log", (event) => (fromOurPage(event) ? logTail() : []));
+    electron_1.ipcMain.handle("ripple-app:act", async (event, id) => {
+        if (!fromOurPage(event) || typeof id !== "string" || !BRIDGE_ACTIONS.has(id))
+            return null;
+        await act(id);
+        return bridgeState();
+    });
+}
+async function act(id) {
+    switch (id) {
+        case "repair":
+            return runAction("repair", ["repair", "--json"]);
+        case "direct-on":
+            return runAction("direct-on", ["direct", "on", "--json"]);
+        case "direct-off":
+            return runAction("direct-off", ["direct", "off", "--json"]);
+        case "restart-claude":
+            return restartClaude();
+        case "logs":
+            node_fs_1.default.mkdirSync(node_path_1.default.join(home, "logs"), { recursive: true });
+            void electron_1.shell.openPath(node_path_1.default.join(home, "logs"));
+            return;
+        case "refresh":
+            if (rec.busy)
+                return;
+            rec.busy = "checking";
+            render();
+            await Promise.all([poll(), refreshDoctor()]);
+            rec.busy = null;
+            render();
+            return;
+        case "login-item":
+            setLoginItem(true);
+            render();
+            return;
+    }
+}
+async function runAction(action, args) {
+    if (rec.busy)
+        return;
+    rec.busy = action;
+    rec.result = null;
+    render();
+    const r = await runCliResult(args, ACTION_TIMEOUT_MS);
+    const out = (0, status_model_1.parseJsonOutput)(r.stdout);
+    const ok = !r.timedOut && out?.ok === true;
+    const details = action === "repair"
+        ? (0, status_model_1.repairDetails)(out, r.output)
+        : [out?.detail ?? "", ...(ok ? [] : (0, status_model_1.tailLines)(out ? "" : r.output, 8))].filter(Boolean);
+    rec.result = { action, ok, timedOut: r.timedOut, details, at: Date.now() };
+    if (ok && out?.restartClaude)
+        rec.restartClaude = true;
+    if (out?.doctor) {
+        rec.doctor = out.doctor;
+        rec.doctorFailed = false;
+    }
+    rec.busy = null;
+    await poll();
+    if (!out?.doctor)
+        await refreshDoctor();
+    render();
+}
+async function restartClaude() {
+    if (rec.busy)
+        return;
+    const options = {
+        type: "question",
+        message: L.restartConfirm,
+        detail: L.restartConfirmDetail,
+        buttons: [L.restartNow, L.cancel],
+        defaultId: 0,
+        cancelId: 1,
+    };
+    const parent = (0, window_1.mainWindow)();
+    const choice = parent ? await electron_1.dialog.showMessageBox(parent, options) : await electron_1.dialog.showMessageBox(options);
+    if (choice.response !== 0)
+        return;
+    rec.busy = "restart-claude";
+    rec.result = null;
+    render();
+    const ok = await (0, claude_desktop_1.reopenClaude)();
+    rec.busy = null;
+    rec.result = { action: "restart-claude", ok, details: [], at: Date.now() };
+    if (ok)
+        rec.restartClaude = false;
+    render();
+}
 let availableUpdate = null;
 let updating = false;
 const UPDATE_CHECK_MS = 12 * 60 * 60 * 1000;
@@ -797,7 +1067,7 @@ async function offerUpdate(check) {
     render();
     const version = check.latest ?? "";
     if (electron_1.Notification.isSupported())
-        new electron_1.Notification({ title: "ClaudeRipple", body: L.updating(version) }).show();
+        new electron_1.Notification({ title: "ClaudeRipple", body: L.updating(version), icon: notifyIcon() }).show();
     const r = await runCliResult(["update"]);
     updating = false;
     if (!r.ok) {
@@ -807,7 +1077,7 @@ async function offerUpdate(check) {
     }
     availableUpdate = null;
     if (electron_1.Notification.isSupported())
-        new electron_1.Notification({ title: "ClaudeRipple", body: L.updateDone(version) }).show();
+        new electron_1.Notification({ title: "ClaudeRipple", body: L.updateDone(version), icon: notifyIcon() }).show();
     // A new tray from the new files, then this one goes. The lock is let go first, or the new tray
     // would see this one and leave.
     electron_1.app.releaseSingleInstanceLock();
@@ -862,10 +1132,14 @@ function windowsText(quota) {
         .join(" · ");
 }
 function render() {
+    pushState();
     if (!tray)
         return;
     const state = healthy(last);
-    tray.setImage(icon(state));
+    // The direct mode is chosen, not broken: its own mark, and no "cannot connect" line.
+    const shown = (0, status_model_1.trayState)(state, rec.doctor);
+    const direct = shown === "direct";
+    tray.setImage(icon(shown));
     const s = last;
     const quota = Object.values(s?.chatgpt?.quota ?? {}).find((q) => q);
     const quotaLine = quota?.rate_limits?.primary
@@ -877,22 +1151,29 @@ function render() {
     // "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}`;
+    const headline = direct
+        ? `ClaudeRipple · ${L.directHeadline}`
+        : 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 detail = direct
+        ? null
+        : s
+            ? [connected ? L.connected : L.notConnected, ...problems, quotaLine].filter(Boolean).join(" · ")
+            : 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 = [
+        // First, because it is the way back when nothing else works: the window needs no router.
+        { label: L.open, click: () => void openDashboard() },
+        { type: "separator" },
         { label: headline, click: () => void openDashboard() },
         ...(detail ? [{ label: detail, click: () => void openDashboard() }] : []),
         ...claudeLines,
@@ -900,8 +1181,6 @@ function render() {
             ? [{ 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() },
         { label: L.startAtLogin, type: "checkbox", checked: loginItemOn(), click: (item) => setLoginItem(item.checked) },
         { type: "separator" },
         { label: unconfigured ? L.runSetup : L.rerunSetup, click: () => void setup() },
@@ -924,14 +1203,38 @@ function render() {
         { label: L.quit, role: "quit" },
     ];
     tray.setContextMenu(electron_1.Menu.buildFromTemplate(template));
-    tray.setToolTip(s ? L.tooltip(state) : L.tooltipDown);
+    tray.setToolTip(direct ? L.tooltipDirect : s ? L.tooltip(state) : L.tooltipDown);
 }
+/**
+ * The dashboard this app draws: the copy of packages/ui inside a packaged build, else the one next
+ * to the tray's own folder (a checkout's packages/ui, an npm install's dist/ui — the same files the
+ * router serves).
+ */
+function uiRoot() {
+    const resources = process.resourcesPath;
+    const candidates = [
+        ...(resources ? [node_path_1.default.join(resources, "clauderipple", "packages", "ui")] : []),
+        node_path_1.default.resolve(__dirname, "..", "..", "ui"),
+    ];
+    return candidates.find((dir) => node_fs_1.default.existsSync(node_path_1.default.join(dir, "index.html"))) ?? candidates[candidates.length - 1];
+}
+(0, protocol_1.registerScheme)();
 // One tray. `clauderipple tray` run while one is up started a second icon (Windows VM,
 // 2026-10-10); the newcomer now leaves at once with code 0, which the CLI reads as "already running".
+if (process.env.CLAUDERIPPLE_APP_USER_DATA)
+    electron_1.app.setPath("userData", process.env.CLAUDERIPPLE_APP_USER_DATA);
 if (!electron_1.app.requestSingleInstanceLock())
     electron_1.app.exit(0);
+// Opening the app again (Finder, Start menu, `clauderipple tray`) while it already runs in the
+// tray is someone looking for it: bring the window forward rather than nothing.
+electron_1.app.on("second-instance", () => {
+    if (electron_1.app.isReady())
+        showWindow(last ? undefined : "health");
+});
 electron_1.app.whenReady().then(() => {
     L = STRINGS[uiLang()];
+    (0, protocol_1.handleScheme)(uiRoot(), adminUrl);
+    wireBridge();
     // Without this, Windows attributes our notifications to "Electron" instead of ClaudeRipple.
     if (process.platform === "win32")
         electron_1.app.setAppUserModelId("com.clauderipple.app");
@@ -950,8 +1253,18 @@ electron_1.app.whenReady().then(() => {
     tray = new electron_1.Tray(icon("down"));
     tray.on("click", () => tray?.popUpContextMenu());
     render();
+    // Opened from its icon (the CLI sets this; a login launch does not): show the window, not just a
+    // tray icon the person may never notice. Taken out so an update's relaunch does not inherit it.
+    if (process.env.CLAUDERIPPLE_APP_SHOW === "1") {
+        delete process.env.CLAUDERIPPLE_APP_SHOW;
+        showWindow("health");
+    }
     void poll();
     setInterval(() => void poll(), POLL_MS);
+    // What the health poll cannot see (the direct mode, a supervisor gone missing) comes from doctor.
+    setTimeout(() => void refreshDoctor(), 3_000);
+    setInterval(() => void (!rec.busy && refreshDoctor()), DOCTOR_EVERY_MS);
+    setInterval(() => void ((0, window_1.windowVisible)() && !rec.busy && refreshDoctor()), DOCTOR_WHILE_OPEN_MS);
     if (needsSetup())
         void promptForSetup();
     // Not at the very start: a tray opened at login shares the first minute with everything else.