clauderipple 0.9.5 → 0.11.0

package/dist/app/dist/preload.js

@@ -0,0 +1,21 @@
+"use strict";
+// window.rippleApp — what the dashboard can ask of the app it runs in, and nothing more: the
+// connection state, and the recovery actions that work with the router dead (they run the CLI in
+// the main process). In a plain browser the object does not exist and the dashboard behaves as it
+// always has. The page runs sandboxed with context isolation.
+const { contextBridge, ipcRenderer } = require("electron");
+contextBridge.exposeInMainWorld("rippleApp", {
+    platform: process.platform,
+    state: () => ipcRenderer.invoke("ripple-app:state"),
+    onState: (callback) => {
+        ipcRenderer.on("ripple-app:state", (_event, state) => callback(state));
+    },
+    refresh: () => ipcRenderer.invoke("ripple-app:act", "refresh"),
+    repair: () => ipcRenderer.invoke("ripple-app:act", "repair"),
+    directOn: () => ipcRenderer.invoke("ripple-app:act", "direct-on"),
+    directOff: () => ipcRenderer.invoke("ripple-app:act", "direct-off"),
+    restartClaude: () => ipcRenderer.invoke("ripple-app:act", "restart-claude"),
+    enableLoginItem: () => ipcRenderer.invoke("ripple-app:act", "login-item"),
+    openLogs: () => ipcRenderer.invoke("ripple-app:act", "logs"),
+    recentLog: () => ipcRenderer.invoke("ripple-app:log"),
+});

package/dist/app/dist/protocol.js

@@ -0,0 +1,121 @@
+"use strict";
+// ripple://app/ — the dashboard drawn from this app's own copy of packages/ui, with /api/* passed
+// on to the router's admin port. The router used to serve the page too, so when it died the
+// dashboard died with it, exactly when it was needed (2026-10-20). Now only the data needs the
+// router; a router that does not answer gives a 503 the dashboard reads as "Ripple is down".
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORIGIN = exports.SCHEME = void 0;
+exports.registerScheme = registerScheme;
+exports.routerDownResponse = routerDownResponse;
+exports.handleScheme = handleScheme;
+const electron_1 = require("electron");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = require("node:stream");
+const status_model_1 = require("./status-model");
+exports.SCHEME = "ripple";
+exports.ORIGIN = `${exports.SCHEME}://app`;
+/** Before app ready: a standard, secure scheme gets an origin, localStorage, fetch and the page's CSP 'self'. */
+function registerScheme() {
+    electron_1.protocol.registerSchemesAsPrivileged([{ scheme: exports.SCHEME, privileges: { standard: true, secure: true, supportFetchAPI: true, stream: true } }]);
+}
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".json": "application/json",
+    ".ico": "image/x-icon",
+};
+/** Quick enough that a dead router reads as dead, long enough for a login or a provider probe. */
+const CONNECT_TIMEOUT_MS = 4_000;
+const IDLE_TIMEOUT_MS = 180_000;
+function json(status, body) {
+    return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json", "cache-control": "no-store" } });
+}
+function routerDownResponse() {
+    return json(503, { error: "ClaudeRipple is not running", routerDown: true });
+}
+/**
+ * The admin API, asked as the CLI and the tray ask it: no Origin header (the router turns away a
+ * cross-site Origin on writes, and a custom scheme's would be one) and a Host it accepts.
+ */
+async function forward(request, admin) {
+    const url = new URL(request.url);
+    const body = request.method === "GET" || request.method === "HEAD" ? null : Buffer.from(await request.arrayBuffer());
+    const headers = { host: `127.0.0.1:${admin.port}`, accept: request.headers.get("accept") ?? "*/*" };
+    const type = request.headers.get("content-type");
+    if (type)
+        headers["content-type"] = type;
+    if (body)
+        headers["content-length"] = String(body.length);
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (response) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(response);
+        };
+        const req = node_http_1.default.request(
+        // A connection of its own per request: the idle timer below is set on the socket, and on a
+        // pooled socket those timers piled up (MaxListenersExceededWarning, measured here).
+        { host: admin.hostname, port: admin.port, method: request.method, path: `${url.pathname}${url.search}`, headers, agent: false }, (res) => {
+            clearTimeout(connectTimer);
+            res.socket?.setTimeout(IDLE_TIMEOUT_MS, () => res.destroy());
+            const out = new Headers();
+            for (const name of ["content-type", "cache-control", "content-disposition"]) {
+                const value = res.headers[name];
+                if (typeof value === "string")
+                    out.set(name, value);
+            }
+            const status = res.statusCode ?? 502;
+            const nullBody = status === 204 || status === 304 || request.method === "HEAD";
+            if (nullBody)
+                res.resume();
+            done(new Response(nullBody ? null : node_stream_1.Readable.toWeb(res), { status, headers: out }));
+        });
+        const connectTimer = setTimeout(() => {
+            req.destroy();
+            done(routerDownResponse());
+        }, CONNECT_TIMEOUT_MS);
+        req.on("error", () => {
+            clearTimeout(connectTimer);
+            done(routerDownResponse());
+        });
+        if (body)
+            req.write(body);
+        req.end();
+    });
+}
+async function serveFile(root, rel) {
+    const full = node_path_1.default.resolve(root, rel);
+    if (full !== root && !full.startsWith(root.endsWith(node_path_1.default.sep) ? root : root + node_path_1.default.sep))
+        return json(400, { error: "invalid path" });
+    try {
+        const data = await node_fs_1.default.promises.readFile(full);
+        return new Response(data, { status: 200, headers: { "content-type": MIME[node_path_1.default.extname(full).toLowerCase()] ?? "application/octet-stream", "cache-control": "no-cache" } });
+    }
+    catch {
+        return json(404, { error: "not found" });
+    }
+}
+/** After app ready. `admin` is read per request, so a port changed in config.json is followed. */
+function handleScheme(uiRoot, admin) {
+    electron_1.protocol.handle(exports.SCHEME, async (request) => {
+        const url = new URL(request.url);
+        if (url.host !== "app")
+            return json(404, { error: "not found" });
+        const route = (0, status_model_1.routeRequest)(url.pathname);
+        if (!route)
+            return json(400, { error: "invalid path" });
+        if (route.kind === "api")
+            return forward(request, new URL(admin()));
+        return serveFile(uiRoot, route.rel);
+    });
+}

package/dist/app/dist/status-model.js

@@ -0,0 +1,87 @@
+"use strict";
+// The tray's reading of what `clauderipple doctor` / `repair` / `direct` answer. Pure: no Electron,
+// no I/O, so `node --test` runs it as it is. What the dashboard draws from the same answers lives in
+// packages/ui/app.js (the connection card); this is only what the main process decides itself.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonOutput = parseJsonOutput;
+exports.tailLines = tailLines;
+exports.trayState = trayState;
+exports.shouldNotifyDown = shouldNotifyDown;
+exports.repairDetails = repairDetails;
+exports.routeRequest = routeRequest;
+/**
+ * The CLI prints one JSON object on stdout. Anything else on stdout (a warning a dependency printed,
+ * a stray blank line) must not lose it, so the last line that parses as an object wins, and failing
+ * that the whole text.
+ */
+function parseJsonOutput(stdout) {
+    const lines = stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const parsed = tryObject(lines[i]);
+        if (parsed)
+            return parsed;
+    }
+    const whole = tryObject(stdout.trim());
+    return whole ? whole : null;
+}
+function tryObject(text) {
+    if (!text.startsWith("{"))
+        return null;
+    try {
+        const value = JSON.parse(text);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The last `count` non-empty lines of a log's tail. */
+function tailLines(text, count) {
+    return text.split(/\r?\n/).filter((l) => l.trim().length > 0).slice(-count);
+}
+/** The tray icon: the direct mode is a choice, not an outage, and gets its own mark. */
+function trayState(health, doctor) {
+    if (doctor?.mode === "direct")
+        return "direct";
+    return health;
+}
+/**
+ * Whether the "Ripple is not responding" notification should go out now. Once per outage (the
+ * caller clears `alreadyNotified` when the router answers again), not while an update or one of our
+ * own actions restarts it on purpose, and never in the direct mode, where the router being off is
+ * the point.
+ */
+function shouldNotifyDown(o) {
+    return !o.alreadyNotified && !o.updating && !o.busy && o.downForMs >= o.graceMs && o.mode !== "direct";
+}
+/** Lines for the "Details" fold after a repair: each step as ✓/✗ with what it said. */
+function repairDetails(out, raw) {
+    if (!out?.steps?.length)
+        return raw ? tailLines(raw, 12) : [];
+    return out.steps.map((s) => `${s.ok ? "✓" : "✗"} ${s.name ?? "?"}${s.detail ? ` — ${s.detail}` : ""}`);
+}
+/**
+ * Where a ripple:// request goes: the dashboard's own files, or the router's admin API. Returns
+ * null for a path that would leave the UI folder.
+ */
+function routeRequest(pathname) {
+    if (pathname === "/api" || pathname.startsWith("/api/"))
+        return { kind: "api" };
+    let decoded;
+    try {
+        decoded = decodeURIComponent(pathname);
+    }
+    catch {
+        return null;
+    }
+    if (decoded.includes("\0"))
+        return null;
+    const rel = decoded === "/" || decoded === "" ? "index.html" : decoded === "/favicon.ico" ? "favicon-32.png" : decoded.replace(/^\/+/, "");
+    const parts = rel.split(/[\\/]+/);
+    if (parts.some((p) => p === ".." || p === ""))
+        return null;
+    // A path with no extension is the dashboard routing itself (as the router serves it).
+    if (!/\.[a-z0-9]+$/i.test(rel))
+        return { kind: "file", rel: "index.html" };
+    return { kind: "file", rel };
+}

package/dist/app/dist/window.js

@@ -0,0 +1,133 @@
+"use strict";
+// The app's one window: the whole dashboard, served from the app itself (protocol.ts), so it opens
+// and can repair things with the router dead. A preload bridge (preload.ts) gives the dashboard the
+// few things only the app can do: doctor, repair, the direct switch, reopening Claude.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openWindow = openWindow;
+exports.mainWindow = mainWindow;
+exports.windowVisible = windowVisible;
+exports.sendToWindow = sendToWindow;
+const electron_1 = require("electron");
+const node_path_1 = __importDefault(require("node:path"));
+const protocol_1 = require("./protocol");
+const DEFAULT = { width: 1040, height: 740 };
+const MIN = { width: 760, height: 540 };
+let win = null;
+/** A saved position is used only if most of it is still on some display (a monitor may be gone). */
+function fits(b) {
+    return electron_1.screen.getAllDisplays().some(({ workArea: a }) => {
+        const w = Math.min(b.x + b.width, a.x + a.width) - Math.max(b.x, a.x);
+        const h = Math.min(b.y + b.height, a.y + a.height) - Math.max(b.y, a.y);
+        return w >= Math.min(200, b.width) && h >= Math.min(120, b.height);
+    });
+}
+function isOurs(url) {
+    return url.startsWith(`${protocol_1.ORIGIN}/`) || url === protocol_1.ORIGIN;
+}
+/**
+ * Opens the window, or brings it forward. `view` is a dashboard section ("health", "slots", …):
+ * the tray asks for "health" when something is wrong.
+ */
+function openWindow(deps, view) {
+    if (win && !win.isDestroyed()) {
+        if (view)
+            void win.webContents.executeJavaScript(`location.hash = ${JSON.stringify(`#${view}`)}`).catch(() => undefined);
+        if (win.isMinimized())
+            win.restore();
+        win.show();
+        focusApp();
+        win.focus();
+        deps.shown();
+        return;
+    }
+    const saved = deps.savedBounds();
+    const bounds = saved && fits(saved) ? saved : null;
+    const mac = process.platform === "darwin";
+    win = new electron_1.BrowserWindow({
+        ...(bounds ?? DEFAULT),
+        minWidth: MIN.width,
+        minHeight: MIN.height,
+        show: false,
+        title: "ClaudeRipple",
+        // The dashboard's own sidebar sits under the traffic lights; elsewhere the system frame stays.
+        ...(mac ? { titleBarStyle: "hiddenInset", trafficLightPosition: { x: 18, y: 18 } } : {}),
+        // Its first frame is the page's own background, not a white flash in dark mode.
+        backgroundColor: electron_1.nativeTheme.shouldUseDarkColors ? "#1c1c1e" : "#f5f5f7",
+        autoHideMenuBar: true,
+        // The app icon (macOS takes it from the bundle): Windows reads every size from the .ico.
+        icon: mac ? undefined : node_path_1.default.join(__dirname, "..", "assets", process.platform === "win32" ? "icon.ico" : "icon.png"),
+        webPreferences: {
+            preload: node_path_1.default.join(__dirname, "preload.js"),
+            contextIsolation: true,
+            sandbox: true,
+            nodeIntegration: false,
+            spellcheck: false,
+        },
+    });
+    if (!mac)
+        win.removeMenu();
+    // Links the dashboard opens (release notes, sign-in pages) belong in the user's browser.
+    win.webContents.setWindowOpenHandler(({ url }) => {
+        if (/^https?:\/\//i.test(url))
+            void electron_1.shell.openExternal(url);
+        return { action: "deny" };
+    });
+    win.webContents.on("will-navigate", (event, url) => {
+        if (isOurs(url))
+            return;
+        event.preventDefault();
+        if (/^https?:\/\//i.test(url))
+            void electron_1.shell.openExternal(url);
+    });
+    const remember = () => {
+        if (win && !win.isDestroyed() && !win.isMinimized() && !win.isFullScreen())
+            deps.saveBounds(win.getNormalBounds());
+    };
+    win.on("resized", remember);
+    win.on("moved", remember);
+    win.on("close", remember);
+    win.once("ready-to-show", () => {
+        win?.show();
+        focusApp();
+        win?.focus();
+        dockIcon();
+    });
+    win.on("closed", () => {
+        win = null;
+        // A tray app again once its window is gone.
+        if (mac)
+            electron_1.app.dock?.hide();
+    });
+    if (mac) {
+        // The window's Dock icon is the running bundle's: installed from npm that is Electron.app, so the
+        // Dock showed Electron's atom (2026-10-20). Ours is set on it whatever bundle runs, once the Dock
+        // icon is up: set while the app had none, it was dropped when show() put the bundle's back.
+        void electron_1.app.dock?.show().then(dockIcon);
+    }
+    void win.loadURL(`${protocol_1.ORIGIN}/?lang=${encodeURIComponent(deps.lang)}${view ? `#${view}` : ""}`);
+    deps.shown();
+}
+/** Our icon on the Dock, on macOS: set again once the window shows, which put the bundle's back. */
+function dockIcon() {
+    if (process.platform === "darwin")
+        electron_1.app.dock?.setIcon(node_path_1.default.join(__dirname, "..", "assets", "icon.png"));
+}
+/** The tray app has no Dock icon until a window opens, so a window opened from it could come up behind the frontmost app. */
+function focusApp() {
+    if (process.platform === "darwin")
+        electron_1.app.focus({ steal: true });
+}
+function mainWindow() {
+    return win && !win.isDestroyed() ? win : null;
+}
+function windowVisible() {
+    return !!win && !win.isDestroyed() && win.isVisible() && !win.isMinimized();
+}
+/** Sends the bridge's state to the page, if the window is open. */
+function sendToWindow(channel, payload) {
+    if (win && !win.isDestroyed())
+        win.webContents.send(channel, payload);
+}

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.9.5",
+  "version": "0.11.0",
   "type": "commonjs"
 }