clauderipple 0.9.5 → 0.11.0

package/dist/router/src/admin.js

@@ -14,8 +14,12 @@
 //   PATCH/DELETE /api/google-accounts/:id rename, pause/resume, clear a cooldown; remove
 //   GET  /api/update    whether a newer version is published, and how this copy was installed
 //   POST /api/update    start `clauderipple update` in the background (it restarts this router)
+//   GET  /api/power     lid-closed awake + hotspot failover state (power.ts)
+//   PUT  /api/power     change awake mode/until, tether on/off (saved), pin (in memory)
+//   POST /api/power/setup  start `clauderipple awake setup [--ssid]` (macOS password dialog); GET polls it
 //   GET  /*           static files from packages/ui (the GUI itself)
 import crypto from "node:crypto";
+import { phoneRequest } from "./phone.js";
 import fs from "node:fs";
 import net from "node:net";
 import os from "node:os";
@@ -23,7 +27,7 @@ import path from "node:path";
 import http from "node:http";
 import { execFile, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { adminPort, headerValueProblem, homeDir, searchProviderFor, validate } from "./config.js";
+import { adminPort, headerValueProblem, homeDir, searchProviderFor, ssidProblem, validate } from "./config.js";
 export { adminPort } from "./config.js";
 import { generatedAgents } from "./agents.js";
 import { isJudgeOnlyModel } from "./model-policy.js";
@@ -51,12 +55,15 @@ import { readClaudeAuthFile } from "./providers/anthropic-token-file.js";
 import { listClaudeAccounts, removeClaudeAccount, renameClaudeAccount, setPreferredClaudeAccount } from "./providers/anthropic-accounts.js";
 import { readChatGptAccounts, removeChatGptAccount, summarize as summarizeChatGptAccount, updateChatGptAccount } from "./providers/chatgpt/accounts.js";
 import { exhaustedForMs, IMAGE_ASPECTS, IMAGE_BACKGROUNDS, IMAGE_FORMATS } from "./providers/chatgpt/index.js";
+import { googleWindowsFromGroups } from "./providers/google/usage.js";
+import { isOpenCodeGo } from "./providers/opencode-usage.js";
 import { ANTIGRAVITY_WARNING, staticAntigravityModels } from "./providers/google/antigravity.js";
 import { readGoogleAccounts, removeGoogleAccount, summarize as summarizeGoogleAccount, updateGoogleAccount } from "./providers/google/accounts.js";
 import { GoogleOAuthSession } from "./providers/google/login.js";
 import { GROK_AUTH_HINT, grokAuthPath, grokHome, readGrokToken, sharedGrokAuth } from "./providers/grok/auth.js";
 import { GROK_DEFAULT_URL, GROK_EFFORT_LEVELS, GROK_FALLBACK_MODELS, grokModelsFromListing } from "./providers/grok/catalog.js";
 import { GROK_WARNING, grokHeaders } from "./providers/grok/index.js";
+import { parsePowerChange, persistPowerChange } from "./power.js";
 const MAX_BODY = 1024 * 1024;
 /** `/api/image` carries reference images inline, so it gets more room than a config save. */
 const MAX_IMAGE_BODY = 32 * 1024 * 1024;
@@ -100,6 +107,145 @@ async function claudeAccountUsage(deps) {
     }
     return rows;
 }
+/** A `{used_percent, window_minutes, reset_at}` snapshot window as `/api/limits` reads it, or null. */
+function limitWindowFrom(w) {
+    if (!w || typeof w !== "object" || Array.isArray(w))
+        return null;
+    const o = w;
+    const used = o.used_percent;
+    if (typeof used !== "number" || !Number.isFinite(used))
+        return null;
+    const minutes = typeof o.window_minutes === "number" && o.window_minutes > 0 ? o.window_minutes : undefined;
+    // A reset already in milliseconds would otherwise park a window for decades; the other readers
+    // normalise the same way (chatgpt windowResetMs).
+    const reset = typeof o.reset_at === "number" && Number.isFinite(o.reset_at) ? Math.round(o.reset_at > 1e12 ? o.reset_at / 1000 : o.reset_at) : undefined;
+    return { used_percent: used, ...(minutes !== undefined ? { window_minutes: minutes } : {}), ...(reset !== undefined ? { reset_at: reset } : {}) };
+}
+/** The kind a five-hour/weekly/other window takes, by its length in minutes. */
+function windowKind(minutes) {
+    return minutes === 300 ? "five_hour" : minutes === 10080 ? "seven_day" : "window";
+}
+/** One Claude subscription account's plan windows: the two main windows and the scoped weeklies. */
+function claudeLimitWindows(quota) {
+    const out = [];
+    const limits = quota.rate_limits;
+    for (const w of [limits?.primary, limits?.secondary]) {
+        const win = limitWindowFrom(w);
+        if (win)
+            out.push({ kind: windowKind(win.window_minutes), used_percent: win.used_percent, ...(win.window_minutes !== undefined ? { window_minutes: win.window_minutes } : {}), ...(win.reset_at !== undefined ? { reset_at: win.reset_at } : {}) });
+    }
+    const scoped = quota.scoped;
+    if (Array.isArray(scoped))
+        for (const s of scoped) {
+            if (!s || typeof s !== "object" || Array.isArray(s))
+                continue;
+            const entry = s;
+            const win = limitWindowFrom(entry);
+            if (!win || typeof entry.name !== "string" || !entry.name)
+                continue;
+            out.push({ kind: "scoped", label: entry.name, used_percent: win.used_percent, ...(win.window_minutes !== undefined ? { window_minutes: win.window_minutes } : {}), ...(win.reset_at !== undefined ? { reset_at: win.reset_at } : {}) });
+        }
+    return out;
+}
+/** The Claude Code login's plan windows as one account (the row shows Claude as a single group). */
+async function anthropicLimitAccounts(deps) {
+    let usage;
+    try {
+        usage = (await deps.claudeUsage?.()) ?? {};
+    }
+    catch {
+        return [];
+    }
+    const quota = usage.current ?? Object.values(usage)[0];
+    if (!quota)
+        return [];
+    const windows = claudeLimitWindows(quota);
+    if (!windows.length)
+        return [];
+    const at = typeof quota.at === "number" ? quota.at : Date.now();
+    return [{ account: 0, windows, at }];
+}
+/** Every ChatGPT account's windows, paused and needs-login accounts left out and unnumbered. */
+function chatgptLimitAccounts(accounts) {
+    const kept = accounts.filter((a) => a.state !== "paused" && a.state !== "needs-login");
+    const out = [];
+    kept.forEach((account, index) => {
+        const quota = account.quota;
+        if (!quota || typeof quota.at !== "number")
+            return;
+        const limits = quota.rate_limits;
+        const windows = [];
+        for (const w of [limits?.primary, limits?.secondary]) {
+            const win = limitWindowFrom(w);
+            if (win)
+                windows.push({ kind: windowKind(win.window_minutes), used_percent: win.used_percent, ...(win.window_minutes !== undefined ? { window_minutes: win.window_minutes } : {}), ...(win.reset_at !== undefined ? { reset_at: win.reset_at } : {}) });
+        }
+        if (windows.length)
+            out.push({ account: index, windows, at: quota.at });
+    });
+    return out;
+}
+/** Every Antigravity account's windows (Gemini's own plus the third-party ones), paused left out. */
+async function googleLimitAccounts(deps, name) {
+    const google = deps.google?.();
+    if (!google)
+        return [];
+    const statuses = google.accounts()[name] ?? [];
+    const groups = (await google.usage?.(name)) ?? {};
+    const kept = statuses.filter((a) => a.state !== "paused" && a.state !== "needs-login");
+    const at = Date.now();
+    // The third-party (Claude and GPT) windows only when this provider has such a model selected:
+    // beside Gemini's own they made four figures, two of them a pool nobody here spends (2026-10-20).
+    const provider = deps.config().providers[name];
+    const models = provider && "models" in provider && Array.isArray(provider.models) ? provider.models : [];
+    const thirdParty = models.some((m) => /^(claude-|gpt-oss(-|$))/i.test(typeof m === "string" ? m : m.id));
+    const out = [];
+    kept.forEach((account, index) => {
+        const quotient = groups[account.id];
+        if (!quotient || !quotient.length)
+            return;
+        const windows = googleWindowsFromGroups(quotient).filter((w) => thirdParty || w.kind !== "scoped");
+        if (windows.length)
+            out.push({ account: index, windows, at });
+    });
+    return out;
+}
+/** Every provider whose quota can be read, in one shape, for `GET /api/limits`. */
+async function buildLimits(deps) {
+    const providers = [];
+    const chatgpt = deps.chatgpt?.();
+    const accounts = chatgpt?.accounts?.() ?? {};
+    for (const [name, p] of Object.entries(deps.config().providers)) {
+        if (p.limits === false)
+            continue;
+        if (p.type === "anthropic" && p.auth === "claude-code") {
+            const rows = await anthropicLimitAccounts(deps);
+            if (rows.length)
+                providers.push({ provider: name, type: "anthropic", title: "Claude", accounts: rows });
+        }
+        else if (p.type === "chatgpt") {
+            const rows = chatgptLimitAccounts(accounts[name] ?? []);
+            if (rows.length)
+                providers.push({ provider: name, type: "chatgpt", title: "GPT", accounts: rows });
+        }
+        else if (p.type === "google" && p.auth === "antigravity") {
+            const rows = await googleLimitAccounts(deps, name);
+            if (rows.length)
+                providers.push({ provider: name, type: "google", title: "Gemini", accounts: rows });
+        }
+        else if (p.type === "openai-compatible" && isOpenCodeGo(p)) {
+            const windows = (await deps.opencodeUsage?.(name)) ?? [];
+            if (windows.length)
+                providers.push({ provider: name, type: "opencode-go", title: "Go", accounts: [{ account: 0, windows: windows.map((w) => ({ ...w })), at: Date.now() }] });
+        }
+        else if (p.type === "grok") {
+            const windows = (await deps.grokUsage?.(name)) ?? [];
+            if (windows.length)
+                providers.push({ provider: name, type: "grok", title: "Grok", accounts: [{ account: 0, windows: windows.map((w) => ({ ...w })), at: Date.now() }] });
+        }
+    }
+    return { providers };
+}
 // The CLI's `--effort` takes the same five; Opus, Sonnet and Haiku 5.5 answered `xhigh` (requests.jsonl, 2026-10-14, #56).
 const ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 const CHATGPT_DEFAULT_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -1030,10 +1176,12 @@ async function probeProvider(body, probeFetch = fetchWithTimeout) {
     const checkModel = presetProbeModel(body.preset) ?? models[0]?.id ?? body.probeModel ?? "test";
     // 16 tokens, as on Responses: some vendors refuse a smaller cap outright (B.ai: "max_tokens must be
     // greater than 2", #57), which read as a failed connection though the key and URL were right.
+    // Streamed, as every translated turn is: the status arrives with the headers, while a reasoning
+    // model answering whole can take past the timeout (Hive: 0.3s streamed, 3–23s whole, 2026-10-18).
     const checkBody = responses
-        ? { model: checkModel, max_output_tokens: 16, stream: false, store: false, input: "hi" }
+        ? { model: checkModel, max_output_tokens: 16, stream: true, store: false, input: "hi" }
         : openai
-            ? { model: checkModel, max_tokens: 16, stream: false, messages: [{ role: "user", content: "hi" }] }
+            ? { model: checkModel, max_tokens: 16, stream: true, messages: [{ role: "user", content: "hi" }] }
             : { model: checkModel, max_tokens: 16, messages: [{ role: "user", content: "hi" }] };
     const label = responses ? "responses endpoint" : openai ? "chat completions endpoint" : "messages endpoint";
     try {
@@ -1051,8 +1199,10 @@ async function probeProvider(body, probeFetch = fetchWithTimeout) {
             const auth = response.status === 403 && refusedByPlan(refusal) ? "not-entitled" : "bad-key";
             return { ok: false, auth, models, error: `${label} returned ${response.status}: ${refusal}` };
         }
-        if (response.ok)
+        if (response.ok) {
+            await response.body?.cancel().catch(() => { });
             return { ok: true, auth: "ok", models, ...(modelsError ? { error: modelsError } : {}) };
+        }
         const detail = snippet(await response.text());
         // A model-validation refusal still demonstrates that the endpoint reached the provider and the key was accepted.
         if (refusedForModel(response.status, detail)) {
@@ -1441,6 +1591,28 @@ async function pickerModels(deps) {
     }
     return { models: await claudeModelList(deps), source: "fallback" };
 }
+/**
+ * Each model's context window, for a client that reads a session's context use without the CLI's own
+ * figure (the phone, for a Claude app session). Claude's from Anthropic's catalog, the CLI's injected
+ * models from their config (else `cli.autoCompactWindow`), providers' from theirs. Unknown is absent.
+ */
+async function contextWindows(deps) {
+    const cfg = deps.config();
+    const windows = {};
+    const put = (id, value) => {
+        if (typeof value === "number" && Number.isFinite(value) && value > 0 && windows[id] === undefined)
+            windows[id] = Math.floor(value);
+    };
+    for (const model of await claudeModelList(deps))
+        put(model.id, model.contextWindow);
+    for (const model of cfg.cli.extraModels)
+        put(model.model, model.contextWindow ?? cfg.cli.autoCompactWindow);
+    for (const provider of Object.values(cfg.providers)) {
+        for (const model of ("models" in provider && provider.models) || [])
+            put(model.id, model.contextWindow);
+    }
+    return { windows };
+}
 function tailLines(file, n) {
     if (!fs.existsSync(file))
         return "";
@@ -1502,6 +1674,8 @@ export function startAdmin(deps) {
     const scores = new ModelScoreCatalog({ home: homeDir(), warn: message => deps.log.warn(message), ...(deps.modelScoresFetch ? { fetch: deps.modelScoresFetch } : {}) });
     // Set again once the socket is bound (port 0 in tests); the Origin check below compares against it.
     let boundPort = adminPort(deps.config());
+    /** The dashboard's `awake setup` run in progress (or the last one), for GET /api/power/setup. */
+    let powerSetup = { running: false };
     const server = http.createServer((req, res) => {
         void handle(req, res);
     });
@@ -1535,6 +1709,28 @@ export function startAdmin(deps) {
                 sendJson(res, 403, { error: "cross-site request refused" });
                 return;
             }
+            if (pathname.startsWith("/api/phone/")) {
+                res.setHeader("cache-control", "no-store");
+                // Pairing is a credential read: guard GETs too, including DNS-rebinding Host values.
+                if (crossSitePost(req) || req.headers["sec-fetch-site"] === "cross-site" ||
+                    !new Set([`127.0.0.1:${boundPort}`, `localhost:${boundPort}`]).has(req.headers.host ?? "")) {
+                    sendJson(res, 403, { error: "same-origin phone control required" });
+                    return;
+                }
+                let body;
+                if (method === "POST" && pathname === "/api/phone/settings") {
+                    try {
+                        body = (await readBody(req, 4096, new Error("phone settings too large"))).toString("utf8");
+                    }
+                    catch {
+                        sendJson(res, 413, { error: "phone settings too large" });
+                        return;
+                    }
+                }
+                const result = await phoneRequest(pathname.slice("/api/phone/".length), method, body, deps.phone);
+                sendJson(res, result.status, result.body);
+                return;
+            }
             if (pathname === "/api/shutdown" && method === "POST") {
                 if (!deps.shutdown) {
                     sendJson(res, 501, { error: "shutdown not available" });
@@ -1546,6 +1742,114 @@ export function startAdmin(deps) {
                 deps.shutdown();
                 return;
             }
+            if (pathname === "/api/remote" && method === "GET") {
+                if (!deps.remote) {
+                    sendJson(res, 501, { error: "remote tunnels not available" });
+                    return;
+                }
+                sendJson(res, 200, { hosts: deps.remote.status() });
+                return;
+            }
+            if (pathname === "/api/remote/reload" && method === "POST") {
+                if (!deps.remote) {
+                    sendJson(res, 501, { error: "remote tunnels not available" });
+                    return;
+                }
+                sendJson(res, 200, { hosts: deps.remote.reload() });
+                return;
+            }
+            if (pathname === "/api/power" && (method === "GET" || method === "PUT")) {
+                if (!deps.power) {
+                    sendJson(res, 501, { error: "power control not available" });
+                    return;
+                }
+                if (method === "GET") {
+                    sendJson(res, 200, deps.power.status());
+                    return;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse((await readBody(req, 4096)).toString("utf8"));
+                }
+                catch {
+                    sendJson(res, 400, { error: "invalid JSON" });
+                    return;
+                }
+                const change = parsePowerChange(parsed);
+                if (typeof change === "string") {
+                    sendJson(res, 400, { error: change });
+                    return;
+                }
+                if (persistPowerChange(deps.configFile, change)) {
+                    deps.log.info(`admin: power saved (${JSON.stringify({ ...(change.awake ? { awake: change.awake } : {}), ...(change.tether?.enabled !== undefined ? { tether: { enabled: change.tether.enabled } } : {}) })})`);
+                }
+                if (change.tether?.pin !== undefined)
+                    deps.power.pin(change.tether.pin);
+                await deps.power.poke();
+                sendJson(res, 200, deps.power.status());
+                return;
+            }
+            // The one privileged step, from the dashboard: the CLI's `awake setup`, which shows macOS's own
+            // password dialog. It runs in the background and is polled, like the ChatGPT sign-in: the user
+            // may take minutes to type, and the app's window gives up on a response with no headers after
+            // 4s (packages/app/src/protocol.ts) — a reply held open until the end would read as a dead router.
+            if (pathname === "/api/power/setup" && (method === "GET" || method === "POST")) {
+                if (!deps.power) {
+                    sendJson(res, 501, { error: "power control not available" });
+                    return;
+                }
+                if (method === "GET") {
+                    sendJson(res, 200, powerSetup);
+                    return;
+                }
+                let parsed;
+                try {
+                    const text = (await readBody(req, 4096)).toString("utf8");
+                    parsed = text.trim() ? JSON.parse(text) : {};
+                }
+                catch {
+                    sendJson(res, 400, { error: "invalid JSON" });
+                    return;
+                }
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                    sendJson(res, 400, { error: "expected an object" });
+                    return;
+                }
+                const extra = Object.keys(parsed).find((key) => key !== "ssid");
+                if (extra) {
+                    sendJson(res, 400, { error: `unknown field "${extra}"` });
+                    return;
+                }
+                const ssid = parsed.ssid;
+                if (ssid !== undefined) {
+                    // Checked here too so a bad name is refused before a password dialog, not after it.
+                    const problem = ssidProblem(ssid);
+                    if (problem) {
+                        sendJson(res, 400, { error: problem });
+                        return;
+                    }
+                }
+                if (powerSetup.running) {
+                    sendJson(res, 409, { error: "setup is already running", running: true });
+                    return;
+                }
+                powerSetup = { running: true, startedAt: new Date().toISOString() };
+                const args = ["awake", "setup", ...(typeof ssid === "string" ? ["--ssid", ssid] : [])];
+                deps.log.info(`admin: awake setup via GUI -> started${typeof ssid === "string" ? ` (hotspot "${ssid}")` : ""}`);
+                const power = deps.power;
+                // The CLI's own dialog times out at 5 min; this leaves it room to say so itself.
+                void (deps.runCli ?? runCli)(args, 330_000).then((result) => ({ ok: result.ok, output: result.output }), (error) => ({ ok: false, output: errorText(error) })).then(async (result) => {
+                    powerSetup = { ...powerSetup, running: false, finishedAt: new Date().toISOString(), ...result };
+                    deps.log.info(`admin: awake setup via GUI -> ${result.ok ? "ok" : "failed"}`);
+                    // Re-read whether the rule is in place now, so the next GET /api/power says so.
+                    try {
+                        await power.poke();
+                    }
+                    catch { /* the next tick does it */ }
+                });
+                sendJson(res, 202, { started: true });
+                return;
+            }
             // Liveness is answering at all; readiness is 200 only when a request can actually go through.
             if (pathname === "/readyz" && method === "GET") {
                 const readiness = (await buildStatus(deps)).readiness;
@@ -1559,6 +1863,11 @@ export function startAdmin(deps) {
                 sendJson(res, 200, await buildStatus(deps, { refresh }));
                 return;
             }
+            // One shape for every provider whose quota can be read, for the status bar's limits row.
+            if (pathname === "/api/limits" && method === "GET") {
+                sendJson(res, 200, await buildLimits(deps));
+                return;
+            }
             if (pathname === "/api/mod-settings" && method === "GET") {
                 const snapshot = readModSettings();
                 // Filled here as well as on save, so a ladder with empty rungs (Auto migrated, or never set) reads whole to every surface.
@@ -1597,6 +1906,10 @@ export function startAdmin(deps) {
                 sendJson(res, 200, await pickerModels(deps));
                 return;
             }
+            if (pathname === "/api/context-windows" && method === "GET") {
+                sendJson(res, 200, await contextWindows(deps));
+                return;
+            }
             if (pathname === "/api/effort-levels" && method === "GET") {
                 sendJson(res, 200, effortLevels(deps.config()));
                 return;
@@ -2294,7 +2607,20 @@ export function startAdmin(deps) {
                 return;
             }
             if (pathname === "/api/requests/summary" && method === "GET") {
-                const seconds = Number(new URL(url, "http://x").searchParams.get("since") ?? 3600);
+                const query = new URL(url, "http://x").searchParams;
+                const fromParam = query.get("from");
+                if (fromParam !== null) {
+                    const from = Number(fromParam);
+                    const toParam = query.get("to");
+                    const to = toParam === null ? Date.now() : Number(toParam);
+                    if (!Number.isFinite(from) || !Number.isFinite(to) || from > to) {
+                        sendJson(res, 400, { error: "from and to must be epoch milliseconds with from <= to" });
+                        return;
+                    }
+                    sendJson(res, 200, { ...deps.requests.usage(from, to), from, to });
+                    return;
+                }
+                const seconds = Number(query.get("since") ?? 3600);
                 const safeSeconds = Number.isFinite(seconds) ? Math.min(31_536_000, Math.max(0, seconds)) : 3600;
                 sendJson(res, 200, deps.requests.summary(Date.now() - safeSeconds * 1000));
                 return;