@cjhyy/code-shell-web 0.8.0

package/dist/i18n/translate.js

@@ -0,0 +1,35 @@
+import { loadUILanguage } from "../lib/uiLanguage.js";
+import { mobile } from "./mobile.js";
+/** Web-package dictionary: just the `mobile` namespace (zh is source of truth). */
+export const webMessages = mobile;
+/** Walk a dotted key path (`"a.b.c"`) into a nested object; return the string leaf or undefined. */
+function lookup(tree, key) {
+    let node = tree;
+    for (const part of key.split(".")) {
+        if (node == null || typeof node !== "object")
+            return undefined;
+        node = node[part];
+    }
+    return typeof node === "string" ? node : undefined;
+}
+/** Replace `{name}` placeholders with values from `params`; leaves unknown placeholders intact. */
+function interpolate(text, params) {
+    if (!params)
+        return text;
+    return text.replace(/\{(\w+)\}/g, (whole, name) => name in params ? String(params[name]) : whole);
+}
+/**
+ * Resolve a translation key for `lang`. Fallback chain:
+ *   1. the requested language,
+ *   2. Chinese (zh) — the source-of-truth tree,
+ *   3. the raw key string itself (so missing keys are visible, never blank).
+ * Then `{name}`-style placeholders are interpolated.
+ */
+export function translate(lang, key, params) {
+    const hit = lookup(webMessages[lang], key) ?? lookup(webMessages.zh, key) ?? key;
+    return interpolate(hit, params);
+}
+/** Translate with the persisted UI language (localStorage; defaults to zh). */
+export function t(key, params) {
+    return translate(loadUILanguage(), key, params);
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @cjhyy/code-shell-web — the browser-side logic layer of the CodeShell web
+ * client (extracted from packages/desktop src/mobile). Zero Electron, zero
+ * preload-bridge globals, zero @cjhyy/code-shell-core runtime imports:
+ * everything here runs in a plain browser (localStorage/WebSocket/navigator).
+ * Protocol types come from @cjhyy/code-shell-core (type-only, erased).
+ *
+ * The desktop mobile UI (packages/desktop/src/mobile) renders on top of this;
+ * a future standalone browser client is meant to grow from this package.
+ */
+export { useRemoteApp, type CcCliKind, type PendingApproval, type RemoteApp, } from "./hooks/useRemoteApp.js";
+export { useRemoteSocket, type ConnStatus, type ResyncReason, type RemoteSocket, type RemoteSocketHandlers, } from "./hooks/useRemoteSocket.js";
+export * from "./hooks/remoteAppSync.js";
+export * from "./lib/streamReducer.js";
+export * from "./lib/messageMappers.js";
+export * from "./lib/riskClassify.js";
+export * from "./lib/format.js";
+export * from "./lib/storage.js";
+export * from "./lib/pairing.js";
+export * from "./lib/deviceCredential.js";
+export * from "./lib/mobileAttachments.js";
+export * from "./lib/uiLanguage.js";
+export { mobile } from "./i18n/mobile.js";
+export { translate, t, webMessages, type WebTranslationKey, type WebTranslateParams, } from "./i18n/translate.js";

package/dist/index.js

@@ -0,0 +1,28 @@
+/**
+ * @cjhyy/code-shell-web — the browser-side logic layer of the CodeShell web
+ * client (extracted from packages/desktop src/mobile). Zero Electron, zero
+ * preload-bridge globals, zero @cjhyy/code-shell-core runtime imports:
+ * everything here runs in a plain browser (localStorage/WebSocket/navigator).
+ * Protocol types come from @cjhyy/code-shell-core (type-only, erased).
+ *
+ * The desktop mobile UI (packages/desktop/src/mobile) renders on top of this;
+ * a future standalone browser client is meant to grow from this package.
+ */
+// ── Hooks: remote-app state machine + reconnecting socket ───────────────────
+export { useRemoteApp, } from "./hooks/useRemoteApp.js";
+export { useRemoteSocket, } from "./hooks/useRemoteSocket.js";
+export * from "./hooks/remoteAppSync.js";
+// ── Stream folding (shared with the desktop renderer's CC room view) ────────
+export * from "./lib/streamReducer.js";
+export * from "./lib/messageMappers.js";
+// ── Pure helpers ─────────────────────────────────────────────────────────────
+export * from "./lib/riskClassify.js";
+export * from "./lib/format.js";
+export * from "./lib/storage.js";
+export * from "./lib/pairing.js";
+export * from "./lib/deviceCredential.js";
+export * from "./lib/mobileAttachments.js";
+export * from "./lib/uiLanguage.js";
+// ── i18n: mobile namespace dict + zh-fallback translate ─────────────────────
+export { mobile } from "./i18n/mobile.js";
+export { translate, t, webMessages, } from "./i18n/translate.js";

package/dist/lib/deviceCredential.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Device credential for the mobile remote.
+ *
+ * CONTRACT (do not "improve" by hashing): the main process
+ * (trusted-device-store.ts) stores and compares the `secretHash` field
+ * VERBATIM — `d.secretHash === input.secretHash`. There is no SHA-256 on
+ * either side. The field is named "secretHash" historically but is really an
+ * opaque shared secret. The phone therefore generates a stable random secret
+ * per browser and sends it raw as `secretHash` for both pair.complete and
+ * auth.device. Hashing it here would send main a value it never recorded →
+ * auth.failed. (See also [[project_beta1_feedback_batch_fixes]]: addDevice
+ * is get-or-create BY secretHash, so the secret must be stable per browser.)
+ */
+export declare function generateSecret(randomBytes?: (n: number) => Uint8Array): string;

package/dist/lib/deviceCredential.js

@@ -0,0 +1,19 @@
+/**
+ * Device credential for the mobile remote.
+ *
+ * CONTRACT (do not "improve" by hashing): the main process
+ * (trusted-device-store.ts) stores and compares the `secretHash` field
+ * VERBATIM — `d.secretHash === input.secretHash`. There is no SHA-256 on
+ * either side. The field is named "secretHash" historically but is really an
+ * opaque shared secret. The phone therefore generates a stable random secret
+ * per browser and sends it raw as `secretHash` for both pair.complete and
+ * auth.device. Hashing it here would send main a value it never recorded →
+ * auth.failed. (See also [[project_beta1_feedback_batch_fixes]]: addDevice
+ * is get-or-create BY secretHash, so the secret must be stable per browser.)
+ */
+export function generateSecret(randomBytes = (n) => crypto.getRandomValues(new Uint8Array(n))) {
+    const b = randomBytes(32);
+    return Array.from(b)
+        .map((x) => x.toString(16).padStart(2, "0"))
+        .join("");
+}

package/dist/lib/format.d.ts

@@ -0,0 +1,26 @@
+import { type UILanguage } from "./uiLanguage.js";
+/** Last path segment of a cwd ("/Users/x/proj" → "proj"). Empty for ""/root. */
+export declare function basename(p: string): string;
+/** Return the desktop project whose root owns `cwd` (longest prefix wins). */
+export declare function projectForCwd<T extends {
+    path: string;
+    name: string;
+}>(cwd: string | null | undefined, projects?: T[]): T | undefined;
+/** Group items by their cwd (project). When desktop project order is provided
+ *  it wins; unknown projects fall back to newest-first. Empty cwd → "无项目"
+ *  bucket, sorted last. Generic over any item carrying `cwd` + `updatedAt`. */
+export declare function groupByProject<T extends {
+    cwd: string;
+    updatedAt: number;
+}>(items: T[], projects?: Array<{
+    path: string;
+    name: string;
+}>, lang?: UILanguage): {
+    cwd: string;
+    name: string;
+    items: T[];
+    updatedAt: number;
+}[];
+/** Coarse relative time ("刚刚" / "5 分钟前" / "3 小时前" / "2 天前").
+ *  `now` is injectable for deterministic tests. */
+export declare function relativeTime(ts: number, now?: number, lang?: UILanguage): string;

package/dist/lib/format.js

@@ -0,0 +1,96 @@
+/** Small display formatters shared by the session/room lists. */
+import { translate } from "../i18n/translate.js";
+import { loadUILanguage } from "./uiLanguage.js";
+/** Last path segment of a cwd ("/Users/x/proj" → "proj"). Empty for ""/root. */
+export function basename(p) {
+    if (!p)
+        return "";
+    const parts = p.replace(/[/\\]+$/, "").split(/[/\\]/);
+    return parts[parts.length - 1] ?? "";
+}
+function normalizePath(p) {
+    const normalized = p.replace(/\\/g, "/").replace(/\/+$/, "");
+    return normalized === "" ? "/" : normalized;
+}
+function isSameOrInside(cwd, root) {
+    const target = normalizePath(cwd).toLowerCase();
+    const base = normalizePath(root).toLowerCase();
+    return target === base || target.startsWith(`${base}/`);
+}
+/** Return the desktop project whose root owns `cwd` (longest prefix wins). */
+export function projectForCwd(cwd, projects = []) {
+    if (!cwd)
+        return undefined;
+    let best;
+    let bestLen = -1;
+    for (const p of projects) {
+        if (!p.path || !isSameOrInside(cwd, p.path))
+            continue;
+        const len = normalizePath(p.path).length;
+        if (len > bestLen) {
+            best = p;
+            bestLen = len;
+        }
+    }
+    return best;
+}
+/** Group items by their cwd (project). When desktop project order is provided
+ *  it wins; unknown projects fall back to newest-first. Empty cwd → "无项目"
+ *  bucket, sorted last. Generic over any item carrying `cwd` + `updatedAt`. */
+export function groupByProject(items, projects = [], lang = loadUILanguage()) {
+    const map = new Map();
+    for (const it of items) {
+        const key = projectForCwd(it.cwd, projects)?.path ?? it.cwd ?? "";
+        const arr = map.get(key);
+        if (arr)
+            arr.push(it);
+        else
+            map.set(key, [it]);
+    }
+    const projectByPath = new Map(projects.map((p, i) => [p.path, { ...p, order: i }]));
+    const groups = [...map.entries()].map(([cwd, list]) => ({
+        cwd,
+        name: cwd
+            ? projectByPath.get(cwd)?.name || basename(cwd) || cwd
+            : translate(lang, "mobile.format.noProject"),
+        items: list,
+        updatedAt: Math.max(...list.map((i) => i.updatedAt)),
+    }));
+    groups.sort((a, b) => {
+        if (!a.cwd && b.cwd)
+            return 1; // 无项目 sinks to bottom
+        if (a.cwd && !b.cwd)
+            return -1;
+        const ao = projectByPath.get(a.cwd)?.order;
+        const bo = projectByPath.get(b.cwd)?.order;
+        if (ao !== undefined && bo !== undefined && ao !== bo)
+            return ao - bo;
+        if (ao !== undefined && bo === undefined)
+            return -1;
+        if (ao === undefined && bo !== undefined)
+            return 1;
+        return b.updatedAt - a.updatedAt; // newest project first
+    });
+    return groups;
+}
+/** Coarse relative time ("刚刚" / "5 分钟前" / "3 小时前" / "2 天前").
+ *  `now` is injectable for deterministic tests. */
+export function relativeTime(ts, now = Date.now(), lang = loadUILanguage()) {
+    const diff = Math.max(0, now - ts);
+    const sec = Math.floor(diff / 1000);
+    if (sec < 60)
+        return translate(lang, "mobile.format.justNow");
+    const min = Math.floor(sec / 60);
+    if (min < 60)
+        return translate(lang, "mobile.format.minutesAgo", { n: min });
+    const hr = Math.floor(min / 60);
+    if (hr < 24)
+        return translate(lang, "mobile.format.hoursAgo", { n: hr });
+    const day = Math.floor(hr / 24);
+    if (day < 30)
+        return translate(lang, "mobile.format.daysAgo", { n: day });
+    const mon = Math.floor(day / 30);
+    if (mon < 12)
+        return translate(lang, "mobile.format.monthsAgo", { n: mon });
+    return translate(lang, "mobile.format.yearsAgo", { n: Math.floor(mon / 12) });
+}

package/dist/lib/messageMappers.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Pure mappers between server payloads and the shapes the phone UI uses:
+ *  - room messages (RoomManager.messages.jsonl) → streamReducer events
+ *  - AskUser approval args → option labels
+ * Extracted from useRemoteApp so they're unit-testable without a DOM.
+ */
+/**
+ * Map a room message (one messages.jsonl line) into a reducer event.
+ *
+ * The shapes MUST match what RoomManager actually persists (room-manager.ts
+ * onAgentEvent/send): `{from:'agent',type:'text'}`, `{type:'tool',tool,summary}`,
+ * `{type:'tool_result',summary,isError}`, `{type:'turn_end',reason}`,
+ * `{from:'system',type:'error',text}`, `{from:'system',type:'agent_exit',reason}`,
+ * and `{from:'system',type:'room_created',text}`. Anything unmapped → `_noop`.
+ */
+export declare function roomMsgToEvent(msg: unknown): unknown;
+/**
+ * Map a `room.history.ok` payload's `messages` into replay events. The payload
+ * comes off the WebSocket from the (untrusted) host — `messages` may be missing
+ * or, on a malformed/hostile message, not an array. `(x ?? []).map` only guards
+ * null/undefined, so `messages: 123` would throw a TypeError and white-screen
+ * the phone. Guard with Array.isArray → non-arrays yield an empty replay.
+ */
+export declare function roomHistoryToEvents(messages: unknown): unknown[];
+/**
+ * Map a `ccRoom.readHistory.ok` payload's `messages` (core HistoryMessage shape:
+ * `{role, text, tools?}`) into replay events for the chat reducer. Like
+ * roomHistoryToEvents, the payload is untrusted off the WebSocket, so guard the
+ * array and each entry. A message expands to its tool starts first (so the tools
+ * render under the turn) followed by the prose bubble.
+ */
+export declare function ccHistoryToEvents(messages: unknown): unknown[];
+/** Detect an AskUser-style approval and pull its option labels + optionsOnly. */
+export declare function extractAskUserOptions(args: Record<string, unknown> | undefined): {
+    options: string[];
+    optionsOnly: boolean;
+} | undefined;

package/dist/lib/messageMappers.js

@@ -0,0 +1,145 @@
+/**
+ * Pure mappers between server payloads and the shapes the phone UI uses:
+ *  - room messages (RoomManager.messages.jsonl) → streamReducer events
+ *  - AskUser approval args → option labels
+ * Extracted from useRemoteApp so they're unit-testable without a DOM.
+ */
+/**
+ * Map a room message (one messages.jsonl line) into a reducer event.
+ *
+ * The shapes MUST match what RoomManager actually persists (room-manager.ts
+ * onAgentEvent/send): `{from:'agent',type:'text'}`, `{type:'tool',tool,summary}`,
+ * `{type:'tool_result',summary,isError}`, `{type:'turn_end',reason}`,
+ * `{from:'system',type:'error',text}`, `{from:'system',type:'agent_exit',reason}`,
+ * and `{from:'system',type:'room_created',text}`. Anything unmapped → `_noop`.
+ */
+export function roomMsgToEvent(msg) {
+    const m = msg;
+    const from = m.from;
+    const type = m.type;
+    // A user line: the agent's resident transcript records the prompt verbatim.
+    if (from === "user") {
+        return {
+            type: "user_message",
+            text: m.text,
+            ...(Array.isArray(m.attachments) ? { attachments: m.attachments } : {}),
+        };
+    }
+    // RoomManager writes agent prose as type:"text" — each line is a COMPLETE
+    // chunk claude emitted between tool calls, not a token delta. Map to
+    // `assistant_text` (its own finished bubble) so consecutive chunks render as
+    // separate bubbles interleaved with tools ("说一句 → 干活 → 再说一句"),
+    // instead of text_delta folding them all into one bubble.
+    if (type === "text")
+        return { type: "assistant_text", text: m.text };
+    // Tool start carries a human `summary` (not structured args). Surface it via
+    // the tool item's summary field. Prefer the real claude tool_use id (toolId)
+    // so the result can be paired by id; fall back to the seq-derived id for
+    // legacy messages that predate id threading.
+    if (type === "tool") {
+        const toolId = typeof m.toolId === "string" ? m.toolId : undefined;
+        // `args` carries the FULL tool_use input (e.g. a sub-agent's `prompt`), so
+        // the card can show real parameters rather than the lossy one-field summary.
+        // Omit the key when the message predates args persistence (legacy lines).
+        const args = m.args && typeof m.args === "object" ? m.args : undefined;
+        return {
+            type: "tool_use_start",
+            toolCall: { id: toolId ?? `room-tool-${m.seq ?? ""}`, toolName: m.tool, summary: m.summary, ...(args ? { args } : {}) },
+        };
+    }
+    // Tool result: if we have the real id, emit an id-paired `tool_result` so the
+    // reducer seals exactly the matching card (correct under parallel tools).
+    // Without an id (legacy), fall back to `room_tool_result` (seal the last open
+    // tool) — the old, best-effort behavior.
+    if (type === "tool_result") {
+        const toolId = typeof m.toolId === "string" ? m.toolId : undefined;
+        if (toolId) {
+            return {
+                type: "tool_result",
+                result: { id: toolId, result: m.summary, isError: m.isError },
+            };
+        }
+        return { type: "room_tool_result", summary: m.summary, isError: m.isError };
+    }
+    if (type === "turn_end")
+        return { type: "turn_complete", reason: m.reason ?? "completed" };
+    if (type === "error")
+        return { type: "error", error: m.text };
+    if (type === "agent_exit")
+        return { type: "error", error: `agent 退出 (code ${m.reason ?? "?"})` };
+    // room_created (audit anchor) and anything else have no visible rendering.
+    return { type: "_noop" };
+}
+/**
+ * Map a `room.history.ok` payload's `messages` into replay events. The payload
+ * comes off the WebSocket from the (untrusted) host — `messages` may be missing
+ * or, on a malformed/hostile message, not an array. `(x ?? []).map` only guards
+ * null/undefined, so `messages: 123` would throw a TypeError and white-screen
+ * the phone. Guard with Array.isArray → non-arrays yield an empty replay.
+ */
+export function roomHistoryToEvents(messages) {
+    return Array.isArray(messages) ? messages.map(roomMsgToEvent) : [];
+}
+/**
+ * Map a `ccRoom.readHistory.ok` payload's `messages` (core HistoryMessage shape:
+ * `{role, text, tools?}`) into replay events for the chat reducer. Like
+ * roomHistoryToEvents, the payload is untrusted off the WebSocket, so guard the
+ * array and each entry. A message expands to its tool starts first (so the tools
+ * render under the turn) followed by the prose bubble.
+ */
+export function ccHistoryToEvents(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        if (!m || typeof m !== "object")
+            continue;
+        const role = m.role === "assistant" ? "assistant" : "user";
+        if (role === "user") {
+            out.push({ type: "user_message", text: typeof m.text === "string" ? m.text : "" });
+            continue;
+        }
+        // Assistant: prose first (its own finished bubble via assistant_text), then
+        // any tool calls — matching how claude actually emits a turn ("说一句 → 干
+        // 活"). In practice each CC transcript message is single-type (pure text OR
+        // pure tools, never mixed), so only one branch fires per message; ordering
+        // across messages is preserved by the loop. Each text chunk is a SEPARATE
+        // bubble (assistant_text), not folded.
+        const text = typeof m.text === "string" ? m.text : "";
+        if (text)
+            out.push({ type: "assistant_text", text });
+        const tools = Array.isArray(m.tools) ? m.tools : [];
+        for (let t = 0; t < tools.length; t++) {
+            const tool = tools[t];
+            if (!tool || typeof tool !== "object")
+                continue;
+            const args = tool.args && typeof tool.args === "object" ? tool.args : undefined;
+            out.push({
+                type: "tool_use_start",
+                toolCall: {
+                    id: `cc-hist-${i}-${t}`,
+                    toolName: typeof tool.name === "string" ? tool.name : "tool",
+                    summary: typeof tool.summary === "string" ? tool.summary : undefined,
+                    ...(args ? { args } : {}),
+                },
+            });
+        }
+        out.push({ type: "turn_complete", reason: "completed" });
+    }
+    return out;
+}
+/** Detect an AskUser-style approval and pull its option labels + optionsOnly. */
+export function extractAskUserOptions(args) {
+    if (!args)
+        return undefined;
+    const opts = args.options;
+    if (Array.isArray(opts)) {
+        const labels = opts
+            .map((o) => (typeof o === "string" ? o : o?.label))
+            .filter((l) => typeof l === "string");
+        if (labels.length)
+            return { options: labels, optionsOnly: args.optionsOnly === true };
+    }
+    return undefined;
+}

package/dist/lib/mobileAttachments.d.ts

@@ -0,0 +1,23 @@
+import type { MobileImageAttachment, MobileImageBase } from "@cjhyy/code-shell-core";
+export declare const MOBILE_INLINE_IMAGE_BYTES: number;
+export declare const MOBILE_INLINE_TOTAL_BYTES: number;
+export declare const MOBILE_MAX_IMAGE_BYTES: number;
+export declare const MOBILE_MAX_ATTACHMENT_TOTAL_BYTES: number;
+export declare const MOBILE_MAX_ATTACHMENTS = 4;
+export interface MobileComposerAttachment {
+    clientId: string;
+    file: File;
+}
+export interface MobileUploadTicket {
+    clientId: string;
+    uploadId: string;
+    putUrl: string;
+    expiresAt: number;
+}
+interface PrepareOptions {
+    beginUpload: (metadata: MobileImageBase) => Promise<MobileUploadTicket>;
+    fetch: typeof fetch;
+}
+export declare function normalizeMobileImage(file: File): Promise<File>;
+export declare function prepareMobileAttachments(attachments: MobileComposerAttachment[], options: PrepareOptions): Promise<MobileImageAttachment[]>;
+export {};

package/dist/lib/mobileAttachments.js

@@ -0,0 +1,121 @@
+export const MOBILE_INLINE_IMAGE_BYTES = 256 * 1024;
+export const MOBILE_INLINE_TOTAL_BYTES = 512 * 1024;
+export const MOBILE_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+export const MOBILE_MAX_ATTACHMENT_TOTAL_BYTES = 20 * 1024 * 1024;
+export const MOBILE_MAX_ATTACHMENTS = 4;
+const SUPPORTED_MIMES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/gif",
+]);
+function jpegName(name) {
+    return /\.[^.]+$/.test(name) ? name.replace(/\.[^.]+$/, ".jpg") : `${name}.jpg`;
+}
+async function canvasJpeg(file) {
+    if (typeof createImageBitmap !== "function" || typeof document === "undefined") {
+        throw new Error(`Unsupported image format: ${file.type || file.name}`);
+    }
+    let bitmap;
+    try {
+        bitmap = await createImageBitmap(file, { imageOrientation: "from-image" });
+    }
+    catch {
+        throw new Error(`Unsupported image format: ${file.type || file.name}`);
+    }
+    try {
+        const maxEdge = 4096;
+        const scale = Math.min(1, maxEdge / Math.max(bitmap.width, bitmap.height));
+        const canvas = document.createElement("canvas");
+        canvas.width = Math.max(1, Math.round(bitmap.width * scale));
+        canvas.height = Math.max(1, Math.round(bitmap.height * scale));
+        const context = canvas.getContext("2d");
+        if (!context)
+            throw new Error("Image conversion is unavailable");
+        context.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
+        const blob = await new Promise((resolve, reject) => canvas.toBlob((next) => (next ? resolve(next) : reject(new Error("Image conversion failed"))), "image/jpeg", 0.88));
+        return new File([blob], jpegName(file.name), {
+            type: "image/jpeg",
+            lastModified: file.lastModified,
+        });
+    }
+    finally {
+        bitmap.close();
+    }
+}
+export async function normalizeMobileImage(file) {
+    const mime = file.type.toLowerCase();
+    if (mime === "image/jpg") {
+        return new File([await file.arrayBuffer()], file.name, {
+            type: "image/jpeg",
+            lastModified: file.lastModified,
+        });
+    }
+    if (SUPPORTED_MIMES.has(mime) && file.size <= MOBILE_MAX_IMAGE_BYTES) {
+        return file;
+    }
+    // Preserve supported animated GIFs rather than silently flattening them.
+    if (mime === "image/gif")
+        throw new Error("Image exceeds the 10 MiB limit");
+    const converted = await canvasJpeg(file);
+    if (converted.size > MOBILE_MAX_IMAGE_BYTES)
+        throw new Error("Image exceeds the 10 MiB limit");
+    return converted;
+}
+function bytesToBase64(bytes) {
+    let binary = "";
+    const chunkSize = 0x8000;
+    for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+        binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+    }
+    return btoa(binary);
+}
+async function dataUrl(file) {
+    const bytes = new Uint8Array(await file.arrayBuffer());
+    return `data:${file.type};base64,${bytesToBase64(bytes)}`;
+}
+export async function prepareMobileAttachments(attachments, options) {
+    if (attachments.length > MOBILE_MAX_ATTACHMENTS) {
+        throw new Error(`At most ${MOBILE_MAX_ATTACHMENTS} images can be sent`);
+    }
+    const normalized = [];
+    let total = 0;
+    for (const attachment of attachments) {
+        const file = await normalizeMobileImage(attachment.file);
+        const mime = file.type.toLowerCase();
+        if (!SUPPORTED_MIMES.has(mime))
+            throw new Error(`Unsupported image format: ${file.type}`);
+        total += file.size;
+        normalized.push({ clientId: attachment.clientId, file, mime });
+    }
+    if (total > MOBILE_MAX_ATTACHMENT_TOTAL_BYTES) {
+        throw new Error("Image attachments exceed the 20 MiB message limit");
+    }
+    const descriptors = [];
+    let inlineBytes = 0;
+    for (const { clientId, file, mime } of normalized) {
+        const base = {
+            clientId,
+            name: file.name,
+            mime,
+            size: file.size,
+        };
+        if (file.size <= MOBILE_INLINE_IMAGE_BYTES &&
+            inlineBytes + file.size <= MOBILE_INLINE_TOTAL_BYTES) {
+            descriptors.push({ ...base, transport: "inline", dataUrl: await dataUrl(file) });
+            inlineBytes += file.size;
+            continue;
+        }
+        const ticket = await options.beginUpload(base);
+        const response = await options.fetch(ticket.putUrl, {
+            method: "PUT",
+            headers: { "Content-Type": mime },
+            body: file,
+            credentials: "same-origin",
+        });
+        if (!response.ok)
+            throw new Error(`Image upload failed (${response.status})`);
+        descriptors.push({ ...base, transport: "upload", uploadId: ticket.uploadId });
+    }
+    return descriptors;
+}

package/dist/lib/pairing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pairing-token helpers. The desktop QR encodes `…/mobile?pairing=<token>`;
+ * the phone reads the token off the URL to send pair.complete. One-use,
+ * 10-minute tokens are enforced server-side (PairingTokenManager).
+ */
+export declare function parsePairingToken(search: string): string | null;

package/dist/lib/pairing.js

@@ -0,0 +1,8 @@
+/**
+ * Pairing-token helpers. The desktop QR encodes `…/mobile?pairing=<token>`;
+ * the phone reads the token off the URL to send pair.complete. One-use,
+ * 10-minute tokens are enforced server-side (PairingTokenManager).
+ */
+export function parsePairingToken(search) {
+    return new URLSearchParams(search).get("pairing");
+}

package/dist/lib/riskClassify.d.ts

@@ -0,0 +1,5 @@
+export type Risk = "low" | "medium" | "high";
+export declare function summarizeApproval(args: Record<string, unknown> | undefined, risk?: string, toolName?: string): {
+    summary: string;
+    risk: Risk;
+};

package/dist/lib/riskClassify.js

@@ -0,0 +1,56 @@
+/**
+ * Approval-card summary + risk normalization. Extracted from the old inline
+ * mobile-ui (the `ks=['command','file_path',…]` scan + medium fallback) so it
+ * is testable. The phone shows this on every approval.request /
+ * agent/approvalRequest. Decisions still go through the core permission engine
+ * (the phone never bypasses it — design §6).
+ */
+import { t } from "../i18n/translate.js";
+/** Arg keys to surface as the one-line summary, in priority order. */
+const SUMMARY_KEYS = ["command", "file_path", "path", "url", "pattern", "query"];
+export function summarizeApproval(args, risk, toolName) {
+    let summary = "";
+    // Match on the tool NAME, never on arg shape: a third-party/MCP tool whose
+    // args happen to carry source/scope/resource must not masquerade as a
+    // data-source read (nor shadow its real `command`/`file_path` summary).
+    const source = args?.source;
+    const scope = args?.scope;
+    const resource = args?.resource;
+    if (toolName === "ReadSource" &&
+        typeof source === "string" &&
+        source.length > 0 &&
+        typeof scope === "string" &&
+        scope.length > 0 &&
+        typeof resource === "string" &&
+        resource.length > 0) {
+        summary = t("mobile.approval.readSourceSummary", { source, scope, resource });
+    }
+    else {
+        for (const k of SUMMARY_KEYS) {
+            const v = args?.[k];
+            if (typeof v === "string" && v.length > 0) {
+                summary = v;
+                break;
+            }
+        }
+    }
+    if (!summary)
+        summary = JSON.stringify(args ?? {});
+    // Normalize the server-supplied risk. The three known levels pass through;
+    // anything else (absent → fall through to medium default; but an UNKNOWN
+    // non-empty value like "critical" from a corrupted/malicious server) must NOT
+    // silently downgrade to medium — fail SAFE to "high" so the badge can't
+    // under-state a dangerous op and nudge an approve. The core permission engine
+    // is still authoritative; this only governs the user-visible badge.
+    let r;
+    if (risk === "low" || risk === "medium" || risk === "high") {
+        r = risk;
+    }
+    else if (risk === undefined || risk === "") {
+        r = "medium"; // unspecified → the historical neutral default
+    }
+    else {
+        r = "high"; // unrecognized non-empty value → fail safe (don't under-state)
+    }
+    return { summary, risk: r };
+}