clauderipple 0.9.4 → 0.10.0

package/dist/mod/types/index.d.ts

@@ -25,6 +25,9 @@ export type StatusRequest = {
 
 export type Effort = 'low' | 'medium' | 'high' | 'xhigh' | 'max'
 
+/** The desktop's skins: the deep (dark water, the first look) and flat (the app's own surfaces). */
+export type Skin = 'deep' | 'flat'
+
 /** API usage may omit counts; the engine's ModelUsage does not expose cache TTL evidence. */
 export type Usage = {
   input_tokens?: number
@@ -183,6 +186,8 @@ export type Settings = {
   swampAlert: boolean
   layout: 'dashboard' | 'minimal'
   appearance: 'auto' | 'dark' | 'light'
+  /** How the desktop draws the band and the cards: the deep or flat (ui/look.ts). */
+  skin: Skin
   language: 'auto' | Lang
   /** Band parts switched off: 'timer' | 'reason' | 'route'. */
   hide: string[]
@@ -210,7 +215,14 @@ export type Verdict = { effort: Effort; sure?: number; why: string }
 export type Pick = Verdict & { by: JudgeKind | 'manual' | 'followup'; at: number }
 
 /** A judge's answer for a delegated task; a judge that names no kind means do. */
-export type WorkerVerdict = { domain: Domain; level: Level; kind?: Kind; effort: Effort; sure?: number; why: string }
+export type WorkerVerdict = {
+  domain: Domain; level: Level; kind?: Kind; effort: Effort
+  /** Confidence in the level, the one that moves a task up the ladder. */
+  sure?: number
+  /** Jev's confidence in each answer, kept in the pick log so a rubric change can be compared. */
+  odds?: { domain?: number; level?: number; kind?: number; effort?: number }
+  why: string
+}
 
 /** What a spawn of ripple:auto (or a taken-over spawn) was turned into. */
 export type WorkerPick = WorkerVerdict & {
@@ -220,10 +232,13 @@ export type WorkerPick = WorkerVerdict & {
   position?: number
   skipped?: { rung: Rung; position: number; model: string; reason: string }[]
   target: TierTarget
-  by: JudgeKind | 'marker' | 'default'
+  /** Who named the tier: the judge, the main chat's tier marker (`session`), a model marker, or the default. */
+  by: JudgeKind | 'session' | 'marker' | 'default'
   ms: number
   /** Set when the tier's own agent could not run and the fallback did. */
   fallbackReason?: string
+  /** Joins the pick's lines in the pick log: the pick, the judge's shadow verdict, the outcome. */
+  id?: string
 }
 
 export type AgentState = 'running' | 'waiting' | 'done' | 'failed'
@@ -243,6 +258,19 @@ export type AgentRec = {
   endedAt?: number
   /** Weighted tokens (spec §5 stats weights). */
   cost: number
+  /** The provider it runs on by config name (`anthropic` for Claude's own), for its card's dot. */
+  provider?: string
+  /**
+   * The effort its last step was sent at: the model id's `@effort` where it carries one (the router
+   * forces that, packages/router/src/routing.ts), else the request's own effort.
+   */
+  effort?: string | number
+  /** The model that answered its last step, by the id the API reported (TurnUsage `model`). */
+  answeredBy?: string
+  /** Its steps' token counts as the API reported them, summed; the shape of StatusRequest's usage. */
+  usage?: { input: number; cached: number; cacheWrite: number; output: number }
+  /** Tool calls it started. */
+  tools?: number
 }
 
 /** The main chat's prompt cache as far as its responses show it. */
@@ -265,6 +293,32 @@ export type WarmState = {
 /** The hottest plan window at or above the alert line. */
 export type Hot = { kind: string; percent: number; resetsAt?: string }
 
+/**
+ * One plan window for the band's second row, the limits row: every window of every provider whose
+ * quota the router can read (Claude's plan windows and per-model weeklies, each ChatGPT account's
+ * windows, each Antigravity account's Gemini and third-party windows). The row reads them all from
+ * `GET /api/limits` (falling back to the older status routes on a router that predates it).
+ * `provider` is the provider's config name (the grouping key; 'claude' on the fallback path);
+ * `type` is its kind ('anthropic', 'chatgpt', 'google', …), which picks the group head's colour;
+ * `title` is the head's name ("Claude", "GPT", "Gemini"); `account` numbers the provider's eligible
+ * accounts from 0 (the row reads "GPT" alone, or "GPT 1", "GPT 2", … when a provider has several);
+ * `kind` is 'five_hour', 'seven_day', 'scoped' (a per-model/third-party window, its name in `label`)
+ * or 'window' (a window of another length, its minutes in `windowMinutes`).
+ */
+export type LimitItem = {
+  provider: string
+  /** The provider's kind, for the head's colour. Absent on an older item, the name stands in. */
+  type?: string
+  /** The head's name; absent, derived from the provider's type or name. */
+  title?: string
+  account: number
+  kind: 'five_hour' | 'seven_day' | 'scoped' | 'window'
+  label: string
+  windowMinutes?: number
+  percent: number
+  resetsAt?: string
+}
+
 export type Stats = {
   prompts: number
   requests: number
@@ -312,6 +366,8 @@ declare module 'claude-code' {
       context: { percent: number; tokens: number; window: number } | null
       hot: Hot | null
       hotHidden: number | null
+      /** The window the hot card was put off for: the put-off lasts until that window moves on. */
+      hotHiddenFor: Hot | null
       saveUntil: number | null
       swampHidden: number | null
       coldHidden: boolean
@@ -342,6 +398,14 @@ declare module 'claude-code' {
       effortMenuOpen: boolean
       agentsOpen: boolean
       agentsShowDone: boolean
+      /** The agent whose conversation the Agents pane shows; null shows the list. */
+      agentOpen: string | null
+      /** Pages of earlier entries the open conversation shows beyond its latest. */
+      agentEarlier: number
+      /** The open conversation's tool runs shown call by call, by their first call's id. */
+      agentRunsOpen: string[]
+      /** Counts the Agents pane's seconds while an agent runs: a write redraws its clocks. */
+      agentsTick: number
       jev: JevState
       routerModels: RouterModel[]
       /** The router's rung choices and presets (GET /api/mod-options), for the quick settings. */
@@ -354,6 +418,8 @@ declare module 'claude-code' {
       judgeRuns: JudgeRun[]
       judgeDownNetwork: boolean
       limit: Hot | null
+      /** Every provider's plan windows for the limits row, from `GET /api/limits`. Null until read. */
+      limits: LimitItem[] | null
       demo: 'cold' | 'swamp' | 'hot' | 'down' | 'kept' | null
     }
   }

package/dist/remote/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@clauderipple/remote",
+  "version": "0.8.10",
+  "private": true,
+  "type": "module",
+  "description": "Ripple Remote: a host on this machine that runs Claude Code sessions in any folder on any routed model, and a phone-first web app that drives them.",
+  "license": "GPL-3.0-only",
+  "scripts": { "test": "node --test test/*.test.ts" },
+  "bin": {
+    "ripple-host": "./src/main.ts"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.283",
+    "qrcode-generator": "2.0.4",
+    "tweetnacl": "1.0.3",
+    "web-push": "3.6.7",
+    "ws": "8.21.3",
+    "zod": "4.1.12"
+  },
+  "devDependencies": {
+    "@types/web-push": "3.6.4",
+    "@types/ws": "8.18.1",
+    "wrangler": "4.142.0"
+  }
+}

package/dist/remote/src/away.js

@@ -0,0 +1,85 @@
+// Whether this Mac is "away" — its screen locked, or no keyboard/mouse input for a while. It is
+// the gate for pushes about Mac sessions the host is not tailing (Sessions' onAlert path): the
+// person is at the desk while these are false, so a phone buzz would only be noise. Probe failures
+// answer "here", never "away": a wrong push is worse than a missed one.
+import { execFile } from "node:child_process";
+/** No input for this long counts as away, matching the phone's own idle threshold (Paseo's PRESENCE_THRESHOLD_MS). */
+export const IDLE_MS = 180_000;
+const CACHE_MS = 10_000;
+const TIMEOUT_MS = 2_000;
+const MAX_BUFFER = 4 * 1024 * 1024;
+const run = (cmd, args) => new Promise((resolve, reject) => {
+    execFile(cmd, args, { timeout: TIMEOUT_MS, maxBuffer: MAX_BUFFER }, (error, stdout) => error ? reject(error) : resolve(stdout));
+});
+/**
+ * Whether the console session's dictionary carries `CGSSessionScreenIsLocked` true.
+ * Measured on this Mac (Darwin 27, unlocked): the key is absent altogether, not `<false/>`, so only
+ * a `<true/>` inside the console user's entry is a lock. Nothing parses as a lock means no lock.
+ */
+export function screenLocked(plist) {
+    const start = plist.indexOf("<key>IOConsoleUsers</key>");
+    if (start < 0)
+        return false;
+    const end = plist.indexOf("</array>", start);
+    const body = plist.slice(start, end < 0 ? plist.length : end);
+    for (const entry of body.split("<dict>").slice(1)) {
+        const close = entry.indexOf("</dict>");
+        const session = close < 0 ? entry : entry.slice(0, close);
+        if (!/<key>kCGSSessionOnConsoleKey<\/key>\s*<true\s*\/>/.test(session))
+            continue;
+        return /<key>CGSSessionScreenIsLocked<\/key>\s*<true\s*\/>/.test(session);
+    }
+    return false;
+}
+/** `HIDIdleTime` from `ioreg -c IOHIDSystem`, in milliseconds, or null when the line is missing. */
+export function hidIdleMs(ioreg) {
+    const match = /"HIDIdleTime"\s*=\s*(\d+)/.exec(ioreg);
+    return match ? Number(match[1]) / 1_000_000 : null;
+}
+/** Both readings are `ioreg`; the answer is cached so a poll every few seconds probes once per CACHE_MS. */
+export class MacAway {
+    runner;
+    platform;
+    now;
+    log;
+    at = -Infinity;
+    value = null;
+    pending = null;
+    /** The last probe failed; cleared by a probe that answers. One log line per failing streak. */
+    failed = false;
+    constructor(opts = {}) {
+        this.runner = opts.runner ?? run;
+        this.platform = opts.platform ?? process.platform;
+        this.now = opts.now ?? Date.now;
+        this.log = opts.log;
+    }
+    async away() {
+        if (this.platform !== "darwin")
+            return false;
+        const now = this.now();
+        if (this.value !== null && now - this.at < CACHE_MS)
+            return this.value;
+        // One probe at a time: a second caller rides the in-flight one instead of reading the old value.
+        this.at = now;
+        this.pending ??= this.probe().then(value => { this.value = value; return value; }).finally(() => { this.pending = null; });
+        return this.pending;
+    }
+    async probe() {
+        try {
+            const [lock, hid] = await Promise.all([
+                this.runner("/usr/sbin/ioreg", ["-n", "Root", "-d1", "-a"]),
+                this.runner("/usr/sbin/ioreg", ["-c", "IOHIDSystem"]),
+            ]);
+            const idle = hidIdleMs(hid);
+            this.failed = false;
+            return screenLocked(lock) || (idle !== null && idle >= IDLE_MS);
+        }
+        catch (error) {
+            if (!this.failed) {
+                this.failed = true;
+                this.log?.(`away: probe failed (${error instanceof Error ? error.message : String(error)}) — treated as here`);
+            }
+            return false;
+        }
+    }
+}

package/dist/remote/src/bridge-client.js

@@ -0,0 +1,295 @@
+// Client-only Remote Control transport. Never register or attach a desktop worker.
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+export const DESKTOP_BLOCKED = "Claude 앱에서 열려 있는 세션에 지금은 보낼 수 없습니다.";
+export const LOGIN_EXPIRED = "이 컴퓨터의 Claude 로그인이 만료되었습니다. Claude 앱을 한 번 열어 주십시오.";
+export const LOGIN_REFUSED = "이 컴퓨터의 Claude 로그인이 거절되었습니다 (401). Claude 앱을 한 번 열어 주십시오.";
+class BridgeNetworkError extends Error {
+}
+/**
+ * This Mac's Claude login cannot be used (expired, unreadable, or refused): nothing reaches any
+ * Claude app session until Claude Code refreshes it, which the host never does itself. A state of
+ * the whole host, not of one session, so phones are told once rather than per request.
+ */
+export class BridgeAuthError extends Error {
+}
+/** While the login is expired, the keychain is read again at most this often (a child process each time). */
+export const AUTH_REREAD_MS = 30_000;
+export function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export function loadBridgeAuth() {
+    if (process.platform !== "darwin")
+        throw new Error(DESKTOP_BLOCKED);
+    try {
+        const credentials = object(JSON.parse(execFileSync("security", ["find-generic-password", "-a", process.env.USER ?? os.userInfo().username, "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })));
+        const oauth = object(credentials?.claudeAiOauth);
+        const account = object(object(JSON.parse(fs.readFileSync(path.join(os.homedir(), ".claude.json"), "utf8")))?.oauthAccount);
+        if (typeof oauth?.accessToken !== "string" || typeof oauth.expiresAt !== "number" || typeof account?.organizationUuid !== "string")
+            throw new Error();
+        return { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt, organizationUuid: account.organizationUuid };
+    }
+    catch {
+        throw new BridgeAuthError("이 컴퓨터의 Claude 로그인 정보를 읽을 수 없습니다.");
+    }
+}
+/** `slash_commands` minus `terminal_slash_commands`, which phone UIs should hide (SDK init docs). */
+export function slashCommands(init) {
+    if (!Array.isArray(init.slash_commands))
+        return null;
+    const terminal = new Set(Array.isArray(init.terminal_slash_commands) ? init.terminal_slash_commands : []);
+    return init.slash_commands.filter((c) => typeof c === "string" && !!c && !terminal.has(c));
+}
+export class BridgeClient {
+    fetchFn;
+    loadAuth;
+    cached = null;
+    readAt = 0;
+    now;
+    constructor(options = {}) {
+        this.fetchFn = options.fetch ?? fetch;
+        this.loadAuth = options.auth ?? loadBridgeAuth;
+        this.now = options.now ?? Date.now;
+    }
+    /**
+     * The keychain read is a synchronous child process; doing it per request blocked the host's
+     * event loop under the 3 s state poll until relay pings timed out (2026-10-12). Kept in memory
+     * and reread only near expiry or after a 401 (Claude Code refreshes the token on its own) — and
+     * near or past expiry at most every AUTH_REREAD_MS: an expired login otherwise meant one keychain
+     * read per request, every poll, for as long as it stayed expired (2026-10-15).
+     */
+    auth() {
+        const now = this.now();
+        const stale = !this.cached || this.refused || this.cached.expiresAt - now < 5 * 60_000;
+        if (stale && (!this.cached || now - this.readAt >= AUTH_REREAD_MS)) {
+            this.readAt = now;
+            this.cached = this.loadAuth();
+            this.refused = false;
+        }
+        return this.cached;
+    }
+    /** The API answered 401 to the token in `cached`; cleared when the keychain is read again. */
+    refused = false;
+    async request(id, suffix, options) {
+        const auth = this.auth();
+        if (this.refused)
+            throw new BridgeAuthError(LOGIN_REFUSED);
+        if (auth.expiresAt <= this.now())
+            throw new BridgeAuthError(LOGIN_EXPIRED);
+        let response;
+        try {
+            // The bridge treats a prompt as the user's own only from a person's app platform
+            // (ios, android, web_claude_ai, desktop_app in CLI 2.1.296); any claude_code_* platform
+            // is demoted to "a message from another Claude session". These prompts are typed on a phone.
+            response = await this.fetchFn(`https://api.anthropic.com/v1/code/sessions/${encodeURIComponent(id)}${suffix}`, {
+                ...options, redirect: "error", headers: { Authorization: `Bearer ${auth.accessToken}`, "anthropic-version": "2023-06-01", "anthropic-client-platform": "ios", "x-organization-uuid": auth.organizationUuid, "Content-Type": "application/json", "User-Agent": "RippleRemote/0.8.10" },
+            });
+        }
+        catch {
+            throw new BridgeNetworkError("Claude 앱과 연결하지 못했습니다.");
+        }
+        if (!response.ok) {
+            await response.body?.cancel();
+            if (response.status === 401) {
+                // Refused: the keychain is read again (Claude Code may have refreshed it) — at once if the
+                // last read is AUTH_REREAD_MS old, else then; until then requests fail here without a call.
+                if (this.now() - this.readAt >= AUTH_REREAD_MS)
+                    this.cached = null;
+                else
+                    this.refused = true;
+                throw new BridgeAuthError(LOGIN_REFUSED);
+            }
+            // Do not expose server bodies (which may echo credentials), or retry rejected writes.
+            throw new Error(`Claude 앱이 메시지를 받지 않았습니다 (${response.status}).`);
+        }
+        return response;
+    }
+    async post(id, payload) {
+        const response = await this.request(id, "/events", { method: "POST", body: JSON.stringify({ session_id: id, events: [{ payload }] }), signal: AbortSignal.timeout(15_000) });
+        await response.body?.cancel();
+    }
+    send(id, uuid, content) {
+        return this.post(id, { type: "user", uuid, message: { role: "user", content }, parent_tool_use_id: null });
+    }
+    interrupt(id) {
+        return this.post(id, { type: "control_request", request_id: randomUUID(), request: { subtype: "interrupt" } });
+    }
+    async session(id) {
+        const response = object(await (await this.request(id, "", { method: "GET", signal: AbortSignal.timeout(3000) })).json());
+        // CLI 2.1.296's single-session read uses response_shape ?? session.
+        const body = object(response?.response_shape ?? response?.session) ?? response;
+        const worker_status = body?.worker_status;
+        if (worker_status !== "running" && worker_status !== "idle" && worker_status !== "requires_action")
+            throw new Error("Remote Control session has no valid worker status.");
+        return { worker_status, ...(typeof body?.status === "string" ? { status: body.status } : {}),
+            ...(typeof body?.status_bucket === "string" ? { status_bucket: body.status_bucket } : {}),
+            ...(typeof body?.connection_status === "string" ? { connection_status: body.connection_status } : {}) };
+    }
+    async events(id) {
+        return object(await (await this.request(id, "/events?sort_order=asc", { signal: AbortSignal.timeout(15_000) })).json()) ?? {};
+    }
+    /** The session's slash commands, from the CLI's init event, without the terminal-only ones; null when it has none. */
+    async commands(id) {
+        const list = (await this.events(id)).data;
+        for (const value of Array.isArray(list) ? list : []) {
+            const payload = object(object(value)?.payload);
+            if (payload?.type === "system" && payload.subtype === "init")
+                return slashCommands(payload);
+        }
+        return null;
+    }
+    /**
+     * Authorization requests still open on the session, oldest first. The stream starts at the
+     * newest event (`latest` below), so attach and every reconnect replay this list from the start
+     * cursor instead — otherwise an approval requested before the stream connected never cards.
+     * A request followed by its control_response (answered from another client) or
+     * control_cancel_request (withdrawn) is not open and is left out.
+     */
+    async openRequests(id) {
+        const list = (await this.events(id)).data;
+        const open = new Map();
+        for (const value of Array.isArray(list) ? list : []) {
+            const item = object(value);
+            const payload = object(item?.payload);
+            if (!payload || typeof payload.request_id !== "string")
+                continue;
+            // Stored prompts carry the same source as stream frames; accept a missing one, never a foreign one.
+            const source = item?.source;
+            if (source !== undefined && source !== "worker")
+                continue;
+            const requestId = payload.request_id;
+            if (payload.type === "control_request") {
+                const request = object(payload.request);
+                const input = object(request?.input);
+                if (request?.subtype === "can_use_tool" && typeof request.tool_name === "string" && input && typeof request.tool_use_id === "string") {
+                    open.set(requestId, { requestId, tool: request.tool_name, input, toolUseId: request.tool_use_id });
+                }
+            }
+            else if (payload.type === "control_response" || payload.type === "control_cancel_request") {
+                open.delete(requestId);
+            }
+        }
+        return [...open.values()];
+    }
+    /** The newest durable event's number; the stream starts there instead of replaying the whole session. */
+    async latest(id, signal) {
+        const body = object(await (await this.request(id, "/events?sort_order=desc&limit=1", { signal })).json());
+        const first = Array.isArray(body?.data) ? object(body.data[0]) : null;
+        return sequenceOf(first?.sequence_num) ?? 0;
+    }
+    async stream(id, signal, handle, onConnect) {
+        let sequence = null;
+        while (!signal.aborted) {
+            if (sequence === null) {
+                try {
+                    sequence = await this.latest(id, signal);
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        return;
+                    if (!(error instanceof BridgeNetworkError))
+                        throw error;
+                    await delay(1000, undefined, { signal }).catch(error => { if (!signal.aborted)
+                        throw error; });
+                    continue;
+                }
+            }
+            let response;
+            try {
+                response = await this.request(id, `/events/stream?from_sequence_num=${sequence}`, { signal });
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                if (!(error instanceof BridgeNetworkError))
+                    throw error;
+                await delay(1000, undefined, { signal }).catch(error => { if (!signal.aborted)
+                    throw error; });
+                continue;
+            }
+            if (!response.body)
+                throw new Error("Remote Control stream is empty.");
+            // Connected (or reconnected): the caller replays approvals already waiting, which the
+            // newest-event cursor above would otherwise skip.
+            onConnect?.();
+            let handling = false;
+            try {
+                for await (const frame of decodeSse(response.body)) {
+                    handling = true;
+                    // Only live permission prompts come from here; the conversation itself is read from the transcript.
+                    if (frame.event === "catch_up_truncated") {
+                        handling = false;
+                        continue;
+                    }
+                    const number = sequenceOf(frame.data.sequence_num);
+                    if (frame.event === "client_event" && number !== undefined) {
+                        if (number <= sequence) {
+                            handling = false;
+                            continue;
+                        }
+                        handle(frame);
+                        sequence = number;
+                    }
+                    else if (frame.event === "ephemeral_event")
+                        handle(frame);
+                    handling = false;
+                }
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                if (handling)
+                    throw error;
+                // A broken read reconnects; HTTP rejection above is terminal. Writes are never retried.
+            }
+            await delay(1000, undefined, { signal }).catch(error => { if (!signal.aborted)
+                throw error; });
+        }
+    }
+}
+/** The server sends sequence numbers as decimal strings ("9136"); tests and older shapes use numbers. */
+function sequenceOf(value) {
+    const number = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+    return typeof number === "number" && Number.isSafeInteger(number) && number >= 0 ? number : undefined;
+}
+export async function* decodeSse(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let pending = "", event = "", data = [];
+    try {
+        for (;;) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                return;
+            pending += decoder.decode(chunk.value, { stream: true });
+            if (pending.length > 4 * 1024 * 1024)
+                throw new Error("Remote Control frame too large.");
+            let end;
+            while ((end = pending.indexOf("\n")) >= 0) {
+                const line = pending.slice(0, end).replace(/\r$/, "");
+                pending = pending.slice(end + 1);
+                if (line.startsWith("event:"))
+                    event = line.slice(6).trim();
+                else if (line.startsWith("data:"))
+                    data.push(line.slice(5).trimStart());
+                else if (!line) {
+                    if (data.length) {
+                        const parsed = object(JSON.parse(data.join("\n")));
+                        if (parsed)
+                            yield { event, data: parsed };
+                    }
+                    event = "";
+                    data = [];
+                }
+            }
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}

package/dist/remote/src/composer-menu.js

@@ -0,0 +1,11 @@
+// The composer's "+" menu beyond attachments: compact the conversation, or start fresh.
+// Pure (no platform imports) so the send behaviour is unit-tested without the native runtime.
+export const COMPOSER_MENU = [
+    { id: "compact", ko: "대화 압축", en: "Compact conversation" },
+    { id: "restart", ko: "새로 시작", en: "Start fresh", confirm: { ko: "지금 대화를 마치고 같은 설정으로 새 세션을 시작합니다.", en: "End this conversation and start fresh with the same settings." } },
+];
+/** The message an action sends. The host turns it into the SDK slash command; "/clear" is the
+ * fresh-session path it already handles, and "/compact" passes through to the CLI/bridge. */
+export function composerCommand(id) {
+    return id === "compact" ? "/compact" : "/clear";
+}

package/dist/remote/src/config.js

@@ -0,0 +1,102 @@
+// Host settings and the pairing token, under ~/.clauderipple/remote (0600). The token is the
+// only secret: whoever holds it can run Claude Code on this machine, so it is never logged,
+// never put in a URL the server sees (the pairing link carries it in the #fragment), and
+// compared in constant time.
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { ConfigStore, adminPort, configPath as routerConfigPath } from "../../router/src/config.js";
+import { readJson, writeFileAtomic } from "./fsutil.js";
+export const DEFAULT_PORT = 8797;
+/** ClaudeRipple's own relay: what phone access turns back on with after it was switched off. */
+export const DEFAULT_RELAY = "https://ripple-relay.clauderipple.workers.dev";
+export function remoteHome() {
+    return process.env.RIPPLE_REMOTE_HOME ?? path.join(os.homedir(), ".clauderipple", "remote");
+}
+export function newToken() {
+    return randomBytes(32).toString("base64url");
+}
+/**
+ * Where the router's admin API is listening, read from the router's own config. The admin API sits
+ * beside the proxy listener: the router derives its port as `admin.port ?? listen.port + 1`, so a
+ * default install is 8791 while this Mac (listen 8791) is 8792. Hardcoding 8792 only worked on this
+ * machine; on a default Windows install the host hit a dead port (`/api/status: HTTP 404`).
+ */
+export function routerAdminUrl(configFile = routerConfigPath()) {
+    return `http://127.0.0.1:${adminPort(new ConfigStore(configFile).get())}`;
+}
+/** `persist: false` reads without writing the generated secrets (for commands that only print). */
+export function loadConfig(dir = remoteHome(), persist = true) {
+    const file = path.join(dir, "host.json");
+    const stored = readJson(file) ?? {};
+    const cfg = {
+        token: typeof stored.token === "string" && stored.token.length >= 32 ? stored.token : newToken(),
+        bind: typeof stored.bind === "string" ? stored.bind : "127.0.0.1",
+        port: typeof stored.port === "number" ? stored.port : DEFAULT_PORT,
+        adminUrl: typeof stored.adminUrl === "string" ? stored.adminUrl : routerAdminUrl(),
+        ...(typeof stored.claudePath === "string" ? { claudePath: stored.claudePath } : {}),
+        ...(typeof stored.relay === "string" ? { relay: stored.relay } : {}),
+        serverId: typeof stored.serverId === "string" && /^[\w-]{16,64}$/.test(stored.serverId) ? stored.serverId : randomBytes(16).toString("base64url"),
+        relaySecret: typeof stored.relaySecret === "string" && stored.relaySecret.length >= 32 ? stored.relaySecret : newToken(),
+    };
+    if (persist && (cfg.token !== stored.token || cfg.serverId !== stored.serverId || cfg.relaySecret !== stored.relaySecret))
+        saveConfig(cfg, dir);
+    return cfg;
+}
+export function saveConfig(cfg, dir = remoteHome()) {
+    writeFileAtomic(path.join(dir, "host.json"), JSON.stringify(cfg, null, 2) + "\n");
+}
+export function tokenMatches(expected, given) {
+    if (typeof given !== "string")
+        return false;
+    const a = Buffer.from(expected);
+    const b = Buffer.from(given);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+const isTailnet = (ip) => {
+    const [a, b] = ip.split(".").map(Number);
+    return a === 100 && b !== undefined && b >= 64 && b <= 127; // 100.64.0.0/10, Tailscale's CGNAT range
+};
+const isLan = (ip) => /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(ip);
+function firstV4(ifaces, pick) {
+    for (const list of Object.values(ifaces))
+        for (const a of list ?? [])
+            if (a.family === "IPv4" && !a.internal && pick(a.address))
+                return a.address;
+    return null;
+}
+/** The address to listen on, and the one to put in the pairing link. */
+export function resolveBind(bind, ifaces = os.networkInterfaces()) {
+    if (bind === "tailscale" || bind === "lan") {
+        const ip = firstV4(ifaces, bind === "tailscale" ? isTailnet : isLan);
+        if (!ip)
+            throw new Error(`no ${bind === "tailscale" ? "Tailscale (100.64.0.0/10)" : "LAN"} address on this machine`);
+        return { listen: ip, advertise: ip, reachableFromPhone: true };
+    }
+    if (bind === "0.0.0.0" || bind === "::") {
+        const ip = firstV4(ifaces, isTailnet) ?? firstV4(ifaces, isLan) ?? "127.0.0.1";
+        return { listen: bind, advertise: ip, reachableFromPhone: ip !== "127.0.0.1" };
+    }
+    const loopback = bind === "127.0.0.1" || bind === "::1" || bind === "localhost";
+    return { listen: bind, advertise: bind, reachableFromPhone: !loopback };
+}
+export function pairingUrl(advertise, port, token) {
+    const host = advertise.includes(":") ? `[${advertise}]` : advertise;
+    return `http://${host}:${port}/#pair=${token}`;
+}
+/**
+ * The pairing link through the relay. Everything after `#` stays on the phone: browsers never send a
+ * fragment, so the relay sees neither the token nor the host's public key, only the page request.
+ */
+export function relayPairingUrl(relay, serverId, hostPublicKey, token) {
+    const origin = new URL(relay).origin;
+    return `${origin}/#pair=${token}&server=${serverId}&hpk=${hostPublicKey}`;
+}
+/** The relay's address, validated: https (or http only for a local `wrangler dev`). */
+export function normalizeRelay(url) {
+    const u = new URL(url);
+    const local = u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]";
+    if (u.protocol !== "https:" && !(u.protocol === "http:" && local))
+        throw new Error(`relay must be https:// (http:// only for localhost): ${url}`);
+    return u.origin;
+}