@cjhyy/code-shell-web 0.9.27 → 0.9.29

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export { useRemoteSocket, type ConnStatus, type ResyncReason, type RemoteSocket,
 export * from "./hooks/remoteAppSync.js";
 export * from "./lib/streamReducer.js";
 export * from "./lib/transcriptReplay.js";
+export * from "./lib/outputJournalRecovery.js";
 export * from "./lib/messageMappers.js";
 export * from "./lib/riskClassify.js";
 export * from "./lib/format.js";

package/dist/index.js

@@ -15,6 +15,7 @@ export * from "./hooks/remoteAppSync.js";
 // ── Stream folding (shared with the desktop renderer's CC room view) ────────
 export * from "./lib/streamReducer.js";
 export * from "./lib/transcriptReplay.js";
+export * from "./lib/outputJournalRecovery.js";
 export * from "./lib/messageMappers.js";
 // ── Pure helpers ─────────────────────────────────────────────────────────────
 export * from "./lib/riskClassify.js";

package/dist/lib/outputJournalRecovery.d.ts

@@ -0,0 +1,28 @@
+import type { StreamEvent } from "@cjhyy/code-shell-core";
+import type { OutputJournalPage } from "@cjhyy/code-shell-core/internal";
+/** Per-recovery state; keep it separate from Main/Hub transport sequence state. */
+export interface OutputJournalRecovery {
+    cursor?: string;
+    /** Safe to persist across browser restarts; never points inside a fragmented event. */
+    appliedCursor?: string;
+    through?: string;
+    coverageStart?: string;
+    legacyBaseThroughEventId?: string;
+    incomplete: boolean;
+    pending?: {
+        id: string;
+        total: number;
+        next: number;
+        bytes: number;
+        chunks: Uint8Array[];
+    };
+}
+/** Only compare positions in the same Session journal, never Host counters. */
+export declare function compareOutputCursors(left: string, right: string): number | undefined;
+/**
+ * Fold a frozen, contiguous page exactly once. Callers first load legacy history
+ * through legacyBaseThroughEventId, then apply returned StreamEvents to their
+ * existing reducer. An unpaired legacy transcript remains behind its barrier.
+ * This function neither treats EOF as completion nor changes transport epochs.
+ */
+export declare function applyOutputJournalPage(state: OutputJournalRecovery, page: OutputJournalPage, emit: (event: StreamEvent) => void): boolean;

package/dist/lib/outputJournalRecovery.js

@@ -0,0 +1,148 @@
+import { projectOutputUserEvent } from "./userMessageDisplay.js";
+const MAX_EVENT_BYTES = 16 * 1024 * 1024;
+function position(token) {
+    if (typeof token !== "string" || token.length > 2048 || !/^[A-Za-z0-9_-]+$/.test(token))
+        throw new Error("Invalid output cursor");
+    const parsed = JSON.parse(atob(token.replace(/-/g, "+").replace(/_/g, "/")));
+    if (typeof parsed.identity !== "string" ||
+        !Number.isSafeInteger(parsed.sequence) ||
+        parsed.sequence < 0 ||
+        !Number.isSafeInteger(parsed.offset) ||
+        parsed.offset < 0)
+        throw new Error("Invalid output cursor");
+    return parsed;
+}
+function decodeFragment(value) {
+    if (value.length > Math.ceil((64 * 1024) / 3) * 4 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value))
+        throw new Error("Invalid output fragment");
+    const binary = atob(value);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+/** Only compare positions in the same Session journal, never Host counters. */
+export function compareOutputCursors(left, right) {
+    try {
+        const a = position(left), b = position(right);
+        return a.identity === b.identity ? Math.sign(a.sequence - b.sequence) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Fold a frozen, contiguous page exactly once. Callers first load legacy history
+ * through legacyBaseThroughEventId, then apply returned StreamEvents to their
+ * existing reducer. An unpaired legacy transcript remains behind its barrier.
+ * This function neither treats EOF as completion nor changes transport epochs.
+ */
+export function applyOutputJournalPage(state, page, emit) {
+    if (state.incomplete)
+        return false;
+    try {
+        if (page.version !== 1 ||
+            page.status !== "ok" ||
+            !page.from ||
+            !page.through ||
+            !page.next ||
+            !page.coverageStart ||
+            !Array.isArray(page.frames) ||
+            page.frames.length > 512 ||
+            new TextEncoder().encode(JSON.stringify(page)).length > 1024 * 1024 + 16 * 1024)
+            throw new Error("Output recovery is incomplete");
+        if ((state.cursor ?? page.coverageStart) !== page.from ||
+            (state.through && state.through !== page.through) ||
+            (state.coverageStart && state.coverageStart !== page.coverageStart) ||
+            (state.legacyBaseThroughEventId !== undefined &&
+                state.legacyBaseThroughEventId !== page.legacyBaseThroughEventId))
+            throw new Error("Output recovery page changed its snapshot");
+        let previous = position(page.from);
+        const through = position(page.through);
+        const start = position(page.coverageStart);
+        if (start.sequence !== 0 ||
+            start.identity !== previous.identity ||
+            through.identity !== previous.identity ||
+            previous.sequence > through.sequence)
+            throw new Error("Output recovery cursor domain changed");
+        let pending = state.pending
+            ? { ...state.pending, chunks: state.pending.chunks.slice() }
+            : undefined;
+        let appliedCursor = state.appliedCursor ?? page.from;
+        const events = [];
+        for (const frame of page.frames) {
+            const next = position(frame.cursor);
+            if (next.identity !== previous.identity ||
+                next.sequence !== previous.sequence + 1 ||
+                frame.sequence !== next.sequence ||
+                next.offset <= previous.offset ||
+                next.sequence > through.sequence ||
+                !!frame.event === !!frame.fragment)
+                throw new Error("Output recovery has a gap");
+            let event = frame.event;
+            if (frame.fragment) {
+                const part = frame.fragment;
+                if (!pending) {
+                    if (part.index !== 0 ||
+                        !Number.isSafeInteger(part.total) ||
+                        part.total < 2 ||
+                        part.total > 256)
+                        throw new Error("Output fragment has no beginning");
+                    pending = { id: part.id, total: part.total, next: 0, bytes: 0, chunks: [] };
+                }
+                if (part.id !== pending.id || part.total !== pending.total || part.index !== pending.next)
+                    throw new Error("Output fragment has a gap");
+                const bytes = decodeFragment(part.data);
+                pending.bytes += bytes.length;
+                if (pending.bytes > MAX_EVENT_BYTES)
+                    throw new Error("Output fragment exceeds its budget");
+                pending.chunks.push(bytes);
+                pending.next++;
+                if (pending.next === pending.total) {
+                    const data = new Uint8Array(pending.bytes);
+                    let offset = 0;
+                    for (const chunk of pending.chunks) {
+                        data.set(chunk, offset);
+                        offset += chunk.length;
+                    }
+                    event = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(data));
+                    pending = undefined;
+                }
+            }
+            else if (pending)
+                throw new Error("Output fragment was interrupted");
+            if (event) {
+                if (typeof event !== "object" ||
+                    typeof event.type !== "string" ||
+                    event.outputRecovery === "incomplete")
+                    throw new Error("Invalid output event");
+                events.push({
+                    ...projectOutputUserEvent(event),
+                    outputCursor: frame.cursor,
+                });
+                appliedCursor = frame.cursor;
+            }
+            previous = next;
+        }
+        const next = position(page.next);
+        if (next.identity !== previous.identity ||
+            next.sequence !== previous.sequence ||
+            next.offset !== previous.offset ||
+            (page.frames.at(-1)?.cursor ?? page.from) !== page.next ||
+            page.complete !== (page.next === page.through) ||
+            (page.complete && pending) ||
+            (!page.complete && !page.frames.length))
+            throw new Error("Output recovery page did not establish coverage");
+        state.cursor = page.next;
+        state.appliedCursor = appliedCursor;
+        state.through = page.through;
+        state.coverageStart = page.coverageStart;
+        state.legacyBaseThroughEventId = page.legacyBaseThroughEventId;
+        state.pending = pending;
+        for (const event of events)
+            emit(event);
+        return page.complete;
+    }
+    catch {
+        state.incomplete = true;
+        state.pending = undefined;
+        return false;
+    }
+}

package/dist/lib/streamReducer.d.ts

@@ -21,6 +21,7 @@ export interface UserAttachmentSummary {
     mime?: string;
     size: number;
     path?: string;
+    absPath?: string;
 }
 export type ChatItem = {
     kind: "user";

package/dist/lib/streamReducer.js

@@ -15,6 +15,7 @@
  * UI can scope subagent rows (see commit fbe6f68 — task_update must be isolated
  * by agentId so a subagent never clobbers the main list).
  */
+import { projectOutputUserEvent } from "./userMessageDisplay.js";
 /** Strip <system-reminder>…</system-reminder> blocks from tool output before
  *  rendering — they're context for the model, not status for the user. */
 function stripSystemReminders(s) {
@@ -87,7 +88,8 @@ export function reduceStream(state, raw) {
     const unwrapped = asStreamEvent(raw);
     if (!unwrapped)
         return state;
-    const { event, sessionId } = unwrapped;
+    const { sessionId } = unwrapped;
+    const event = projectOutputUserEvent(unwrapped.event);
     const type = event.type;
     let s = state;
     if (sessionId && sessionId !== s.sessionId) {
@@ -503,7 +505,15 @@ export function reduceStream(state, raw) {
             return { ...s, title: event.title };
         }
         case "session_user_message":
+        case "steer_injected":
         case "user_message": {
+            if (event.agentId)
+                return s;
+            if (event.injected === true ||
+                event.authority === "agent" ||
+                event.authority === "system" ||
+                event.authority === "policy")
+                return s;
             // History replay surfaces past user turns as a synthetic event so the
             // same reducer rebuilds the full conversation (the live path uses
             // appendUserMessage instead, since the phone echoes locally).

package/dist/lib/transcriptReplay.d.ts

@@ -3,16 +3,11 @@
  * stream events used by the live reducer. Keep Node/Electron readers outside
  * this module: the Hub, phone and other browser hosts can share this boundary.
  */
-import { type ChatState, type UserAttachmentSummary } from "./streamReducer.js";
+import { type ChatState } from "./streamReducer.js";
+export { transcriptUserDisplay, projectOutputUserEvent } from "./userMessageDisplay.js";
 type ObjectValue = Record<string, unknown>;
-/** Hide engine attachment plumbing while retaining attachment-only messages. */
-export declare function transcriptUserDisplay(data: ObjectValue): {
-    text: string;
-    attachments: UserAttachmentSummary[];
-};
 /** Durable logs contain both assistant tool_use blocks and dedicated tool_use
  * events. Their tool IDs are identical: emit idempotent starts, never two cards.
  */
 export declare function transcriptToStreamEvents(records: readonly unknown[]): ObjectValue[];
 export declare function replayTranscript(records: readonly unknown[]): ChatState;
-export {};

package/dist/lib/transcriptReplay.js

@@ -3,7 +3,9 @@
  * stream events used by the live reducer. Keep Node/Electron readers outside
  * this module: the Hub, phone and other browser hosts can share this boundary.
  */
-import { initialChatState, reduceStream, } from "./streamReducer.js";
+import { initialChatState, reduceStream } from "./streamReducer.js";
+import { transcriptUserDisplay } from "./userMessageDisplay.js";
+export { transcriptUserDisplay, projectOutputUserEvent } from "./userMessageDisplay.js";
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -25,90 +27,6 @@ function textContent(value) {
         .map((block) => text(block.text))
         .join("");
 }
-function unescapeAttribute(value) {
-    return value
-        .replace(/"/g, '"')
-        .replace(/&lt;/g, "<")
-        .replace(/&gt;/g, ">")
-        .replace(/&amp;/g, "&");
-}
-function attachmentName(path) {
-    const name = path.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "附件";
-    // The canonical staging service prefixes a content hash; it is not part of
-    // the filename the user selected. Other paths keep their original basename.
-    return path.includes(".code-shell/attachments/") ? name.replace(/^[a-f0-9]{16}-/, "") : name;
-}
-function byteSize(value) {
-    const number = typeof value === "number" ? value : Number(value);
-    return Number.isSafeInteger(number) && number >= 0 ? number : 0;
-}
-/** Hide engine attachment plumbing while retaining attachment-only messages. */
-export function transcriptUserDisplay(data) {
-    const attachments = [];
-    const imagePaths = [];
-    let raw = textContent(data.content);
-    raw = raw.replace(/<attached-file\s+path="([^"]*)">\s*([\s\S]*?)<\/attached-file>/g, (match, path, metadata) => {
-        if (!/^absolutePath:\s*.+$/m.test(metadata) || !/^origin:\s*.+$/m.test(metadata)) {
-            return match;
-        }
-        const mime = metadata.match(/^mime:\s*(.+)$/m)?.[1]?.trim();
-        attachments.push({
-            name: attachmentName(unescapeAttribute(path)),
-            path: unescapeAttribute(path),
-            size: byteSize(metadata.match(/^size:\s*(\d+)\s*$/m)?.[1]),
-            ...(mime ? { mime } : {}),
-        });
-        return "";
-    });
-    raw = raw.replace(/<attached-directory\s+path="([^"]*)"[^>]*>[\s\S]*?<\/attached-directory>/g, (_match, path) => {
-        attachments.push({
-            name: `${attachmentName(unescapeAttribute(path))}/`,
-            path: unescapeAttribute(path),
-            size: 0,
-        });
-        return "";
-    });
-    raw = raw.replace(/<attached-image-paths>\s*([\s\S]*?)<\/attached-image-paths>\s*(?:\(上面附带的图片在工作区的真实路径[^\n]*\))?/g, (_match, paths) => {
-        imagePaths.push(...paths
-            .split("\n")
-            .map((path) => path.trim())
-            .filter(Boolean));
-        return "";
-    });
-    const imageBlocks = contentBlocks(data.content).filter((block) => block.type === "image");
-    for (let index = 0; index < Math.max(imageBlocks.length, imagePaths.length); index++) {
-        const source = object(imageBlocks[index]?.source);
-        const encoded = text(source?.data).replace(/\s/g, "");
-        attachments.push({
-            name: imagePaths[index] ? attachmentName(imagePaths[index]) : `图片 ${index + 1}`,
-            ...(imagePaths[index] ? { path: imagePaths[index] } : {}),
-            size: encoded
-                ? Math.max(0, Math.floor((encoded.length * 3) / 4) - (encoded.match(/=+$/)?.[0].length ?? 0))
-                : 0,
-            ...(typeof source?.media_type === "string" ? { mime: source.media_type } : {}),
-        });
-    }
-    const explicit = Array.isArray(data.attachments)
-        ? data.attachments.flatMap((item) => {
-            const attachment = object(item);
-            const name = text(attachment?.name) || text(attachment?.originalName);
-            return name
-                ? [
-                    {
-                        name,
-                        size: byteSize(attachment?.size),
-                        ...(typeof attachment?.mime === "string" ? { mime: attachment.mime } : {}),
-                        ...(typeof attachment?.path === "string" ? { path: attachment.path } : {}),
-                    },
-                ]
-                : [];
-        })
-        : [];
-    return {
-        text: typeof data.displayText === "string" ? data.displayText : raw.trim(),
-        attachments: explicit.length ? explicit : attachments,
-    };
-}
 function eventData(event) {
     return object(event.data) ?? object(event.message) ?? event;
 }

package/dist/lib/userMessageDisplay.d.ts

@@ -0,0 +1,17 @@
+/** Shared browser-only user input projection for live and durable replay. */
+import type { UserAttachmentSummary } from "./streamReducer.js";
+type ObjectValue = Record<string, unknown>;
+/** Hide engine attachment plumbing while retaining attachment-only messages. */
+export declare function transcriptUserDisplay(data: ObjectValue, options?: {
+    includeAbsolutePaths?: boolean;
+    cwd?: string;
+}): {
+    text: string;
+    attachments: UserAttachmentSummary[];
+};
+/** Apply the canonical display projection without copying image payloads. */
+export declare function projectOutputUserEvent<T extends {
+    type?: unknown;
+    transcriptMessage?: unknown;
+}>(event: T): T;
+export {};

package/dist/lib/userMessageDisplay.js

@@ -0,0 +1,130 @@
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+function contentBlocks(value) {
+    return Array.isArray(value)
+        ? value.map(object).filter((block) => block !== undefined)
+        : [];
+}
+function textContent(value) {
+    if (typeof value === "string")
+        return value;
+    return contentBlocks(value)
+        .filter((block) => block.type === "text")
+        .map((block) => text(block.text))
+        .join("");
+}
+function unescapeAttribute(value) {
+    return value
+        .replace(/"/g, '"')
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&");
+}
+function attachmentName(path) {
+    const name = path.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "附件";
+    // The canonical staging service prefixes a content hash; it is not part of
+    // the filename the user selected. Other paths keep their original basename.
+    return path.includes(".code-shell/attachments/") ? name.replace(/^[a-f0-9]{16}-/, "") : name;
+}
+function byteSize(value) {
+    const number = typeof value === "number" ? value : Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : 0;
+}
+/** Hide engine attachment plumbing while retaining attachment-only messages. */
+export function transcriptUserDisplay(data, options = {}) {
+    const attachments = [];
+    const absolutePath = (path) => /^(?:[a-zA-Z]:[\\/]|[\\/])/.test(path) || !options.cwd
+        ? path
+        : `${options.cwd.replace(/[\\/]$/, "")}/${path}`;
+    const imagePaths = [];
+    let raw = textContent(data.content);
+    raw = raw.replace(/<attached-file\s+path="([^"]*)">\s*([\s\S]*?)<\/attached-file>/g, (match, path, metadata) => {
+        if (!/^absolutePath:\s*.+$/m.test(metadata) || !/^origin:\s*.+$/m.test(metadata)) {
+            return match;
+        }
+        const mime = metadata.match(/^mime:\s*(.+)$/m)?.[1]?.trim();
+        attachments.push({
+            name: attachmentName(unescapeAttribute(path)),
+            path: unescapeAttribute(path),
+            ...(options.includeAbsolutePaths
+                ? { absPath: metadata.match(/^absolutePath:\s*(.+)$/m)[1].trim() }
+                : {}),
+            size: byteSize(metadata.match(/^size:\s*(\d+)\s*$/m)?.[1]),
+            ...(mime ? { mime } : {}),
+        });
+        return "";
+    });
+    raw = raw.replace(/<attached-directory\s+path="([^"]*)"[^>]*>[\s\S]*?<\/attached-directory>/g, (_match, path) => {
+        attachments.push({
+            name: `${attachmentName(unescapeAttribute(path))}/`,
+            path: unescapeAttribute(path),
+            ...(options.includeAbsolutePaths ? { absPath: absolutePath(unescapeAttribute(path)) } : {}),
+            size: 0,
+        });
+        return "";
+    });
+    raw = raw.replace(/<attached-image-paths>\s*([\s\S]*?)<\/attached-image-paths>\s*(?:\(上面附带的图片在工作区的真实路径[^\n]*\))?/g, (_match, paths) => {
+        imagePaths.push(...paths
+            .split("\n")
+            .map((path) => path.trim())
+            .filter(Boolean));
+        return "";
+    });
+    const imageBlocks = contentBlocks(data.content).filter((block) => block.type === "image");
+    for (let index = 0; index < Math.max(imageBlocks.length, imagePaths.length); index++) {
+        const source = object(imageBlocks[index]?.source);
+        const encoded = text(source?.data).replace(/\s/g, "");
+        attachments.push({
+            name: imagePaths[index] ? attachmentName(imagePaths[index]) : `图片 ${index + 1}`,
+            ...(imagePaths[index] ? { path: imagePaths[index] } : {}),
+            ...(options.includeAbsolutePaths && imagePaths[index]
+                ? { absPath: absolutePath(imagePaths[index]) }
+                : {}),
+            size: encoded
+                ? Math.max(0, Math.floor((encoded.length * 3) / 4) - (encoded.match(/=+$/)?.[0].length ?? 0))
+                : byteSize(source?.byteLength),
+            ...(typeof source?.media_type === "string" ? { mime: source.media_type } : {}),
+        });
+    }
+    const explicit = Array.isArray(data.attachments)
+        ? data.attachments.flatMap((item) => {
+            const attachment = object(item);
+            const name = text(attachment?.name) || text(attachment?.originalName);
+            return name
+                ? [
+                    {
+                        name,
+                        size: byteSize(attachment?.size),
+                        ...(typeof attachment?.mime === "string" ? { mime: attachment.mime } : {}),
+                        ...(typeof attachment?.path === "string" ? { path: attachment.path } : {}),
+                    },
+                ]
+                : [];
+        })
+        : [];
+    return {
+        text: typeof data.displayText === "string" ? data.displayText : raw.trim(),
+        attachments: explicit.length ? explicit : attachments,
+    };
+}
+/** Apply the canonical display projection without copying image payloads. */
+export function projectOutputUserEvent(event) {
+    if (event.type !== "session_user_message" && event.type !== "steer_injected")
+        return event;
+    const message = object(event.transcriptMessage);
+    return message
+        ? {
+            ...event,
+            ...transcriptUserDisplay(message, {
+                includeAbsolutePaths: true,
+                ...(typeof message.cwd === "string" ? { cwd: message.cwd } : {}),
+            }),
+        }
+        : event;
+}