clauderipple 0.9.5 → 0.11.0

package/dist/router/src/requestlog.js

@@ -2,11 +2,9 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import zlib from "node:zlib";
 import path from "node:path";
+import { UsageHistory, addTotals, emptyTotals, finishTotals, recordTotals, sortByVolume } from "./usage-history.js";
 const DEFAULT_MAX_BYTES = 20 * 1024 * 1024;
 const MAX_CARRY = 64 * 1024;
-function emptyBucket() {
-    return { count: 0, ok: 0, failed: 0, input: 0, cached: 0, cacheWrite: 0, output: 0, cacheHitPercent: 0, avgMs: 0 };
-}
 function isRecord(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -21,13 +19,29 @@ export class RequestLog {
     max;
     maxBytes;
     records;
+    history;
     constructor(file, max = 2000, maxBytes = DEFAULT_MAX_BYTES) {
         this.file = file;
         this.max = max;
         this.maxBytes = maxBytes;
-        this.records = this.load();
+        const persisted = this.readRecords(this.file);
+        this.records = persisted.slice(-this.max);
+        this.history = new UsageHistory(path.join(path.dirname(file), "usage-hourly.jsonl"));
+        // Replay what the history has not seen yet: the `.1` file first when it may hold a record above
+        // the watermark, so the first run backfills both files. Its mtime is its last append, and a
+        // record starts before it is written, so an mtime at or below the watermark hour rules it out;
+        // the first record of requests.jsonl does not, since a long request that straddled the rotation
+        // starts earlier than records left in `.1`. The history skips everything at or below its
+        // watermark, so a restart counts no hour twice.
+        const watermark = this.history.watermark;
+        const rotatedHour = usageHourOfFile(`${file}.1`);
+        const replay = rotatedHour !== null && (watermark === null || rotatedHour > watermark)
+            ? [...this.readRecords(`${file}.1`), ...persisted]
+            : persisted;
+        this.history.replay(replay);
     }
     add(record) {
+        this.history.add(record);
         this.records.push(record);
         if (this.records.length > this.max)
             this.records.splice(0, this.records.length - this.max);
@@ -64,47 +78,34 @@ export class RequestLog {
     }
     /** Summarise records at or after an epoch timestamp in milliseconds. */
     summary(sinceMs) {
-        const total = emptyBucket();
-        const providers = {};
-        const cacheBases = new Map();
-        const add = (bucket, record) => {
-            bucket.count++;
-            if (record.ok)
-                bucket.ok++;
-            else if (!record.resent)
-                bucket.failed++;
-            bucket.avgMs += record.ms;
-            if (record.usage) {
-                bucket.input += record.usage.input;
-                bucket.cached += record.usage.cached;
-                bucket.cacheWrite += record.usage.cacheWrite ?? 0;
-                bucket.output += record.usage.output;
-                // A cache write is input the model read fresh, so it counts against the hit rate. Leaving it
-                // out read a turn that wrote 2,218 tokens and uncached 2 as a 100% hit (2026-09-23).
-                cacheBases.set(bucket, (cacheBases.get(bucket) ?? 0) + record.usage.input + record.usage.cached + (record.usage.cacheWrite ?? 0));
-            }
-        };
+        const total = emptyTotals();
+        const providers = new Map();
+        const models = new Map();
         for (const record of this.records) {
             const at = Date.parse(record.at);
             if (!Number.isFinite(at) || at < sinceMs)
                 continue;
-            const provider = providers[record.provider] ?? (providers[record.provider] = emptyBucket());
-            add(total, record);
-            add(provider, record);
+            const provider = providers.get(record.provider) ?? providers.set(record.provider, emptyTotals()).get(record.provider);
+            const key = `${record.provider}\u0000${record.target}`;
+            const model = models.get(key) ?? models.set(key, { totals: emptyTotals(), provider: record.provider, model: record.target }).get(key);
+            for (const bucket of [total, provider, model.totals])
+                addTotals(bucket, recordTotals(record));
         }
-        for (const bucket of [total, ...Object.values(providers)]) {
-            if (bucket.count > 0)
-                bucket.avgMs = Math.round(bucket.avgMs / bucket.count);
-            const base = cacheBases.get(bucket) ?? 0;
-            bucket.cacheHitPercent = base > 0 ? Math.round((bucket.cached / base) * 1000) / 10 : 0;
-        }
-        return { total, providers };
+        const modelsList = [...models.values()].map(({ totals, provider, model }) => ({ ...finishTotals(totals), provider, model }));
+        sortByVolume(modelsList);
+        return {
+            total: finishTotals(total),
+            providers: Object.fromEntries([...providers].map(([name, totals]) => [name, finishTotals(totals)])),
+            models: modelsList,
+        };
+    }
+    /** Durable hourly usage over [fromMs, toMs), beyond the in-memory ring. */
+    usage(fromMs, toMs) {
+        return this.history.summary(fromMs, toMs);
     }
-    load() {
+    readRecords(file) {
         try {
-            if (!fs.existsSync(this.file))
-                return [];
-            const records = fs.readFileSync(this.file, "utf8")
+            return fs.readFileSync(file, "utf8")
                 .split("\n")
                 .flatMap((line) => {
                 try {
@@ -115,13 +116,21 @@ export class RequestLog {
                     return [];
                 }
             });
-            return records.slice(-this.max);
         }
         catch {
             return [];
         }
     }
 }
+/** The hour of a file's last write, or null when it does not exist. */
+function usageHourOfFile(file) {
+    try {
+        return Math.floor(fs.statSync(file).mtimeMs / 3_600_000);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Observes an Anthropic-compatible response without retaining or modifying its bytes.
  * Call feed() after forwarding each response chunk, then finish() on response end.

package/dist/router/src/tether-win.js

@@ -0,0 +1,211 @@
+// Hotspot failover on Windows (tether.ts holds the shared probe/decision loop; this is the OS part).
+//
+// No administrator step: joining a saved Wi-Fi profile and disconnecting are ordinary user actions
+// (`netsh wlan connect|disconnect`, WlanConnect/WlanDisconnect).
+//
+// Windows 11 24H2 put the Native Wifi calls that can reveal a BSSID behind the Location permission:
+// WlanGetAvailableNetworkList, WlanGetNetworkBssList, WlanScan, and WlanQueryInterface with
+// wlan_intf_opcode_current_connection (Microsoft Learn, "Changes to API behavior for Wi-Fi access and
+// location"). `netsh wlan show interfaces` is the last of those, so it is not used: the Wi-Fi adapter
+// comes from Get-NetAdapter (NdisPhysicalMedium 9 = Native 802.11, 1 = wireless LAN), its address from
+// os.networkInterfaces() (keyed by the same adapter name), and "on the hotspot" from that address as
+// on macOS: the iPhone range 172.20.10.0/28, or the network learned after our own `netsh wlan
+// connect` to the hotspot's profile (address + netmask from os.networkInterfaces(), which Windows
+// fills from GetAdaptersAddresses — no Location, no elevation). Profile listing (WlanGetProfileList /
+// WlanGetProfile), connect and disconnect are not on Microsoft's list; if a build gates them anyway,
+// netsh says so and the state reads `needs-location` with the Settings path.
+//
+// netsh's own text is translated, so it is read only where it cannot be avoided: profile names from
+// `show profiles` (the part after " : " on each line — the label before it is what gets translated),
+// and everything else from `export profile` XML (connectionMode auto|manual, the SSID), which is not.
+//
+//   failover  `netsh wlan connect name="<profile>" interface="<adapter>"`. Windows keeps the password
+//             in the profile, so the hotspot must have been joined once (no profile → a hint).
+//   return    `netsh wlan disconnect interface="<adapter>"`; Windows' auto-config then joins the best
+//             network whose profile connects automatically. Whether a netsh disconnect suppresses that
+//             is not documented for Vista and later (WlanDisconnect's note about "on-demand" profiles
+//             is for XP), so if nothing has an address after 8s the first automatic profile other
+//             than the hotspot is joined by name. No automatic profile at all → no attempt, a hint.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { POWERSHELL, powershellEnv, psArgs } from "./awake-win.js";
+const SYSTEM_ROOT = process.env.SystemRoot ?? process.env.SYSTEMROOT ?? "C:\\Windows";
+export const NETSH = path.win32.join(SYSTEM_ROOT, "System32", "netsh.exe");
+/** NdisPhysicalMedium: 9 Native802_11, 1 WirelessLan (8 is WirelessWan, cellular — not Wi-Fi). */
+export const FIND_WIFI_PS = [
+    "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
+    "$a = Get-NetAdapter -Physical -ErrorAction SilentlyContinue | Where-Object { $_.NdisPhysicalMedium -eq 9 -or $_.NdisPhysicalMedium -eq 1 } | Sort-Object { $_.Status -ne 'Up' } | Select-Object -First 1",
+    "if ($a) { $a.Name }",
+].join("\n");
+/** Names netsh can take between double quotes, and nothing else. */
+export function quotable(name) {
+    return name.length > 0 && name.length <= 256 && !/["\r\n\0]/.test(name);
+}
+export function parseAdapterName(stdout) {
+    const name = stdout.replace(/^\uFEFF/, "").split(/\r?\n/).map((l) => l.trim()).find((l) => l) ?? null;
+    return name && quotable(name) ? name : null;
+}
+/** Windows 11 24H2+: netsh refuses Wi-Fi commands without Location consent, and says so. */
+export function needsLocation(r) {
+    return /location permission|ms-settings:privacy-location/i.test(`${r.stdout}\n${r.stderr}`);
+}
+/**
+ * `netsh wlan show profiles`, in profile order (Windows' connection preference):
+ *   Profiles on interface Wi-Fi:
+ *   Group policy profiles (read only)
+ *   ---------------------------------
+ *       <None>
+ *   User profiles
+ *   -------------
+ *       All User Profile     : Home
+ *       All User Profile     : PBJ’s iPhone
+ * The labels are translated; the " : " and the name after it are not.
+ */
+export function parseProfileNames(text) {
+    const names = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (!/^\s{2,}\S/.test(line))
+            continue;
+        const i = line.indexOf(" : ");
+        if (i < 0)
+            continue;
+        const name = line.slice(i + 3).trim();
+        if (name && !names.includes(name))
+            names.push(name);
+    }
+    return names;
+}
+function xmlText(s) {
+    return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n))).replace(/&amp;/g, "&");
+}
+/** One `netsh wlan export profile` file (WLANProfile schema; not translated). */
+export function parseProfileXml(xml) {
+    const body = xml.replace(/^\uFEFF/, "");
+    const name = /<name>([^<]*)<\/name>/.exec(body)?.[1];
+    if (name === undefined)
+        return null;
+    const ssid = /<SSID>[\s\S]*?<name>([^<]*)<\/name>/.exec(body)?.[1];
+    const mode = /<connectionMode>\s*(auto|manual)\s*<\/connectionMode>/i.exec(body)?.[1];
+    return { name: xmlText(name), ssid: xmlText(ssid ?? name), auto: mode?.toLowerCase() === "auto" };
+}
+/** Saved Wi-Fi profiles in Windows' preference order, with SSID and auto-connect from their XML. */
+export async function listWifiProfiles(run) {
+    const shown = await run(NETSH, ["wlan", "show", "profiles"]);
+    if (needsLocation(shown))
+        return { profiles: [], location: true };
+    if (shown.code !== 0)
+        return { profiles: [], error: (shown.stdout || shown.stderr).trim().slice(0, 200) };
+    const order = parseProfileNames(shown.stdout);
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "clauderipple-wlan-"));
+    try {
+        // No `key=clear`: the passwords stay encrypted (and that would need elevation anyway).
+        const r = await run(NETSH, ["wlan", "export", "profile", `folder="${dir}"`], { verbatim: true });
+        if (needsLocation(r))
+            return { profiles: [], location: true };
+        const parsed = [];
+        for (const f of fs.readdirSync(dir)) {
+            if (!f.toLowerCase().endsWith(".xml"))
+                continue;
+            const p = parseProfileXml(fs.readFileSync(path.join(dir, f), "utf8"));
+            if (p && !parsed.some((q) => q.name === p.name))
+                parsed.push(p);
+        }
+        const rank = (p) => (order.includes(p.name) ? order.indexOf(p.name) : order.length);
+        return { profiles: parsed.sort((a, b) => rank(a) - rank(b)) };
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+export function hotspotProfile(profiles, ssid) {
+    return profiles.find((p) => p.ssid === ssid) ?? profiles.find((p) => p.name === ssid) ?? null;
+}
+/** Profiles Windows would join by itself, other than the hotspot's. */
+export function autoProfiles(profiles, ssid) {
+    const hotspot = hotspotProfile(profiles, ssid);
+    return profiles.filter((p) => p.auto && p !== hotspot);
+}
+/** `netsh wlan connect`'s outcome. It returns when the request is queued; the address decides after. */
+export function classifyNetshConnect(r) {
+    if (needsLocation(r))
+        return "needs-location";
+    if (r.code === 0)
+        return null;
+    const text = `${r.stdout}\n${r.stderr}`;
+    if (/is not available to connect/i.test(text))
+        return "hotspot-not-visible";
+    if (/no profile .* assigned|profile .* is not found/i.test(text))
+        return "no-hotspot-profile";
+    return "join-failed";
+}
+/**
+ * What an idle phone does to its hotspot differs, so the step to wake it is said per phone. Shared
+ * with the macOS hints; it lives here because tether.ts imports this module (not the other way).
+ */
+export const HOTSPOT_NOT_VISIBLE_STEPS = "On an iPhone, open Settings → Personal Hotspot once (and keep \"Allow Others to Join\" on). On Android, turn Wi-Fi hotspot on again: Android switches it off by itself after a while with nothing connected, unless its \"turn off hotspot automatically\" setting is off.";
+export const WIN_HINTS = {
+    "hotspot-not-visible": `Windows could not find the phone's hotspot. ${HOTSPOT_NOT_VISIBLE_STEPS}`,
+    "no-hotspot-profile": "Windows has not joined this hotspot before. Join it once from the Wi-Fi menu so Windows saves its password; ClaudeRipple then switches to it by name.",
+    "needs-location": "Windows 11 24H2 and later allow Wi-Fi commands only with Location on: Settings → Privacy & security → Location → turn on Location services and \"Let desktop apps access your location\".",
+    "no-hotspot-ssid": "Set the phone hotspot's name: `clauderipple awake setup --ssid <hotspot name>`.",
+    "no-wifi": "Wi-Fi is not connected. Windows joins the phone hotspot by itself only if its saved profile is set to connect automatically.",
+    "join-failed": "Joining the hotspot failed. Check the hotspot name, and that Windows has joined it once before (it keeps the password).",
+    pinned: "Switching is paused because the network was pinned.",
+};
+export class WinTetherBackend {
+    noAddressOutcome = "hotspot-not-visible";
+    hints = WIN_HINTS;
+    run;
+    log;
+    adapter = null;
+    constructor(run, log) {
+        this.run = run;
+        this.log = log;
+    }
+    async findWifi() {
+        const r = await this.run(POWERSHELL, psArgs(FIND_WIFI_PS), { env: powershellEnv(), timeoutMs: 20_000 });
+        this.adapter = r.code === 0 ? parseAdapterName(r.stdout) : null;
+        return this.adapter;
+    }
+    async join(ssid) {
+        const list = await listWifiProfiles(this.run);
+        if (list.location)
+            return "needs-location";
+        const p = hotspotProfile(list.profiles, ssid);
+        if (!p)
+            return "no-hotspot-profile";
+        return this.connect(p.name);
+    }
+    async connect(profile) {
+        if (!quotable(profile) || !this.adapter)
+            return "join-failed";
+        const r = await this.run(NETSH, ["wlan", "connect", `name="${profile}"`, `interface="${this.adapter}"`], { verbatim: true, timeoutMs: 30_000 });
+        const failed = classifyNetshConnect(r);
+        if (failed && failed !== "needs-location")
+            this.log.warn(`tether: netsh said: ${(r.stdout + r.stderr).trim().slice(0, 200)}`);
+        return failed;
+    }
+    async returnBlocked(ssid) {
+        const list = await listWifiProfiles(this.run);
+        if (list.location)
+            return "Windows needs Location on for Wi-Fi commands";
+        if (list.error)
+            return null; // cannot tell: try anyway
+        return autoProfiles(list.profiles, ssid).length ? null : "no other Wi-Fi on this PC is set to connect automatically";
+    }
+    async leave() {
+        if (!this.adapter)
+            return "no Wi-Fi adapter";
+        const r = await this.run(NETSH, ["wlan", "disconnect", `interface="${this.adapter}"`], { verbatim: true, timeoutMs: 15_000 });
+        return r.code === 0 && !needsLocation(r) ? null : (r.stdout || r.stderr).trim().slice(0, 200) || `netsh exited ${r.code}`;
+    }
+    async joinKnown(ssid) {
+        const list = await listWifiProfiles(this.run);
+        const first = autoProfiles(list.profiles, ssid)[0];
+        if (!first)
+            return;
+        this.log.info(`tether: Windows joined nothing by itself; asking for "${first.name}"`);
+        await this.connect(first.name);
+    }
+}