clauderipple 0.2.0

package/dist/router/src/redact.js

@@ -0,0 +1,43 @@
+// Safe excerpts of upstream errors for logs and client-safe translated errors.
+//
+// An upstream error may reflect the credential it was given. Keys are opaque vendor strings, so
+// callers supply their actual outbound credential values; token-shaped fallbacks cover errors from
+// a layer whose credentials are not present in config (for example a refreshed OAuth token).
+const REDACTED = "[REDACTED]";
+/** Values sent under a credential-bearing outbound header name. */
+function credentialHeaderName(name) {
+    return /^(?:authorization|proxy-authorization|cookie|set-cookie|x-api-key|api[-_]?key|.*(?:token|secret|password).*)$/i.test(name);
+}
+export function credentialHeaderValues(headers) {
+    const secrets = new Set();
+    for (const [rawName, value] of headers) {
+        if (credentialHeaderName(rawName) && value)
+            secrets.add(value);
+    }
+    return [...secrets].sort((a, b) => b.length - a.length);
+}
+/** Header names are diagnostic; their sensitive values must never reach a log line. */
+export function redactHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers).flatMap(([name, value]) => {
+        if (value === undefined)
+            return [];
+        return [[name, credentialHeaderName(name) ? REDACTED : value]];
+    }));
+}
+/** Return a bounded, one-line diagnostic without credentials. */
+export function redactErrorText(value, secrets = [], max = 500) {
+    let text = value.replace(/\s+/g, " ").trim();
+    // Longest first avoids leaving a suffix exposed when one configured value contains another.
+    for (const secret of [...new Set(secrets.filter(Boolean))].sort((a, b) => b.length - a.length)) {
+        text = text.replaceAll(secret, REDACTED);
+    }
+    return text
+        // Authorization values in prose or header-shaped JSON.
+        .replace(/\b(Bearer)\s+[A-Za-z0-9._~+/=-]{8,}\b/gi, `$1 ${REDACTED}`)
+        .replace(/\b(sk-[A-Za-z0-9][A-Za-z0-9._-]{6,})\b/g, REDACTED)
+        // OAuth access/refresh tokens are JWTs, regardless of the header/body formatting.
+        .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]*\b/g, REDACTED)
+        // Key/value echoes that are not sent as a standard Authorization header.
+        .replace(/\b((?:api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|client[-_]?secret|token|secret|password)\s*[:=]\s*)[^\s,"'};]+/gi, `$1${REDACTED}`)
+        .slice(0, max);
+}

package/dist/router/src/requestlog.js

@@ -0,0 +1,346 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import zlib from "node:zlib";
+import path from "node:path";
+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, output: 0, cacheHitPercent: 0, avgMs: 0 };
+}
+function isRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const r = value;
+    return typeof r.id === "string" && typeof r.at === "string" && typeof r.ms === "number" && typeof r.ok === "boolean" &&
+        (r.kind === "messages" || r.kind === "count_tokens" || r.kind === "other") && typeof r.source === "string" &&
+        typeof r.target === "string" && typeof r.provider === "string" && typeof r.stream === "boolean";
+}
+/** Bounded request history, persisted as JSONL so a router restart preserves recent entries. */
+export class RequestLog {
+    file;
+    max;
+    maxBytes;
+    records;
+    constructor(file, max = 2000, maxBytes = DEFAULT_MAX_BYTES) {
+        this.file = file;
+        this.max = max;
+        this.maxBytes = maxBytes;
+        this.records = this.load();
+    }
+    add(record) {
+        this.records.push(record);
+        if (this.records.length > this.max)
+            this.records.splice(0, this.records.length - this.max);
+        const line = JSON.stringify(record) + "\n";
+        try {
+            fs.mkdirSync(path.dirname(this.file), { recursive: true });
+            const bytes = Buffer.byteLength(line);
+            const size = fs.existsSync(this.file) ? fs.statSync(this.file).size : 0;
+            if (size > 0 && size + bytes > this.maxBytes) {
+                const previous = `${this.file}.1`;
+                fs.rmSync(previous, { force: true });
+                fs.renameSync(this.file, previous);
+            }
+            fs.appendFileSync(this.file, line, "utf8");
+        }
+        catch {
+            // Request logging must never alter the proxy response path.
+        }
+    }
+    list(n, filter = {}) {
+        const limit = Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+        const out = [];
+        for (let i = this.records.length - 1; i >= 0 && out.length < limit; i--) {
+            const record = this.records[i];
+            if (filter.provider && record.provider !== filter.provider)
+                continue;
+            if (filter.kind && record.kind !== filter.kind)
+                continue;
+            out.push(record);
+        }
+        return out;
+    }
+    /** 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
+                bucket.failed++;
+            bucket.avgMs += record.ms;
+            if (record.usage) {
+                bucket.input += record.usage.input;
+                bucket.cached += record.usage.cached;
+                bucket.output += record.usage.output;
+                cacheBases.set(bucket, (cacheBases.get(bucket) ?? 0) + record.usage.input + record.usage.cached);
+            }
+        };
+        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);
+        }
+        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 };
+    }
+    load() {
+        try {
+            if (!fs.existsSync(this.file))
+                return [];
+            const records = fs.readFileSync(this.file, "utf8")
+                .split("\n")
+                .flatMap((line) => {
+                try {
+                    const parsed = JSON.parse(line);
+                    return isRecord(parsed) ? [parsed] : [];
+                }
+                catch {
+                    return [];
+                }
+            });
+            return records.slice(-this.max);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+/**
+ * Observes an Anthropic-compatible response without retaining or modifying its bytes.
+ * Call feed() after forwarding each response chunk, then finish() on response end.
+ */
+export class ResponseUsageTap {
+    isSse;
+    decoder = new TextDecoder();
+    carry = "";
+    event = "";
+    data = [];
+    dropUntilNewline = false;
+    jsonUsageStarted = false;
+    jsonUsageDepth = 0;
+    jsonUsageText = "";
+    stopCarry = "";
+    stopReason;
+    usage;
+    // Compressed responses (Anthropic answers the CLI with gzip/br) are collected side-band up to a cap
+    // and inflated once at the end; the forwarded bytes are never touched.
+    encoding = null;
+    encodedChunks = [];
+    encodedBytes = 0;
+    static MAX_ENCODED = 16 * 1024 * 1024;
+    constructor(contentType, contentEncoding) {
+        this.isSse = /^text\/event-stream\b/i.test(contentType ?? "");
+        const enc = (contentEncoding ?? "").toLowerCase().trim();
+        if (enc === "" || enc === "identity")
+            this.encoding = null;
+        else if (enc === "gzip" || enc === "x-gzip")
+            this.encoding = "gzip";
+        else if (enc === "deflate")
+            this.encoding = "deflate";
+        else if (enc === "br")
+            this.encoding = "br";
+        else if (enc === "zstd" && typeof zlib.zstdDecompressSync === "function")
+            this.encoding = "zstd";
+        else
+            this.dropUntilNewline = true; // unknown encoding: observe nothing
+    }
+    get enabled() {
+        return !this.dropUntilNewline;
+    }
+    feed(chunk) {
+        if (!this.enabled)
+            return;
+        if (this.encoding) {
+            if (this.encodedBytes + chunk.length > ResponseUsageTap.MAX_ENCODED) {
+                this.dropUntilNewline = true;
+                this.encodedChunks = [];
+                return;
+            }
+            this.encodedChunks.push(chunk);
+            this.encodedBytes += chunk.length;
+            return;
+        }
+        const text = this.decoder.decode(chunk, { stream: true });
+        if (this.isSse)
+            this.feedSse(text);
+        else
+            this.feedJson(text);
+    }
+    finish() {
+        if (!this.enabled)
+            return {};
+        if (this.encoding) {
+            let plain;
+            try {
+                const all = Buffer.concat(this.encodedChunks);
+                plain =
+                    this.encoding === "gzip" ? zlib.gunzipSync(all)
+                        : this.encoding === "deflate" ? zlib.inflateSync(all)
+                            : this.encoding === "br" ? zlib.brotliDecompressSync(all)
+                                : zlib.zstdDecompressSync(all);
+            }
+            catch {
+                return {};
+            }
+            this.encodedChunks = [];
+            const text = plain.toString("utf8");
+            if (this.isSse)
+                this.feedSse(text);
+            else
+                this.feedJson(text);
+        }
+        const tail = this.decoder.decode();
+        if (tail) {
+            if (this.isSse)
+                this.feedSse(tail);
+            else
+                this.feedJson(tail);
+        }
+        if (this.isSse && this.carry)
+            this.feedSse("\n");
+        return { ...(this.usage ? { usage: this.usage } : {}), ...(this.stopReason ? { stopReason: this.stopReason } : {}) };
+    }
+    feedSse(text) {
+        this.carry += text;
+        if (this.carry.length > MAX_CARRY) {
+            const newline = this.carry.lastIndexOf("\n");
+            if (newline < 0) {
+                this.carry = "";
+                this.event = "";
+                this.data = [];
+                return;
+            }
+            this.carry = this.carry.slice(newline + 1);
+            this.event = "";
+            this.data = [];
+        }
+        for (;;) {
+            const newline = this.carry.indexOf("\n");
+            if (newline < 0)
+                return;
+            const raw = this.carry.slice(0, newline);
+            this.carry = this.carry.slice(newline + 1);
+            const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+            if (line === "") {
+                this.consumeSseEvent();
+                this.event = "";
+                this.data = [];
+            }
+            else if (line.startsWith("event:")) {
+                this.event = line.slice(6).trim();
+            }
+            else if (line.startsWith("data:")) {
+                this.data.push(line.slice(5).trimStart());
+            }
+        }
+    }
+    consumeSseEvent() {
+        if (!this.data.length)
+            return;
+        try {
+            const body = JSON.parse(this.data.join("\n"));
+            if (this.event === "message_start" || body.type === "message_start") {
+                const message = body.message;
+                this.setUsage(message?.usage);
+            }
+            else if (this.event === "message_delta" || body.type === "message_delta") {
+                this.setUsage(body.usage);
+                const delta = body.delta;
+                if (typeof delta?.stop_reason === "string")
+                    this.stopReason = delta.stop_reason;
+            }
+        }
+        catch {
+            // A malformed upstream event is not a proxy error and must not affect delivery.
+        }
+    }
+    feedJson(text) {
+        this.carry += text;
+        this.stopCarry = (this.stopCarry + text).slice(-MAX_CARRY);
+        const stop = /"stop_reason"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/.exec(this.stopCarry);
+        if (stop) {
+            try {
+                this.stopReason = JSON.parse(`"${stop[1]}"`);
+            }
+            catch { /* ignore */ }
+        }
+        if (!this.jsonUsageStarted) {
+            const match = /"usage"\s*:\s*\{/.exec(this.carry);
+            if (!match) {
+                if (this.carry.length > MAX_CARRY)
+                    this.carry = this.carry.slice(-MAX_CARRY);
+                return;
+            }
+            this.jsonUsageStarted = true;
+            const start = (match.index ?? 0) + match[0].lastIndexOf("{");
+            this.jsonUsageText = this.carry.slice(start);
+            this.carry = "";
+            this.jsonUsageDepth = 0;
+        }
+        else {
+            this.jsonUsageText += this.carry;
+            this.carry = "";
+        }
+        if (this.jsonUsageText.length > MAX_CARRY) {
+            this.jsonUsageStarted = false;
+            this.jsonUsageText = "";
+            return;
+        }
+        let quoted = false;
+        let escaped = false;
+        for (let i = 0; i < this.jsonUsageText.length; i++) {
+            const char = this.jsonUsageText[i];
+            if (quoted) {
+                if (escaped)
+                    escaped = false;
+                else if (char === "\\")
+                    escaped = true;
+                else if (char === '"')
+                    quoted = false;
+                continue;
+            }
+            if (char === '"')
+                quoted = true;
+            else if (char === "{")
+                this.jsonUsageDepth++;
+            else if (char === "}" && --this.jsonUsageDepth === 0) {
+                try {
+                    this.setUsage(JSON.parse(this.jsonUsageText.slice(0, i + 1)));
+                }
+                catch { /* ignore */ }
+                this.jsonUsageStarted = false;
+                this.jsonUsageText = "";
+                return;
+            }
+        }
+    }
+    setUsage(value) {
+        if (!value || typeof value !== "object")
+            return;
+        const usage = value;
+        const number = (key) => typeof usage[key] === "number" && Number.isFinite(usage[key]) ? Math.max(0, usage[key]) : 0;
+        if (!("input_tokens" in usage || "output_tokens" in usage || "cache_read_input_tokens" in usage || "cache_creation_input_tokens" in usage))
+            return;
+        const current = this.usage ?? { input: 0, cached: 0, output: 0 };
+        const input = "input_tokens" in usage ? number("input_tokens") : current.input;
+        const cached = "cache_read_input_tokens" in usage ? number("cache_read_input_tokens") : current.cached;
+        const cacheWrite = "cache_creation_input_tokens" in usage ? number("cache_creation_input_tokens") : current.cacheWrite;
+        const output = "output_tokens" in usage ? number("output_tokens") : current.output;
+        this.usage = { input, cached, ...(cacheWrite && cacheWrite > 0 ? { cacheWrite } : {}), output };
+    }
+}
+export function requestId() {
+    return crypto.randomUUID();
+}

package/dist/router/src/routing.js

@@ -0,0 +1,113 @@
+// Decide, per request, whether the model goes to a provider or straight to Anthropic.
+//
+//   "claude-opus-4-8"            → routes["claude-opus-4-8"]           (picker-slot alias)
+//   "gpt-5.6-sol"                → direct rule by prefix, model unchanged
+//   "gpt-5.6-sol@medium"         → same, effort forced to medium
+//   "[[ripple: sol@xhigh]]" or "[[gpt: sol@xhigh]]" at the top of the first user
+//   message overrides model/effort for direct-rule models only (subagent prompts).
+const REMINDER = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+const MARKER = /\[\[\s*(?:ripple|gpt)\s*:\s*([A-Za-z0-9.\-]+)\s*(?:@\s*([A-Za-z]+))?\s*\]\]/;
+export function markerOverride(body, aliases) {
+    const messages = body?.messages;
+    if (!Array.isArray(messages))
+        return null;
+    let seen = 0;
+    for (const m of messages) {
+        if (m?.role !== "user")
+            continue;
+        if (++seen > 5)
+            break; // the task prompt is always near the top
+        const c = m.content;
+        const text = typeof c === "string"
+            ? c
+            : Array.isArray(c)
+                ? c.filter((b) => b && b.type === "text").map((b) => b.text ?? "").join(" ")
+                : "";
+        const hit = MARKER.exec(text.replace(REMINDER, ""));
+        if (hit) {
+            const name = hit[1].toLowerCase();
+            const effort = hit[2]?.toLowerCase();
+            return effort ? { model: aliases[name] ?? name, effort } : { model: aliases[name] ?? name };
+        }
+    }
+    return null;
+}
+export function resolve(model, body, cfg) {
+    if (typeof model !== "string")
+        return null;
+    let base = model;
+    let effort;
+    const at = model.indexOf("@");
+    if (at > 0) {
+        base = model.slice(0, at);
+        effort = model.slice(at + 1) || undefined;
+    }
+    // A native `anthropic` provider serves the OpenAI ingress only; it speaks the Messages API with
+    // its own credentials and has nothing to translate for a caller that already speaks it. A rule
+    // naming one is ignored here so the request passes through to Anthropic instead of failing.
+    const ingressOnly = (name) => cfg.providers[name]?.type === "anthropic";
+    const direct = cfg.direct.find((d) => base.startsWith(d.prefix));
+    if (direct && ingressOnly(direct.provider))
+        return null;
+    if (direct) {
+        const ov = markerOverride(body, cfg.aliases);
+        const finalModel = ov?.model ?? base;
+        const finalEffort = ov?.effort ?? effort;
+        return { provider: direct.provider, model: finalModel, effort: finalEffort, tag: `${model}->${finalModel}` };
+    }
+    // The app sends some slots with a dated id (`claude-haiku-4-5-20251001`) and others without
+    // (`claude-opus-5`), while the GUI only ever offers the undated form. Match either.
+    const route = cfg.routes[base] ?? cfg.routes[base.replace(/-\d{8}$/, "")];
+    if (!route || ingressOnly(route.provider))
+        return null;
+    return {
+        provider: route.provider,
+        model: route.model,
+        effort: effort ?? route.effort,
+        tag: `${model}->${route.model}`,
+    };
+}
+/** Apply a resolution to a parsed Messages request body (mutates and returns it). */
+export function rewriteBody(json, r, effortClamp) {
+    json.model = r.model;
+    const oc = { ...(json.output_config ?? {}) };
+    if (r.effort)
+        oc.effort = r.effort;
+    if (typeof oc.effort === "string" && effortClamp[oc.effort])
+        oc.effort = effortClamp[oc.effort];
+    if (Object.keys(oc).length > 0)
+        json.output_config = oc;
+    return json;
+}
+export function effortOf(json) {
+    const oc = json.output_config;
+    return typeof oc?.effort === "string" ? oc.effort : undefined;
+}
+// ---- Server-side threads ("tether") -------------------------------------------------
+//
+// Claude Code 2.1.266 sends `thread: {type:"create"}` on a session's first request and then
+// `thread: {type:"continue", previous_message_id}` with ONLY the new messages, expecting the API to
+// hold the history (measured 2026-09-13; see docs/ARCHITECTURE.md). Translated providers have no
+// such state, so a continue request must be refused with the error code the CLI recognises: it then
+// resends the turn stateless and keeps the session stateless on this model ("retry:tether-stateless").
+// Accepting the continue instead makes the model see an orphan tool_result and forget the task, and
+// kills prompt caching (each turn is a tiny delta with a cold prefix).
+export const THREAD_UNSUPPORTED = {
+    type: "error",
+    error: {
+        type: "invalid_request_error",
+        message: "thread: unsupported request — ClaudeRipple routes this model to a provider without server-side threads; resend stateless",
+        details: { error_code: "thread_unsupported_request" },
+    },
+};
+/** "refuse" → answer 400 with THREAD_UNSUPPORTED; "strip" → drop thread/diagnostics and proceed. */
+export function threadDecision(json) {
+    const thread = json.thread;
+    if (!thread || typeof thread !== "object")
+        return "none";
+    return thread.type === "continue" ? "refuse" : "strip";
+}
+export function stripThreadFields(json) {
+    delete json.thread;
+    delete json.diagnostics;
+}

package/dist/router/src/version.js

@@ -0,0 +1,8 @@
+// The one version string the router, CLI and app compare against each other.
+//
+// Packaged apps ship only `packages/*/src`, so nothing at runtime can read a package.json. The
+// constant lives here and packages/router/test/version.test.ts fails the build when it drifts
+// from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
+// still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
+// running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
+export const VERSION = "0.2.0";