clauderipple 0.2.0

package/dist/cli/src/claude-auth.js

@@ -0,0 +1,112 @@
+// `claude setup-token` invocation for a ClaudeRipple-owned, 0600 token file.
+// The token is never echoed, logged, or returned from this module.
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { removeClaudeAuthFile, saveClaudeAuthFile } from "../../router/src/providers/anthropic-token-file.js";
+function isSetupToken(value) {
+    return /^sk-ant-oat01-[A-Za-z0-9._~-]{16,}$/.test(value);
+}
+export function parseSetupToken(stdout) {
+    const matches = stdout.match(/sk-ant-oat01-[A-Za-z0-9._~-]{16,}/g) ?? [];
+    const unique = [...new Set(matches)];
+    return unique.length === 1 && isSetupToken(unique[0]) ? unique[0] : null;
+}
+const isWindows = process.platform === "win32";
+/** Launcher names on PATH. Windows has no extensionless one: npm writes .cmd, the app ships .exe. */
+const BINARY_NAMES = isWindows ? ["claude.exe", "claude.cmd", "claude.bat"] : ["claude"];
+/** Where Claude Desktop caches the CLI it downloads, per platform. */
+export function desktopClaudeCodeDirs() {
+    if (!isWindows)
+        return [path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code")];
+    const roots = [
+        process.env.LOCALAPPDATA ?? path.join(os.homedir(), "AppData", "Local"),
+        process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming"),
+    ];
+    return roots.map((root) => path.join(root, "Claude", "claude-code"));
+}
+/** Launcher inside one cached version directory. The macOS build nests an .app bundle. */
+function versionBinaries(versionDir) {
+    return isWindows
+        ? BINARY_NAMES.map((name) => path.join(versionDir, name))
+        : [path.join(versionDir, "claude.app", "Contents", "MacOS", "claude")];
+}
+export function latestDesktopClaude() {
+    for (const directory of desktopClaudeCodeDirs()) {
+        try {
+            const versions = fs.readdirSync(directory)
+                .filter((entry) => /^\d+\.\d+\.\d+$/.test(entry))
+                .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }));
+            for (const version of versions.reverse()) {
+                const binary = versionBinaries(path.join(directory, version)).find((candidate) => fs.existsSync(candidate));
+                if (binary)
+                    return binary;
+            }
+        }
+        catch {
+            // Try the next root; a missing directory just means the app has not cached a CLI there.
+        }
+    }
+    return null;
+}
+export function claudeBinary(pathValue = process.env.PATH) {
+    for (const directory of (pathValue ?? "").split(path.delimiter)) {
+        if (!directory)
+            continue;
+        for (const name of BINARY_NAMES) {
+            const binary = path.join(directory, name);
+            try {
+                // X_OK is not meaningful on Windows; existence of a named launcher is the real test.
+                fs.accessSync(binary, isWindows ? fs.constants.F_OK : fs.constants.X_OK);
+                return binary;
+            }
+            catch {
+                // Continue to the next name, then the bundled Desktop CLI.
+            }
+        }
+    }
+    return latestDesktopClaude();
+}
+function needsTerminal() {
+    return (`Claude sign-in needs a terminal: run \`clauderipple claude-login\` in ${isWindows ? "PowerShell" : "Terminal"}. ` +
+        "If Claude Code is already signed in on this computer, its login is reused automatically and this step is not needed.");
+}
+export function claudeLogin(home, options = {}) {
+    const binary = options.binary ?? claudeBinary(options.pathValue);
+    if (!binary)
+        throw new Error("Claude Code CLI not found; install Claude Code or open Claude Desktop once");
+    // `claude setup-token` is an interactive terminal flow (it opens the browser and waits for the
+    // code to be pasted back). From the tray app or the GUI there is no terminal: it cannot succeed,
+    // and left to run it waits for input that never comes (the tray has no timeout at all). Refuse
+    // before spawning and say where it works (reported as a bare "setup-token failed", 2026-09-15).
+    if (!options.run && !(options.interactive ?? process.stdin.isTTY))
+        throw new Error(needsTerminal());
+    let stdout;
+    try {
+        // A .cmd/.bat launcher cannot be spawned directly on Windows; it needs a shell, and then the
+        // path must carry its own quotes because the shell re-parses the whole command line.
+        const viaShell = /\.(cmd|bat)$/i.test(binary);
+        const spawn = () => viaShell
+            ? execFileSync(`"${binary}"`, ["setup-token"], { encoding: "utf8", stdio: ["inherit", "pipe", "inherit"], shell: true })
+            : execFileSync(binary, ["setup-token"], { encoding: "utf8", stdio: ["inherit", "pipe", "inherit"] });
+        stdout = options.run ? options.run(binary) : spawn();
+    }
+    catch (error) {
+        const detail = error.stderr;
+        const text = typeof detail === "string" ? detail : Buffer.isBuffer(detail) ? detail.toString("utf8") : "";
+        if (/unknown command|unknown option|setup-token/i.test(text))
+            throw new Error("This Claude Code version does not support `claude setup-token`; update Claude Code and try again");
+        const reason = text.replace(/\s+/g, " ").trim().slice(0, 200);
+        if (!(options.interactive ?? process.stdin.isTTY))
+            throw new Error(`${needsTerminal()}${reason ? ` (claude setup-token said: ${reason})` : ""}`);
+        throw new Error(`Claude Code setup-token failed${reason ? `: ${reason}` : ""}`);
+    }
+    const token = parseSetupToken(stdout);
+    if (!token)
+        throw new Error("Claude Code did not return a recognizable setup token; no credential was saved");
+    saveClaudeAuthFile(home, token);
+}
+export function claudeLogout(home) {
+    return removeClaudeAuthFile(home);
+}

package/dist/cli/src/codex.js

@@ -0,0 +1,172 @@
+// `clauderipple codex on|off`: installs only ClaudeRipple-owned TOML fragments.
+// Codex 0.146 profiles are separate $CODEX_HOME/<name>.config.toml layers, so the default
+// selection in config.toml is never changed. The provider definition is marked and removed exactly.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const START = "# >>> ClaudeRipple Codex provider >>>";
+const END = "# <<< ClaudeRipple Codex provider <<<";
+const PROFILE_START = "# >>> ClaudeRipple Codex profile >>>";
+const PROFILE_END = "# <<< ClaudeRipple Codex profile <<<";
+const CATALOG_START = "# >>> ClaudeRipple Codex model catalog >>>";
+const CATALOG_END = "# <<< ClaudeRipple Codex model catalog <<<";
+export const CODEX_PROVIDER_MARKER = START;
+export function codexHome() {
+    return process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+}
+function configFile(home = codexHome()) {
+    return path.join(home, "config.toml");
+}
+function profileFile(home = codexHome()) {
+    return path.join(home, "clauderipple.config.toml");
+}
+function backup(file) {
+    if (!fs.existsSync(file))
+        return undefined;
+    const destination = `${file}.clauderipple-backup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+    fs.copyFileSync(file, destination);
+    return destination;
+}
+function withoutOwnedBlock(content, start, end) {
+    const startAt = content.indexOf(start);
+    if (startAt < 0)
+        return content;
+    const endAt = content.indexOf(end, startAt);
+    if (endAt < 0)
+        throw new Error(`refusing to edit ${start}: end marker is missing`);
+    const after = endAt + end.length;
+    const trailing = content.slice(after).replace(/^\r?\n/, "");
+    return (content.slice(0, startAt).replace(/\s*$/, "") + (content.slice(0, startAt).trim() && trailing.trim() ? "\n\n" : "") + trailing).replace(/^\s+/, "");
+}
+function appendBlock(content, block) {
+    const base = content.trimEnd();
+    return `${base}${base ? "\n\n" : ""}${block}\n`;
+}
+function providerBlock(port) {
+    return `${START}
+[model_providers.clauderipple]
+name = "ClaudeRipple local ingress"
+base_url = "http://127.0.0.1:${port}/v1"
+wire_api = "responses"
+${END}`;
+}
+function catalogFile(home = codexHome()) {
+    return path.join(home, "clauderipple-models.json");
+}
+/**
+ * Codex lists models from its catalog (`model_catalog_json` overrides the bundled one; measured with
+ * 0.146: the file is `{ models: [...] }` in the shape of Codex's own `models_cache.json`, and each
+ * entry additionally needs `base_instructions` and `supports_parallel_tool_calls`; when an entry
+ * carries `model_messages.instructions_template` Codex renders that as the system prompt and ignores
+ * `base_instructions`). We copy the cached OpenAI entries as they are — so the app keeps its GPT
+ * list — and append ClaudeRipple's models built from the cached `gpt-5.5` entry (same tools,
+ * same instructions template). Without a cache (Codex never signed in) there is nothing to copy
+ * from and the catalog is skipped: Codex then works but shows the model as "custom".
+ */
+export function writeCodexCatalog(models, home = codexHome()) {
+    const cache = path.join(home, "models_cache.json");
+    if (!fs.existsSync(cache))
+        return undefined;
+    let cached;
+    try {
+        cached = JSON.parse(fs.readFileSync(cache, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    const entries = (cached.models ?? []).filter((m) => typeof m.slug === "string");
+    const template = entries.find((m) => m.slug === "gpt-5.5" && m.model_messages) ?? entries.find((m) => m.model_messages);
+    if (!template)
+        return undefined;
+    const ours = models.map((m, i) => ({
+        ...template,
+        slug: m.id,
+        display_name: m.name ?? m.id,
+        description: `via ClaudeRipple (${m.provider})`,
+        default_reasoning_level: m.effortLevels.includes("medium") ? "medium" : (m.effortLevels[0] ?? "medium"),
+        supported_reasoning_levels: m.effortLevels.map((effort) => ({ effort, description: effort })),
+        visibility: "list",
+        supported_in_api: true,
+        priority: 100 + i,
+        additional_speed_tiers: [],
+        service_tiers: [],
+        availability_nux: null,
+        upgrade: null,
+        context_window: 200000,
+        max_context_window: 200000,
+        base_instructions: "",
+        supports_parallel_tool_calls: true,
+    }));
+    const theirs = entries.filter((m) => !models.some((o) => o.id === m.slug)).map((m) => ({ base_instructions: "", supports_parallel_tool_calls: true, ...m }));
+    const file = catalogFile(home);
+    fs.writeFileSync(file, JSON.stringify({ models: [...theirs, ...ours] }, null, 1), { mode: 0o600 });
+    return file;
+}
+function catalogBlock(file) {
+    return `${CATALOG_START}
+model_catalog_json = ${JSON.stringify(file)}
+${CATALOG_END}`;
+}
+/** Top-level keys must precede any `[table]`, so the catalog block goes first. Never overrides a user's own setting. */
+function withCatalog(content, file) {
+    const stripped = withoutOwnedBlock(content, CATALOG_START, CATALOG_END);
+    if (!file || /^\s*model_catalog_json\s*=/m.test(stripped))
+        return stripped;
+    return `${catalogBlock(file)}\n\n${stripped}`.replace(/\n+$/, "\n");
+}
+function profileBlock() {
+    return `${PROFILE_START}
+model_provider = "clauderipple"
+${PROFILE_END}`;
+}
+/** Install provider in config.toml plus selection in the dedicated `clauderipple` profile. */
+export function codexOn(port, home = codexHome(), models = []) {
+    fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+    const config = configFile(home);
+    const profile = profileFile(home);
+    const beforeConfig = fs.existsSync(config) ? fs.readFileSync(config, "utf8") : "";
+    const beforeProfile = fs.existsSync(profile) ? fs.readFileSync(profile, "utf8") : "";
+    const catalog = models.length ? writeCodexCatalog(models, home) : undefined;
+    const nextConfig = withCatalog(appendBlock(withoutOwnedBlock(beforeConfig, START, END), providerBlock(port)), catalog);
+    const nextProfile = appendBlock(withoutOwnedBlock(beforeProfile, PROFILE_START, PROFILE_END), profileBlock());
+    if (nextConfig === beforeConfig && nextProfile === beforeProfile)
+        return { changed: false, config, profile };
+    const configBackup = backup(config);
+    const profileBackup = backup(profile);
+    fs.writeFileSync(config, nextConfig, { mode: 0o600 });
+    fs.writeFileSync(profile, nextProfile, { mode: 0o600 });
+    return { changed: true, ...(configBackup ? { backup: configBackup } : {}), ...(profileBackup ? { profileBackup } : {}), config, profile };
+}
+/** Remove only blocks with our exact sentinels. Keeps all user config and profile values. */
+export function codexOff(home = codexHome()) {
+    const config = configFile(home);
+    const profile = profileFile(home);
+    const beforeConfig = fs.existsSync(config) ? fs.readFileSync(config, "utf8") : "";
+    const beforeProfile = fs.existsSync(profile) ? fs.readFileSync(profile, "utf8") : "";
+    const nextConfig = withoutOwnedBlock(withoutOwnedBlock(beforeConfig, START, END), CATALOG_START, CATALOG_END);
+    const nextProfile = withoutOwnedBlock(beforeProfile, PROFILE_START, PROFILE_END);
+    fs.rmSync(catalogFile(home), { force: true });
+    if (nextConfig === beforeConfig && nextProfile === beforeProfile)
+        return { changed: false, config, profile };
+    const configBackup = backup(config);
+    const profileBackup = backup(profile);
+    if (nextConfig)
+        fs.writeFileSync(config, nextConfig.endsWith("\n") ? nextConfig : `${nextConfig}\n`, { mode: 0o600 });
+    else
+        fs.rmSync(config, { force: true });
+    if (nextProfile)
+        fs.writeFileSync(profile, nextProfile.endsWith("\n") ? nextProfile : `${nextProfile}\n`, { mode: 0o600 });
+    else
+        fs.rmSync(profile, { force: true });
+    return { changed: true, ...(configBackup ? { backup: configBackup } : {}), ...(profileBackup ? { profileBackup } : {}), config, profile };
+}
+/** True when `codex on` is in effect for this Codex home. */
+export function codexEnabled(home = codexHome()) {
+    try {
+        const text = fs.readFileSync(configFile(home), "utf8");
+        return text.includes(START) && text.includes(END);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli/src/gen-certs.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Dev helper until `clauderipple install` exists: generate CA + leaf into CLAUDERIPPLE_HOME.
+import { generateCerts } from "./certs.js";
+import { homeDir } from "../../router/src/config.js";
+const home = homeDir();
+const p = generateCerts(home);
+console.log(`certs written to ${home}: ${Object.values(p).map((f) => f.split("/").pop()).join(", ")}`);

package/dist/cli/src/hooks/agent-title.js

@@ -0,0 +1,160 @@
+// Claude Code PreToolUse hook (matcher: Agent|Task): put the real model and thinking depth into the
+// subagent's title, e.g. "Terra·high · Provider presets", so the Claude Desktop background-task
+// panel shows which model a subagent runs on. The app's own second line is a fixed "Agent" label
+// (verified in the app renderer), so the description is the only text we can influence.
+//
+// Model resolution mirrors the router (packages/router/src/routing.ts): a `[[gpt: sol@xhigh]]`
+// marker in the prompt's first 5 lines, else the agent definition's frontmatter `model:`, else the
+// explicit `model` argument, else the parent session's model from the transcript tail.
+// Depth = the hook input's effort.level. Runs in <50ms, never fails the tool call (empty output = no-op).
+//
+// Installed by `clauderipple agent-title on` into ~/.claude/settings.json; the router ships no
+// Python, so this is TypeScript run by the Node recorded in <home>/paths.json.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const MARKER = /\[\[\s*gpt\s*:\s*([a-z0-9.\-]+)\s*(?:@\s*([a-z]+))?\s*\]\]/i;
+const OUR_PREFIX = /^[^\s·]+(?:·[a-z]+)? · /;
+const CLAUDE_ID = /^claude-(opus|sonnet|haiku|fable)-(\d+(?:-\d+)*?)(?:-\d{8})?$/;
+/** Display names: config's picker names (e.g. "GPT-5.6 Terra" → "Terra"), then a built-in table. */
+function prettyNames() {
+    const out = { "gpt-5.6-terra": "Terra", "gpt-5.6-sol": "Sol", "gpt-5.6-luna": "Luna", "gpt-6-astra": "Astra" };
+    const home = process.env.CLAUDERIPPLE_HOME ?? path.join(os.homedir(), ".clauderipple");
+    try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(home, "config.json"), "utf8"));
+        const add = (id, name) => {
+            if (!id || !name)
+                return;
+            const words = name.trim().split(/\s+/);
+            out[id.toLowerCase()] = words.length > 1 ? words[words.length - 1] : name.trim();
+        };
+        for (const m of cfg.cli?.extraModels ?? [])
+            add(m.model, m.name);
+        for (const p of Object.values(cfg.providers ?? {}))
+            for (const m of p.models ?? [])
+                add(m.id, m.name);
+    }
+    catch {
+        /* no config: built-ins only */
+    }
+    return out;
+}
+export function fromMarker(prompt) {
+    const head = prompt.split("\n").slice(0, 5).join("\n");
+    const m = MARKER.exec(head);
+    return m ? { model: m[1].toLowerCase(), effort: (m[2] ?? "").toLowerCase() } : null;
+}
+export function fromAgentFile(subagentType, dirs) {
+    if (!subagentType || subagentType.includes("/") || subagentType.startsWith("."))
+        return null;
+    for (const d of dirs) {
+        let head;
+        try {
+            head = fs.readFileSync(path.join(d, `${subagentType}.md`), "utf8").slice(0, 8192);
+        }
+        catch {
+            continue;
+        }
+        if (head.startsWith("---")) {
+            const end = head.indexOf("\n---", 3);
+            if (end !== -1)
+                head = head.slice(0, end);
+        }
+        const m = /^model:\s*['"]?([^'"\s]+)/m.exec(head);
+        if (m) {
+            const [model, effort = ""] = m[1].toLowerCase().split("@");
+            return { model: model, effort };
+        }
+    }
+    return null;
+}
+export function claudePretty(modelId) {
+    const v = (modelId ?? "").trim().toLowerCase();
+    if (["opus", "sonnet", "haiku", "fable"].includes(v))
+        return v[0].toUpperCase() + v.slice(1);
+    const m = CLAUDE_ID.exec(v);
+    return m ? m[1][0].toUpperCase() + m[1].slice(1) + m[2].replace(/-/g, ".") : null;
+}
+function parentModel(transcriptPath) {
+    if (!transcriptPath)
+        return null;
+    let chunk;
+    try {
+        const fd = fs.openSync(transcriptPath, "r");
+        const size = fs.fstatSync(fd).size;
+        const start = Math.max(0, size - 262144);
+        const buf = Buffer.alloc(size - start);
+        fs.readSync(fd, buf, 0, buf.length, start);
+        fs.closeSync(fd);
+        chunk = buf.toString("utf8");
+    }
+    catch {
+        return null;
+    }
+    for (const line of chunk.split("\n").reverse()) {
+        if (!line.includes('"assistant"') || line.includes('"isSidechain":true'))
+            continue;
+        try {
+            const d = JSON.parse(line);
+            if (d.message?.model)
+                return d.message.model;
+        }
+        catch {
+            /* the first line of a tail read can be cut */
+        }
+    }
+    return null;
+}
+export function retitle(input, agentDirs, names) {
+    if (input.tool_name !== "Agent" && input.tool_name !== "Task")
+        return null;
+    const inp = input.tool_input ?? {};
+    const desc = inp.description;
+    if (typeof desc !== "string" || desc.trim() === "")
+        return null;
+    const effort = (typeof input.effort === "object" && input.effort ? input.effort.level : typeof input.effort === "string" ? input.effort : "") ?? "";
+    const got = fromMarker(typeof inp.prompt === "string" ? inp.prompt : "") ?? fromAgentFile(typeof inp.subagent_type === "string" ? inp.subagent_type : "", agentDirs);
+    let tag = null;
+    if (got) {
+        // Marker short forms ("sol") resolve against full ids ("gpt-5.6-sol"), as the router's aliases do.
+        const key = names[got.model] !== undefined ? got.model : Object.keys(names).find((k) => k.endsWith(`-${got.model}`));
+        const name = (key ? names[key] : undefined) ?? (got.model.startsWith("gpt") || got.model.includes("/") ? got.model : null);
+        if (name)
+            tag = got.effort ? `${name}·${got.effort}` : name;
+    }
+    if (tag === null) {
+        const name = claudePretty(typeof inp.model === "string" ? inp.model : undefined) ?? (got ? claudePretty(got.model) : null) ?? claudePretty(parentModel(input.transcript_path) ?? undefined);
+        if (!name)
+            return null;
+        tag = effort ? `${name}·${effort}` : name;
+    }
+    const prefix = `${tag} · `;
+    if (desc.startsWith(prefix))
+        return null;
+    let bare = desc.replace(OUR_PREFIX, "");
+    if (bare.trim() === "")
+        bare = desc;
+    return { ...inp, description: prefix + bare };
+}
+function defaultAgentDirs() {
+    const dirs = [path.join(os.homedir(), ".claude", "agents")];
+    for (const base of [process.env.CLAUDE_PROJECT_DIR, process.cwd()])
+        if (base)
+            dirs.push(path.join(base, ".claude", "agents"));
+    return dirs;
+}
+// fileURLToPath, not URL.pathname: the latter keeps percent-encoding (a space in the path becomes
+// %20, so the comparison fails and the hook silently does nothing) and on Windows yields "/C:/…".
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
+    try {
+        const raw = fs.readFileSync(0, "utf8");
+        const data = JSON.parse(raw || "{}");
+        const updated = retitle(data, defaultAgentDirs(), prettyNames());
+        if (updated)
+            process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", updatedInput: updated } }) + "\n");
+    }
+    catch {
+        /* a hook must never break the tool call */
+    }
+}