@cjhyy/code-shell-web 0.9.46 → 0.9.47

package/dist/hooks/mobileOutputClient.d.ts

@@ -5,6 +5,7 @@ type Result = NonNullable<Awaited<ReturnType<typeof recoverMobileOutput>>>;
 export declare class MobileOutputClient {
     private readonly deps;
     private enabled;
+    private basePages;
     private auth;
     private sequence;
     private selection?;
@@ -21,12 +22,15 @@ export declare class MobileOutputClient {
         awaitingJournal?: (sessionId: string) => void;
     });
     cancel(notify?: boolean): void;
+    private clearPending;
     begin(sessionId: string): boolean;
     private current;
     owns(sessionId: string): boolean;
     rejectUnsequenced(sessionId: string): boolean;
     private fail;
     observe(event: MobileServerEvent): boolean;
+    private request;
+    private readBase;
     private recover;
     /** Live output is withheld until it is covered by the frozen candidate. */
     hold(sessionId: string, raw: unknown): false | "pending" | "covered";

package/dist/hooks/mobileOutputClient.js

@@ -4,6 +4,7 @@ import { compareOutputCursors } from "../lib/outputJournalRecovery.js";
 export class MobileOutputClient {
     deps;
     enabled = false;
+    basePages = false;
     auth = 0;
     sequence = 0;
     selection;
@@ -17,13 +18,25 @@ export class MobileOutputClient {
             clearTimeout(old.readyTimer);
         if (old?.capacityTimer)
             clearTimeout(old.capacityTimer);
-        if (old?.waiter) {
-            clearTimeout(old.waiter.timer);
-            old.waiter.reject(new Error("Recovery cancelled"));
-        }
+        if (old)
+            this.clearPending(old, "Recovery cancelled");
         if (notify && old)
             this.deps.send({ type: "session.recovery.cancel" });
     }
+    clearPending(selection, message) {
+        if (selection.waiter) {
+            const waiter = selection.waiter;
+            selection.waiter = undefined;
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error(message));
+        }
+        if (selection.retry) {
+            const retry = selection.retry;
+            selection.retry = undefined;
+            clearTimeout(retry.timer);
+            retry.reject(new Error(message));
+        }
+    }
     begin(sessionId) {
         if (!this.enabled)
             return false;
@@ -61,7 +74,7 @@ export class MobileOutputClient {
         return true;
     }
     fail(selection) {
-        if (!this.current(selection))
+        if (!this.current(selection) || selection.failed)
             return;
         if (selection.readyTimer)
             clearTimeout(selection.readyTimer);
@@ -72,6 +85,7 @@ export class MobileOutputClient {
         selection.readyTimer = undefined;
         selection.recovering = false;
         selection.failed = true;
+        this.clearPending(selection, "Recovery failed");
         this.deps.failed(selection.sessionId);
     }
     observe(event) {
@@ -79,9 +93,12 @@ export class MobileOutputClient {
             this.cancel(false);
             this.auth++;
             this.enabled = event.capabilities?.outputJournal === 1;
+            this.basePages = this.enabled && event.capabilities?.legacyBasePages === 1;
             return false;
         }
-        if (event.type !== "session.recovery.ready" && event.type !== "session.outputJournal")
+        if (event.type !== "session.recovery.ready" &&
+            event.type !== "session.outputJournal" &&
+            event.type !== "session.legacyBase")
             return false;
         const selection = this.selection;
         if (!selection ||
@@ -107,7 +124,7 @@ export class MobileOutputClient {
             else
                 void this.recover(selection);
         }
-        else if (selection.waiter?.id === event.requestId) {
+        else if (selection.waiter?.id === event.requestId && selection.waiter.type === event.type) {
             const waiter = selection.waiter;
             selection.waiter = undefined;
             clearTimeout(waiter.timer);
@@ -115,6 +132,60 @@ export class MobileOutputClient {
         }
         return true;
     }
+    request(selection, type, options) {
+        return new Promise((resolve, reject) => {
+            if (!this.current(selection) || selection.failed || selection.waiter || selection.retry)
+                return reject(new Error("Recovery cancelled"));
+            const id = `page-${this.auth}-${++this.sequence}`;
+            const timer = setTimeout(() => {
+                selection.waiter = undefined;
+                reject(new Error("Recovery timed out"));
+            }, 10_000);
+            selection.waiter = {
+                id,
+                type,
+                timer,
+                reject,
+                resolve: (page) => resolve(page),
+            };
+            try {
+                if (!this.deps.send({
+                    ...options,
+                    type,
+                    sessionId: selection.sessionId,
+                    recoveryId: selection.id,
+                    requestId: id,
+                }))
+                    throw new Error("Recovery disconnected");
+            }
+            catch (error) {
+                clearTimeout(timer);
+                selection.waiter = undefined;
+                reject(error);
+            }
+        });
+    }
+    async readBase(selection, options) {
+        for (let retries = 0;; retries++) {
+            const reply = await this.request(selection, "session.legacyBase", options);
+            if (new TextEncoder().encode(JSON.stringify(reply)).length > 1024 * 1024 + 4096 ||
+                (reply.ok === false &&
+                    ((reply.reason !== "busy" && reply.reason !== "incomplete") ||
+                        Object.keys(reply).some((key) => !["type", "sessionId", "recoveryId", "requestId", "ok", "reason"].includes(key)))))
+                throw new Error("Invalid recovery base reply");
+            if (reply.ok !== false || reply.reason !== "busy" || retries >= 8)
+                return reply;
+            await new Promise((resolve, reject) => {
+                if (!this.current(selection) || selection.failed)
+                    return reject(new Error("Recovery cancelled"));
+                const timer = setTimeout(() => {
+                    selection.retry = undefined;
+                    resolve();
+                }, 25);
+                selection.retry = { timer, reject };
+            });
+        }
+    }
     async recover(selection, resume) {
         try {
             const result = await (resume
@@ -123,28 +194,12 @@ export class MobileOutputClient {
                     requireJournal: selection.journalRequired,
                     canContinue: () => this.current(selection) && !selection.failed,
                     latestCursor: () => selection.latest,
-                    read: (options) => new Promise((resolve, reject) => {
-                        if (!this.current(selection) || selection.waiter)
-                            return reject(new Error("Recovery cancelled"));
-                        const id = `page-${this.auth}-${++this.sequence}`;
-                        const timer = setTimeout(() => {
-                            selection.waiter = undefined;
-                            reject(new Error("Recovery timed out"));
-                        }, 10_000);
-                        selection.waiter = { id, resolve, reject, timer };
-                        if (!this.deps.send({
-                            type: "session.outputJournal",
-                            sessionId: selection.sessionId,
-                            recoveryId: selection.id,
-                            requestId: id,
-                            after: options.after,
-                            through: options.through,
-                        })) {
-                            clearTimeout(timer);
-                            selection.waiter = undefined;
-                            reject(new Error("Recovery disconnected"));
+                    read: (options) => this.request(selection, "session.outputJournal", options),
+                    ...(this.basePages
+                        ? {
+                            readBase: (options) => this.readBase(selection, options),
                         }
-                    }),
+                        : {}),
                 }));
             if (!this.current(selection))
                 return;

package/dist/lib/mobileOutputRecovery.d.ts

@@ -4,6 +4,16 @@ import { initialChatState } from "./streamReducer.js";
 type Reply = Extract<MobileServerEvent, {
     type: "session.outputJournal";
 }>;
+type BaseReply = Extract<MobileServerEvent, {
+    type: "session.legacyBase";
+}>;
+export type MobileLegacyBaseOptions = {
+    throughEventId: string;
+    cursor?: never;
+} | {
+    cursor: string;
+    throughEventId?: never;
+};
 /** Valid identities may arrive before their new Core Run acquires a durable anchor. */
 export declare class MobilePendingInput extends Error {
     readonly ids: string[];
@@ -27,6 +37,8 @@ type MobileOutputRecoveryResult = {
 /** Build a private candidate, then join its frozen prefix to an actual Main snapshot. */
 export declare function recoverMobileOutput(args: {
     read: (options: OutputJournalOptions) => Promise<Reply>;
+    /** Supplied only after an implementing host explicitly advertises the capability. */
+    readBase?: (options: MobileLegacyBaseOptions) => Promise<BaseReply>;
     canContinue: () => boolean;
     latestCursor: () => string | undefined;
     requireJournal?: boolean;

package/dist/lib/mobileOutputRecovery.js

@@ -1,6 +1,87 @@
 import { applyOutputJournalPage, compareOutputCursors, } from "./outputJournalRecovery.js";
 import { assertOutputCoverage } from "./outputCoverage.js";
 import { initialChatState, reduceStream } from "./streamReducer.js";
+const MiB = 1024 * 1024;
+const wireBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).length;
+function record(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function onlyKeys(value, keys) {
+    return Object.keys(value).every((key) => keys.includes(key));
+}
+const BASE_EVENT_KEYS = {
+    session_started: ["type", "sessionId"],
+    stream_request_start: ["type", "agentId"],
+    assistant_message: ["type", "agentId"],
+    text_delta: ["type", "text", "agentId"],
+    thinking_delta: ["type", "text", "agentId"],
+    user_message: ["type", "text", "attachments", "clientMessageId"],
+    tool_use_start: ["type", "toolCall", "agentId"],
+    tool_use_args_delta: ["type", "toolCallId", "args", "agentId"],
+    tool_result: ["type", "result", "agentId"],
+    agent_start: ["type", "agentId", "name", "description", "status"],
+    error: ["type", "error"],
+    turn_complete: ["type", "reason"],
+};
+/** Only the display projection's event schema is accepted on this new wire path. */
+function baseEvent(value, sessionId) {
+    if (!record(value) ||
+        typeof value.type !== "string" ||
+        !Object.hasOwn(BASE_EVENT_KEYS, value.type) ||
+        !onlyKeys(value, BASE_EVENT_KEYS[value.type]) ||
+        (value.agentId !== undefined && typeof value.agentId !== "string"))
+        return false;
+    switch (value.type) {
+        case "session_started":
+            return value.sessionId === sessionId;
+        case "stream_request_start":
+        case "assistant_message":
+            return true;
+        case "text_delta":
+        case "thinking_delta":
+            return typeof value.text === "string";
+        case "user_message":
+            return (typeof value.text === "string" &&
+                (value.clientMessageId === undefined || typeof value.clientMessageId === "string") &&
+                (value.attachments === undefined ||
+                    (Array.isArray(value.attachments) &&
+                        value.attachments.every((item) => record(item) &&
+                            onlyKeys(item, ["name", "size", "mime", "path"]) &&
+                            typeof item.name === "string" &&
+                            Number.isSafeInteger(item.size) &&
+                            item.size >= 0 &&
+                            ["mime", "path"].every((key) => item[key] === undefined || typeof item[key] === "string")))));
+        case "tool_use_start":
+            return (record(value.toolCall) &&
+                onlyKeys(value.toolCall, ["id", "toolName", "args"]) &&
+                typeof value.toolCall.id === "string" &&
+                !!value.toolCall.id &&
+                typeof value.toolCall.toolName === "string" &&
+                record(value.toolCall.args));
+        case "tool_use_args_delta":
+            return typeof value.toolCallId === "string" && !!value.toolCallId && record(value.args);
+        case "tool_result":
+            return (record(value.result) &&
+                onlyKeys(value.result, ["id", "result", "isError", "error"]) &&
+                typeof value.result.id === "string" &&
+                !!value.result.id &&
+                typeof value.result.result === "string" &&
+                typeof value.result.isError === "boolean" &&
+                (value.result.error === undefined || typeof value.result.error === "string"));
+        case "agent_start":
+            return (typeof value.agentId === "string" &&
+                !!value.agentId &&
+                typeof value.name === "string" &&
+                typeof value.description === "string" &&
+                value.status === "recorded");
+        case "error":
+            return typeof value.error === "string";
+        case "turn_complete":
+            return value.reason === "aborted_tools";
+        default:
+            return false;
+    }
+}
 /** Valid identities may arrive before their new Core Run acquires a durable anchor. */
 export class MobilePendingInput extends Error {
     ids;
@@ -63,21 +144,84 @@ export async function recoverMobileOutput(args) {
     }
     if (reply.page.status === "unavailable")
         return null;
-    if (reply.page.status !== "ok" ||
-        !reply.legacyBaseComplete ||
-        !reply.legacyBase ||
-        !Array.isArray(reply.legacyBase.events) ||
-        reply.legacyBase.events[0]?.type !== "session_started" ||
-        reply.legacyBase.throughEventId !== reply.page.legacyBaseThroughEventId ||
-        new TextEncoder().encode(JSON.stringify(reply.legacyBase)).length > 1024 * 1024 + 4096)
-        throw new Error("Recovery base is incomplete");
     let chat = initialChatState();
-    for (const event of reply.legacyBase.events)
-        chat = reduceStream(chat, event);
+    let pages = 0;
+    if (reply.page.status === "ok" && reply.legacyBaseComplete === false && args.readBase) {
+        const throughEventId = reply.page.legacyBaseThroughEventId;
+        if (typeof throughEventId !== "string" || !throughEventId || throughEventId.length > 512)
+            throw new Error("Recovery base is incomplete");
+        const cursors = new Set();
+        let cursor, index = 0, bytes = 0;
+        for (let count = 0;; count++) {
+            if (!args.canContinue() || count >= 40 || ++pages > 2048)
+                throw new Error("Recovery base cancelled or bounded");
+            const base = await args.readBase(cursor ? { cursor } : { throughEventId });
+            if (!args.canContinue())
+                throw new Error("Recovery cancelled");
+            const size = wireBytes(base);
+            bytes += size;
+            if (!record(base) ||
+                !onlyKeys(base, [
+                    "type",
+                    "sessionId",
+                    "recoveryId",
+                    "requestId",
+                    "ok",
+                    "throughEventId",
+                    "index",
+                    "events",
+                    "complete",
+                    "next",
+                ]) ||
+                base.type !== "session.legacyBase" ||
+                typeof base.requestId !== "string" ||
+                !base.requestId ||
+                base.requestId.length > 128 ||
+                base.ok !== true ||
+                base.sessionId !== reply.sessionId ||
+                base.recoveryId !== reply.recoveryId ||
+                base.throughEventId !== throughEventId ||
+                !Number.isSafeInteger(base.index) ||
+                base.index !== index ||
+                !Array.isArray(base.events) ||
+                !base.events.length ||
+                !base.events.every((event) => baseEvent(event, reply.sessionId)) ||
+                (index === 0 && base.events[0].type !== "session_started") ||
+                base.events.some((event, offset) => event.type === "session_started" && index + offset !== 0) ||
+                size > MiB + 4096 ||
+                bytes > 32 * MiB + 40 * 4096 ||
+                typeof base.complete !== "boolean" ||
+                (base.complete
+                    ? base.next !== undefined
+                    : typeof base.next !== "string" ||
+                        !base.next ||
+                        base.next.length > 2048 ||
+                        cursors.has(base.next)))
+                throw new Error("Recovery base is incomplete or exceeds its bound");
+            for (const event of base.events)
+                chat = reduceStream(chat, event);
+            index += base.events.length;
+            if (base.complete)
+                break;
+            cursor = base.next;
+            cursors.add(cursor);
+        }
+    }
+    else {
+        if (reply.page.status !== "ok" ||
+            !reply.legacyBaseComplete ||
+            !reply.legacyBase ||
+            !Array.isArray(reply.legacyBase.events) ||
+            reply.legacyBase.events[0]?.type !== "session_started" ||
+            reply.legacyBase.throughEventId !== reply.page.legacyBaseThroughEventId ||
+            wireBytes(reply.legacyBase) > MiB + 4096)
+            throw new Error("Recovery base is incomplete");
+        for (const event of reply.legacyBase.events)
+            chat = reduceStream(chat, event);
+    }
     // A legacy transcript establishes display history, never live completion.
     chat = { ...chat, run: chat.run === "error" ? "error" : "idle", liveByAgent: {} };
     let recovery = { incomplete: false };
-    let pages = 0;
     // A continuation retains the verified private candidate and the same total
     // page budget. No prefix is published until the eventual frozen join passes.
     const advance = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-web",
-  "version": "0.9.46",
+  "version": "0.9.47",
   "description": "CodeShell web client logic layer — remote-app state (chatReducer + server-event fold), reconnecting WebSocket hook, pairing/device-credential/risk helpers, and the mobile i18n namespace. Browser-only (no Electron, no Node); seed of the standalone browser client.",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,8 +40,8 @@
     "test:host-title-browser": "node ../../scripts/run-isolated-node-smoke.mjs ../../scripts/smoke-web-host-operations.mjs --late-title"
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.46",
-    "@cjhyy/code-shell-link": "0.9.46",
+    "@cjhyy/code-shell-core": "0.9.47",
+    "@cjhyy/code-shell-link": "0.9.47",
     "@types/react": "^19.2.14",
     "qrcode": "1.5.4"
   },