@cjhyy/code-shell-web 0.9.43 → 0.9.46

package/dist/hooks/useRemoteApp.d.ts

@@ -19,6 +19,14 @@ export interface PendingApproval {
     options?: string[];
     /** When true, the user must pick an option (no free text). */
     optionsOnly?: boolean;
+    /** CLI AskUserQuestion asking several questions in one request. They are
+     *  answered together: the request accepts exactly one response. */
+    questions?: Array<{
+        question: string;
+        header?: string;
+        options: string[];
+        multiSelect: boolean;
+    }>;
     /** A nonblocking question remains answerable after the run ends. */
     asynchronous?: boolean;
     /** True for path-scoped tools (Read/Edit/Write/…) → show file/dir scope. */
@@ -36,6 +44,8 @@ export interface RemoteApp {
     /** The bound room — for the user this is always an external CC (Claude Code)
      *  session. The room is internal transport; there is no user-facing room list. */
     activeRoom?: RoomPublic;
+    /** Set while a CLI room is bound, even before its metadata has loaded. */
+    activeRoomId?: string;
     approvals: PendingApproval[];
     permissionMode: PermissionMode;
     loading: {
@@ -50,9 +60,17 @@ export interface RemoteApp {
     };
     notice?: string;
     logout: () => void;
+    /** Resolves true once the host accepted the message. */
     sendChat: (input: {
         text: string;
         attachments: MobileComposerAttachment[];
+        modelTraceSource?: string;
+        /** Retry an earlier intent whose delivery could not be confirmed. The host
+         *  ignores an ID it already recorded, so the task never runs twice. */
+        clientMessageId?: string;
+        /** The frame reached the socket but neither acceptance nor rejection
+         *  arrived (lost connection or timeout): the host may have run it. */
+        onUncertain?: (clientMessageId: string) => void;
     }) => Promise<boolean>;
     stopRun: () => void;
     selectSession: (id: string) => void;
@@ -81,14 +99,11 @@ export interface RemoteApp {
     ccCliKind: CcCliKind;
     setCcCliKind: (kind: CcCliKind) => void;
     openCcSession: (sessionId: string, cwd: string, mode: PermissionMode) => void;
-    respondCcApproval: (roomId: string, requestId: string, decision: {
-        behavior: "allow";
-        updatedInput?: unknown;
-    } | {
-        behavior: "deny";
-        message: string;
-    }) => void;
+    respondCcApproval: (roomId: string, requestId: string, decision: CcApprovalDecision) => void;
 }
+type CcApprovalDecision = Extract<import("@cjhyy/code-shell-core").MobileClientEvent, {
+    type: "ccRoom.respondApproval";
+}>["decision"];
 export type MobileSessionCreateTarget = {
     projectId: string;
     rootId?: string;
@@ -101,3 +116,4 @@ export interface RemoteAppOptions {
     onNotification?: (method: string, params: Record<string, unknown>) => void;
 }
 export declare function useRemoteApp(options?: RemoteAppOptions): RemoteApp;
+export {};

package/dist/hooks/useRemoteApp.js

@@ -9,6 +9,9 @@ import { MobileOutputClient } from "./mobileOutputClient.js";
 import { useRemoteSocket } from "./useRemoteSocket.js";
 import { prepareMobileAttachments, } from "../lib/mobileAttachments.js";
 import { filterNewRoomMessages, clearUnreadSession, markSessionUnread, markRoomSeqApplied, maxRoomSeq, alignSessionEpoch, pruneUnreadSessions, rawApprovalResolvedRequestId, removeResolvedApproval, roomMessageSeq, selectSessionReplayEntries, } from "./remoteAppSync.js";
+/** The host explicitly refused a message, so it was not admitted. */
+class MessageRejectedError extends Error {
+}
 /** Tools whose grants can be remembered with a path scope (file/dir). */
 const PATH_SCOPED = new Set([
     "Read",
@@ -80,6 +83,10 @@ export function useRemoteApp(options = {}) {
     const approvalsRef = useRef(approvals);
     approvalsRef.current = approvals;
     const submittingAsyncApprovalsRef = useRef(new Set());
+    /** Synchronous approvals whose card was consumed on send. A correlated
+     *  delivery error asks Main to replay them if Core still holds the request. */
+    const submittedApprovalsRef = useRef(new Set());
+    const requestActiveResyncRef = useRef(() => undefined);
     // The SELECTED project (one-true-source for "what am I looking at"), distinct
     // from activeSessionCwd which is derived from the bound session. Drives session
     // list filtering AND ccRoom.listSessions.
@@ -101,6 +108,8 @@ export function useRemoteApp(options = {}) {
      *  socket's callback), so it can't close over `socket` directly. */
     const sendRef = useRef(null);
     const connectionGenerationRef = useRef(0);
+    /** Image PUTs in flight; a lost connection aborts them so sending recovers. */
+    const uploadAbortsRef = useRef(new Set());
     const uploadWaitersRef = useRef(new Map());
     const conversationRevisionRef = useRef(0);
     const pendingCreateRef = useRef(null);
@@ -185,6 +194,9 @@ export function useRemoteApp(options = {}) {
             waiter.resolve();
     }, []);
     useEffect(() => () => {
+        for (const upload of uploadAbortsRef.current)
+            upload.abort(new Error("Remote app closed"));
+        uploadAbortsRef.current.clear();
         for (const waiter of uploadWaitersRef.current.values()) {
             clearTimeout(waiter.timer);
             waiter.reject(new Error("Remote app closed"));
@@ -226,8 +238,10 @@ export function useRemoteApp(options = {}) {
      * subscription cwd from activeProjectCwd. */
     const ccHistoryCwdRef = useRef(undefined);
     /** openSession replies do not echo cwd. Keep it keyed by the requested
-     * session until ccRoom.opened confirms which room acquired it. */
-    const pendingCcOpenCwdsRef = useRef(new Map());
+     * session until ccRoom.opened confirms which room acquired it. The
+     * conversation revision of the request lets a reply that arrives after the
+     * user navigated elsewhere be discarded instead of navigating back. */
+    const pendingCcOpensRef = useRef(new Map());
     const ccBacklogLoadedRef = useRef(false);
     /** Which CLI the currently-open cc session belongs to — selects the on-disk
      *  history reader (claude vs codex rollout) for ccRoom.readHistory. Captured
@@ -247,6 +261,7 @@ export function useRemoteApp(options = {}) {
     }, []);
     const clearApproval = useCallback((requestId) => {
         submittingAsyncApprovalsRef.current.delete(requestId);
+        submittedApprovalsRef.current.delete(requestId);
         approvalsRef.current = removeResolvedApproval(approvalsRef.current, requestId);
         setApprovals((prev) => removeResolvedApproval(prev, requestId));
     }, []);
@@ -317,6 +332,9 @@ export function useRemoteApp(options = {}) {
         if (a.sessionId) {
             if (boundSessionRef.current && a.sessionId !== boundSessionRef.current)
                 return;
+            // A pending creation owns the unbound view; only its acceptance binds it.
+            if (!boundSessionRef.current && pendingCreateRef.current)
+                return;
             if (!boundSessionRef.current) {
                 boundSessionRef.current = a.sessionId;
                 setActiveSessionId(a.sessionId);
@@ -558,6 +576,12 @@ export function useRemoteApp(options = {}) {
                         break;
                     }
                 }
+                else if (pendingCreateRef.current) {
+                    // Another task's output while a new session awaits its acceptance:
+                    // binding it would move the new conversation (and its draft) there.
+                    setUnreadSessionIds((prev) => markSessionUnread(prev, event.sessionId));
+                    break;
+                }
                 else {
                     boundSessionRef.current = event.sessionId;
                     setActiveSessionId(event.sessionId);
@@ -753,6 +777,11 @@ export function useRemoteApp(options = {}) {
             case "room.closed":
                 // Keep the internal room snapshot in sync (resolves activeRoom metadata).
                 setRooms((prev) => prev.map((r) => (r.id === event.roomId ? { ...r, open: false } : r)));
+                // The room's process is gone, so no turn is running any more. Its
+                // stopped process cannot report its own turn end.
+                if (event.roomId === activeRoomIdRef.current) {
+                    dispatchChat({ kind: "raw", raw: { type: "turn_complete", reason: "aborted_tools" } });
+                }
                 break;
             case "room.recovery":
                 if (event.roomId === activeRoomIdRef.current) {
@@ -772,16 +801,21 @@ export function useRemoteApp(options = {}) {
                     setLoadingKey("roomHistory", false);
                 }
                 if (event.clientMessageId) {
-                    settleMessageAck(event.clientMessageId, new Error(event.message));
+                    settleMessageAck(event.clientMessageId, new MessageRejectedError(event.message));
                 }
                 setNotice(event.message || t("mobile.notice.roomError"));
                 break;
             case "error":
                 if (event.approvalId) {
                     submittingAsyncApprovalsRef.current.delete(event.approvalId);
+                    // The decision did not reach Core. The request may still be
+                    // pending there; an authoritative resync replays its card.
+                    if (submittedApprovalsRef.current.delete(event.approvalId)) {
+                        requestActiveResyncRef.current();
+                    }
                 }
                 if (event.clientMessageId) {
-                    settleMessageAck(event.clientMessageId, new Error(event.message));
+                    settleMessageAck(event.clientMessageId, new MessageRejectedError(event.message));
                 }
                 setNotice(event.message);
                 setLoading({
@@ -829,9 +863,13 @@ export function useRemoteApp(options = {}) {
                     setLoadingKey("ccSessions", false);
                 }
                 break;
-            case "ccRoom.opened":
+            case "ccRoom.opened": {
+                const request = pendingCcOpensRef.current.get(event.sessionId);
+                pendingCcOpensRef.current.delete(event.sessionId);
+                // Only this browser's latest open request may change navigation.
+                if (!request || request.revision !== conversationRevisionRef.current)
+                    break;
                 if (event.status === "missing") {
-                    pendingCcOpenCwdsRef.current.delete(event.sessionId);
                     setNotice(t("mobile.notice.ccRoomOpenFailed"));
                     break;
                 }
@@ -854,17 +892,14 @@ export function useRemoteApp(options = {}) {
                         ...room,
                         open: event.status === "running",
                         observing: event.status === "observing",
+                        ...(event.permissionMode ? { permissionMode: event.permissionMode } : {}),
                     }
                     : room));
                 // Refresh metadata even when this room was created after the last
                 // room.list snapshot, so the mobile view can display read-only state.
                 sendRef.current?.({ type: "room.list" });
                 ccHistorySessionRef.current = event.sessionId;
-                ccHistoryCwdRef.current =
-                    pendingCcOpenCwdsRef.current.get(event.sessionId) ??
-                        activeProjectCwdRef.current ??
-                        undefined;
-                pendingCcOpenCwdsRef.current.delete(event.sessionId);
+                ccHistoryCwdRef.current = request.cwd;
                 ccBacklogLoadedRef.current = false;
                 boundSessionRef.current = undefined;
                 setApprovals([]);
@@ -887,6 +922,7 @@ export function useRemoteApp(options = {}) {
                     requestRoomCatchup(event.roomId, 0);
                 }
                 break;
+            }
             case "ccRoom.transcriptSubscribed":
                 // Atomic snapshot + live subscription. roomCursor identifies exactly
                 // where the snapshot ended in the shared room log; the incremental
@@ -948,6 +984,9 @@ export function useRemoteApp(options = {}) {
                             risk,
                             options: askUser?.options,
                             optionsOnly: false,
+                            ...(askUser?.questions && askUser.questions.length > 1
+                                ? { questions: askUser.questions }
+                                : {}),
                             pathScoped: PATH_SCOPED.has(event.req.toolName),
                         },
                     ]);
@@ -1024,6 +1063,9 @@ export function useRemoteApp(options = {}) {
                 if (sid && sid !== boundSessionRef.current)
                     return;
             }
+            else if (pendingCreateRef.current) {
+                return; // the pending creation's acceptance decides the binding
+            }
             else if (sid) {
                 // Auto-bind to the first session we see so the feed is coherent.
                 boundSessionRef.current = sid;
@@ -1084,6 +1126,7 @@ export function useRemoteApp(options = {}) {
             ...(cursor.epoch ? { epoch: cursor.epoch } : {}),
         });
     }, [setLoadingKey, sessionCursor, requestRoomCatchup]);
+    requestActiveResyncRef.current = requestActiveResync;
     const socket = useRemoteSocket({
         onServerEvent,
         onRawLine,
@@ -1096,7 +1139,11 @@ export function useRemoteApp(options = {}) {
             return;
         outputClient.cancel(false);
         submittingAsyncApprovalsRef.current.clear();
+        submittedApprovalsRef.current.clear();
         const error = new Error("Remote connection was lost");
+        for (const upload of uploadAbortsRef.current)
+            upload.abort(error);
+        uploadAbortsRef.current.clear();
         for (const waiter of uploadWaitersRef.current.values()) {
             clearTimeout(waiter.timer);
             waiter.reject(error);
@@ -1119,17 +1166,21 @@ export function useRemoteApp(options = {}) {
         const conversationRevision = conversationRevisionRef.current;
         const roomId = activeRoomIdRef.current;
         const sessionId = boundSessionRef.current;
-        const clientMessageId = globalThis.crypto?.randomUUID?.() ??
+        const clientMessageId = input.clientMessageId ??
+            globalThis.crypto?.randomUUID?.() ??
             `mobile-message-${Date.now()}-${Math.random().toString(36).slice(2)}`;
         let attachments;
         if (roomId && roomsRef.current.find((room) => room.id === roomId)?.observing) {
             setNotice(t("mobile.notice.ccRoomObserving"));
             return false;
         }
+        const upload = new AbortController();
+        uploadAbortsRef.current.add(upload);
         try {
             attachments = await prepareMobileAttachments(input.attachments, {
                 beginUpload: (metadata) => beginMobileUpload(metadata, connectionGeneration),
                 fetch: window.fetch.bind(window),
+                signal: upload.signal,
             });
         }
         catch (error) {
@@ -1138,6 +1189,9 @@ export function useRemoteApp(options = {}) {
             }));
             return false;
         }
+        finally {
+            uploadAbortsRef.current.delete(upload);
+        }
         if (conversationRevision !== conversationRevisionRef.current)
             return false;
         const summaries = attachments.map(({ name, mime, size }) => ({ name, mime, size }));
@@ -1159,6 +1213,7 @@ export function useRemoteApp(options = {}) {
         else {
             queued = socket.send({
                 type: "chat.send",
+                ...(input.modelTraceSource ? { modelTraceSource: input.modelTraceSource } : {}),
                 text,
                 sessionId,
                 clientMessageId,
@@ -1174,6 +1229,9 @@ export function useRemoteApp(options = {}) {
             await acknowledged;
         }
         catch (error) {
+            // Only an explicit host rejection proves the message was not admitted.
+            if (!(error instanceof MessageRejectedError))
+                input.onUncertain?.(clientMessageId);
             setNotice(t("mobile.notice.attachmentSendFailed", {
                 error: error instanceof Error ? error.message : String(error),
             }));
@@ -1190,6 +1248,14 @@ export function useRemoteApp(options = {}) {
         return true;
     }, [beginMobileUpload, setNotice, settleMessageAck, socket, waitForMessageAck]);
     const stopRun = useCallback(() => {
+        const roomId = activeRoomIdRef.current;
+        if (roomId) {
+            // A CLI room runs in its own resident process, not a native session.
+            // Closing it stops the process; the next message resumes the same CLI
+            // conversation.
+            socket.send({ type: "room.close", roomId });
+            return;
+        }
         socket.send({ type: "run.stop", sessionId: boundSessionRef.current });
     }, [socket]);
     const refreshSessions = useCallback(() => {
@@ -1246,22 +1312,51 @@ export function useRemoteApp(options = {}) {
         // Pin the CLI this session belongs to so its on-disk backlog is read with
         // the right reader even if the user switches the pane's CLI afterward.
         ccHistoryKindRef.current = ccCliKindRef.current;
-        pendingCcOpenCwdsRef.current.set(sessionId, cwd);
+        pendingCcOpensRef.current.set(sessionId, {
+            cwd,
+            revision: conversationRevisionRef.current,
+        });
         socket.send({ type: "ccRoom.openSession", sessionId, cwd, mode, kind: ccCliKindRef.current });
     }, [socket]);
     const respondCcApproval = useCallback((roomId, requestId, decision) => {
         const a = approvalsRef.current.find((p) => p.requestId === requestId);
         if (!a)
             return; // approve-once: already resolved
-        socket.send({ type: "ccRoom.respondApproval", roomId, requestId, decision });
+        // An unsent response never reaches the CLI, which is still waiting.
+        // Keep the card so the user can retry once the connection recovers.
+        if (!socket.send({ type: "ccRoom.respondApproval", roomId, requestId, decision })) {
+            setNotice(t("mobile.notice.approvalSendFailed"));
+            return;
+        }
         approvalsRef.current = approvalsRef.current.filter((p) => p.requestId !== requestId);
         setApprovals((prev) => prev.filter((p) => p.requestId !== requestId));
-    }, [socket]);
+    }, [setNotice, socket]);
     const newSession = useCallback((target, name) => {
-        outputClient.cancel();
-        conversationRevisionRef.current += 1;
         const clientRequestId = globalThis.crypto?.randomUUID?.() ??
             `mobile-create-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        const stableTarget = target === undefined && activeProjectIdRef.current
+            ? { projectId: activeProjectIdRef.current }
+            : target;
+        // Creation needs the host's acceptance. Send it before switching the
+        // view: offline, a dropped frame used to leave the view on the new target
+        // while a later first send fell back to the previous (possibly another
+        // project's) session.
+        const created = socket.send(stableTarget && typeof stableTarget === "object"
+            ? { type: "session.create", clientRequestId, ...stableTarget, ...(name ? { name } : {}) }
+            : stableTarget === undefined
+                ? { type: "session.create", clientRequestId, ...(name ? { name } : {}) }
+                : {
+                    type: "session.create",
+                    clientRequestId,
+                    cwd: stableTarget,
+                    ...(name ? { name } : {}),
+                });
+        if (!created) {
+            setNotice(t("mobile.notice.createOffline"));
+            return;
+        }
+        outputClient.cancel();
+        conversationRevisionRef.current += 1;
         pendingCreateRef.current = {
             clientRequestId,
             conversationRevision: conversationRevisionRef.current,
@@ -1273,9 +1368,6 @@ export function useRemoteApp(options = {}) {
                 roomId: activeRoomIdRef.current,
             });
         }
-        const stableTarget = target === undefined && activeProjectIdRef.current
-            ? { projectId: activeProjectIdRef.current }
-            : target;
         const selectedProject = stableTarget && typeof stableTarget === "object" && stableTarget.projectId
             ? projectsRef.current.find((project) => project.id === stableTarget.projectId)
             : undefined;
@@ -1315,25 +1407,7 @@ export function useRemoteApp(options = {}) {
         setApprovals([]);
         setLoadingKey("sessionHistory", false);
         dispatchChat({ kind: "reset" });
-        if (stableTarget && typeof stableTarget === "object") {
-            socket.send({
-                type: "session.create",
-                clientRequestId,
-                ...stableTarget,
-                ...(name ? { name } : {}),
-            });
-        }
-        else {
-            socket.send(stableTarget === undefined
-                ? { type: "session.create", clientRequestId, ...(name ? { name } : {}) }
-                : {
-                    type: "session.create",
-                    clientRequestId,
-                    cwd: stableTarget,
-                    ...(name ? { name } : {}),
-                });
-        }
-    }, [socket, setLoadingKey]);
+    }, [socket, setLoadingKey, setNotice]);
     const respondApproval = useCallback((requestId, decision, opts) => {
         const a = approvalsRef.current.find((p) => p.requestId === requestId);
         // Dedup at the source: if this approval is already gone from the ref it was
@@ -1361,12 +1435,17 @@ export function useRemoteApp(options = {}) {
             submittingAsyncApprovalsRef.current.add(requestId);
             return;
         }
+        submittedApprovalsRef.current.add(requestId);
         // Update the ref synchronously too so a second tap in the same tick (before
         // the async setApprovals commits) sees it gone and no-ops above.
         approvalsRef.current = approvalsRef.current.filter((p) => p.requestId !== requestId);
         setApprovals((prev) => prev.filter((p) => p.requestId !== requestId));
     }, [socket]);
     const setPermissionMode = useCallback((mode) => {
+        // A CLI room's mode is a spawn-time argument of its process; the native
+        // session mode does not govern it. Never pretend to change it here.
+        if (activeRoomIdRef.current)
+            return;
         setPermissionModeState(mode);
         socket.send({ type: "permission.setMode", sessionId: boundSessionRef.current, mode });
     }, [socket]);
@@ -1388,6 +1467,11 @@ export function useRemoteApp(options = {}) {
         ccHistorySessionRef.current = undefined;
         ccHistoryCwdRef.current = undefined;
         ccBacklogLoadedRef.current = false;
+        // The room's cards belong to the conversation being left and must not
+        // block other conversations. The host keeps the requests pending and
+        // replays them when the room is opened again.
+        approvalsRef.current = approvalsRef.current.filter((approval) => !approval.roomId);
+        setApprovals((prev) => prev.filter((approval) => !approval.roomId));
         setLoadingKey("roomHistory", false);
         dispatchChat({ kind: "reset" });
     }, [setLoadingKey, socket]);
@@ -1439,6 +1523,7 @@ export function useRemoteApp(options = {}) {
         activeCwd,
         projects,
         activeRoom,
+        activeRoomId,
         approvals,
         permissionMode,
         loading,

package/dist/i18n/mobile.d.ts

@@ -97,6 +97,8 @@ export declare const mobile: {
                 readonly ccRoomOpenFailed: "cc 会话无法打开";
                 readonly ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送";
                 readonly attachmentSendFailed: "图片发送失败：{error}";
+                readonly createOffline: "连接已断开，重新连接后才能新建任务。";
+                readonly approvalSendFailed: "审批未送达，请检查连接后重试";
             };
             readonly permissionMode: {
                 readonly default: "默认";
@@ -261,6 +263,8 @@ export declare const mobile: {
                 readonly ccRoomOpenFailed: "Could not open cc session";
                 readonly ccRoomObserving: "This CC session is read-only; the message was not sent";
                 readonly attachmentSendFailed: "Could not send images: {error}";
+                readonly createOffline: "Disconnected. Reconnect before starting a new task.";
+                readonly approvalSendFailed: "The approval was not delivered. Check the connection and try again.";
             };
             readonly permissionMode: {
                 readonly default: "Default";

package/dist/i18n/mobile.js

@@ -97,6 +97,8 @@ export const mobile = {
                 ccRoomOpenFailed: "cc 会话无法打开",
                 ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送",
                 attachmentSendFailed: "图片发送失败：{error}",
+                createOffline: "连接已断开，重新连接后才能新建任务。",
+                approvalSendFailed: "审批未送达，请检查连接后重试",
             },
             permissionMode: {
                 default: "默认",
@@ -261,6 +263,8 @@ export const mobile = {
                 ccRoomOpenFailed: "Could not open cc session",
                 ccRoomObserving: "This CC session is read-only; the message was not sent",
                 attachmentSendFailed: "Could not send images: {error}",
+                createOffline: "Disconnected. Reconnect before starting a new task.",
+                approvalSendFailed: "The approval was not delivered. Check the connection and try again.",
             },
             permissionMode: {
                 default: "Default",

package/dist/i18n/translate.d.ts

@@ -107,6 +107,8 @@ export declare const webMessages: {
                 readonly ccRoomOpenFailed: "cc 会话无法打开";
                 readonly ccRoomObserving: "此 CC 会话当前为只读查看，消息未发送";
                 readonly attachmentSendFailed: "图片发送失败：{error}";
+                readonly createOffline: "连接已断开，重新连接后才能新建任务。";
+                readonly approvalSendFailed: "审批未送达，请检查连接后重试";
             };
             readonly permissionMode: {
                 readonly default: "默认";
@@ -271,6 +273,8 @@ export declare const webMessages: {
                 readonly ccRoomOpenFailed: "Could not open cc session";
                 readonly ccRoomObserving: "This CC session is read-only; the message was not sent";
                 readonly attachmentSendFailed: "Could not send images: {error}";
+                readonly createOffline: "Disconnected. Reconnect before starting a new task.";
+                readonly approvalSendFailed: "The approval was not delivered. Check the connection and try again.";
             };
             readonly permissionMode: {
                 readonly default: "Default";

package/dist/index.d.ts

@@ -25,7 +25,9 @@ export * from "./lib/mobileAttachments.js";
 export * from "./lib/uiLanguage.js";
 export * from "./link-authorization.js";
 export * from "./link-authorization-view.js";
+export * from "./model-trace-api.js";
 export { mobile } from "./i18n/mobile.js";
 export { translate, t, webMessages, type WebTranslationKey, type WebTranslateParams, } from "./i18n/translate.js";
 export { isEnvironmentDescriptor, projectReferenceKey } from "./lib/environment.js";
 export type { EnvironmentDescriptor, ProjectReference } from "./lib/environment.js";
+export { ModelTraceExplorer } from "./components/ModelTraceExplorer.js";

package/dist/index.js

@@ -28,7 +28,9 @@ export * from "./lib/mobileAttachments.js";
 export * from "./lib/uiLanguage.js";
 export * from "./link-authorization.js";
 export * from "./link-authorization-view.js";
+export * from "./model-trace-api.js";
 // ── i18n: mobile namespace dict + zh-fallback translate ─────────────────────
 export { mobile } from "./i18n/mobile.js";
 export { translate, t, webMessages, } from "./i18n/translate.js";
 export { isEnvironmentDescriptor, projectReferenceKey } from "./lib/environment.js";
+export { ModelTraceExplorer } from "./components/ModelTraceExplorer.js";

package/dist/lib/format.d.ts

@@ -5,10 +5,13 @@ interface ProjectPathLike {
     id?: string;
     path: string;
     name: string;
+    pathCaseSensitive?: boolean;
     roots?: Array<{
         path: string;
     }>;
 }
+/** Compare Host paths using that project's declared canonical-key policy. */
+export declare function sameProjectPath(left: string | null | undefined, right: string | null | undefined, project?: ProjectPathLike): boolean;
 /** Return the desktop project whose V2 root owns `cwd` (longest prefix wins). */
 export declare function projectForCwd<T extends ProjectPathLike>(cwd: string | null | undefined, projects?: T[]): T | undefined;
 /** Group items by their cwd (project). When desktop project order is provided

package/dist/lib/format.js

@@ -8,14 +8,30 @@ export function basename(p) {
     const parts = p.replace(/[/\\]+$/, "").split(/[/\\]/);
     return parts[parts.length - 1] ?? "";
 }
-function normalizePath(p) {
-    const normalized = p.replace(/\\/g, "/").replace(/\/+$/, "");
+function isWindowsPath(p) {
+    return /^[a-z]:[/\\]/i.test(p) || /^\\\\[^\\]+\\[^\\]+/.test(p);
+}
+function normalizePath(p, project) {
+    const windows = isWindowsPath(project.path);
+    const normalized = (windows ? p.replace(/\\/g, "/") : p).replace(/\/+$/, "");
     return normalized === "" ? "/" : normalized;
 }
-function isSameOrInside(cwd, root) {
-    const target = normalizePath(cwd).toLowerCase();
-    const base = normalizePath(root).toLowerCase();
-    return target === base || target.startsWith(`${base}/`);
+function comparisonPath(path, project) {
+    const normalized = normalizePath(path, project);
+    const sensitive = project.pathCaseSensitive ?? !isWindowsPath(project.path);
+    return sensitive ? normalized : normalized.toLocaleLowerCase("en-US");
+}
+function isSameOrInside(cwd, root, project) {
+    const target = comparisonPath(cwd, project);
+    const base = comparisonPath(root, project);
+    return target === base || target.startsWith(base.endsWith("/") ? base : `${base}/`);
+}
+/** Compare Host paths using that project's declared canonical-key policy. */
+export function sameProjectPath(left, right, project) {
+    if (!left || !right)
+        return left === right;
+    const policy = project ?? { path: left, name: "" };
+    return comparisonPath(left, policy) === comparisonPath(right, policy);
 }
 /** Return the desktop project whose V2 root owns `cwd` (longest prefix wins). */
 export function projectForCwd(cwd, projects = []) {
@@ -26,9 +42,9 @@ export function projectForCwd(cwd, projects = []) {
     for (const p of projects) {
         const roots = p.roots?.length ? p.roots.map((root) => root.path) : [p.path];
         for (const root of roots) {
-            if (!root || !isSameOrInside(cwd, root))
+            if (!root || !isSameOrInside(cwd, root, p))
                 continue;
-            const len = normalizePath(root).length;
+            const len = normalizePath(root, p).length;
             if (len > bestLen) {
                 best = p;
                 bestLen = len;

package/dist/lib/mobileAttachments.d.ts

@@ -17,6 +17,8 @@ export interface MobileUploadTicket {
 interface PrepareOptions {
     beginUpload: (metadata: MobileImageBase) => Promise<MobileUploadTicket>;
     fetch: typeof fetch;
+    /** Aborts an upload already in flight, e.g. when its connection is lost. */
+    signal?: AbortSignal;
 }
 export declare function normalizeMobileImage(file: File): Promise<File>;
 export declare function prepareMobileAttachments(attachments: MobileComposerAttachment[], options: PrepareOptions): Promise<MobileImageAttachment[]>;

package/dist/lib/mobileAttachments.js

@@ -44,13 +44,15 @@ async function canvasJpeg(file) {
     }
 }
 export async function normalizeMobileImage(file) {
-    const mime = file.type.toLowerCase();
-    if (mime === "image/jpg") {
-        return new File([await file.arrayBuffer()], file.name, {
+    // An accepted MIME alias still follows the ordinary conversion/size rules.
+    // Wrap the Blob directly to preserve bytes without an extra full-buffer copy.
+    if (file.type.toLowerCase() === "image/jpg") {
+        file = new File([file], file.name, {
             type: "image/jpeg",
             lastModified: file.lastModified,
         });
     }
+    const mime = file.type.toLowerCase();
     if (SUPPORTED_MIMES.has(mime) && file.size <= MOBILE_MAX_IMAGE_BYTES) {
         return file;
     }
@@ -112,6 +114,7 @@ export async function prepareMobileAttachments(attachments, options) {
             headers: { "Content-Type": mime },
             body: file,
             credentials: "same-origin",
+            ...(options.signal ? { signal: options.signal } : {}),
         });
         if (!response.ok)
             throw new Error(`Image upload failed (${response.status})`);