@cjhyy/code-shell-server 0.9.43 → 0.9.46

package/dist/links/types.d.ts

@@ -1,6 +1,26 @@
-export type { LinkAuthorization, LinkAuthMode, LinkAuthorizationInput, LinkAuthorizationResponse, LinkAuthorizationStep, LinkConnectionInput, LinkErrorCode, LinkSnapshot, MaskedLinkConnection, TokenConnectionInput, } from "@cjhyy/code-shell-link";
+export type { LinkAuthorization, LinkAuthorizationFailure, LinkAuthMode, LinkAuthorizationInput, LinkAuthorizationResponse, LinkAuthorizationStep, LinkConnectionInput, LinkErrorCode, LinkSnapshot, MaskedLinkConnection, TokenConnectionInput, } from "@cjhyy/code-shell-link";
 export interface LinkOperationContext {
     ownerId: string;
     /** Rechecked after every external await and immediately before persistence. */
     authorize: () => boolean | Promise<boolean>;
+    /** Native Host request lifetime; never accepted from the remote request body. */
+    signal?: AbortSignal;
+}
+/** Trusted Host integration. Secrets and registration settings never enter browser inputs. */
+export interface HostLinkOAuthAdapter {
+    providerId: string;
+    methodId: string;
+    authModeId: string;
+    label: string;
+    authorize(input: {
+        id: string;
+        label: string;
+        previous: import("@cjhyy/code-shell-core").Credential | null;
+        signal: AbortSignal;
+        onAuthorizationUrl(url: string, expiresAt: string): Promise<void>;
+    }): Promise<import("@cjhyy/code-shell-core").Credential>;
+    /** The adapter owns its callback listener; the native browser must not bind it again. */
+    openAuthorizationUrl(url: string): Promise<void>;
+    /** Called after local authority is removed; must not delete a subsequently reconnected record. */
+    disconnect?(credential: import("@cjhyy/code-shell-core").Credential): Promise<void>;
 }

package/dist/mobile-remote/codex-parse.d.ts

@@ -14,8 +14,10 @@ import type { ResidentAgentEvent } from "./resident-agent.js";
  *       item.type "reasoning"         → []      (thinking noise)
  *       item.type "command_execution" → tool(Bash) on start, tool_result on complete
  *       item.type "mcp_tool_call"     → tool(server__tool) on start, tool_result on complete
+ *                                        (result.content text blocks, or error.message on failure)
  *       item.type "web_search"        → tool(WebSearch) on start
- *       item.type "file_change"       → tool(Edit) on start
+ *       item.type "file_change"       → tool(Edit) + tool_result on complete (only the
+ *                                        completion carries `changes[]` {path, kind})
  *   {type:"turn.completed", usage}                           → turn_end
  *   {type:"turn.failed", error}                              → error
  *   {type:"error", message}                                  → error

package/dist/mobile-remote/codex-parse.js

@@ -13,8 +13,10 @@
  *       item.type "reasoning"         → []      (thinking noise)
  *       item.type "command_execution" → tool(Bash) on start, tool_result on complete
  *       item.type "mcp_tool_call"     → tool(server__tool) on start, tool_result on complete
+ *                                        (result.content text blocks, or error.message on failure)
  *       item.type "web_search"        → tool(WebSearch) on start
- *       item.type "file_change"       → tool(Edit) on start
+ *       item.type "file_change"       → tool(Edit) + tool_result on complete (only the
+ *                                        completion carries `changes[]` {path, kind})
  *   {type:"turn.completed", usage}                           → turn_end
  *   {type:"turn.failed", error}                              → error
  *   {type:"error", message}                                  → error
@@ -33,6 +35,9 @@ export function parseCodexJsonLine(line) {
     catch {
         return [];
     }
+    // A valid JSON scalar (e.g. `null`) is not an event; ignore it like noise.
+    if (!msg || typeof msg !== "object")
+        return [];
     if (msg.type === "turn.completed")
         return [{ type: "turn_end", reason: "completed" }];
     if (msg.type === "turn.failed") {
@@ -71,7 +76,7 @@ export function parseCodexJsonLine(line) {
                 return [{
                         type: "tool_result",
                         id,
-                        summary: String(item.result ?? item.output ?? "").slice(0, 400),
+                        summary: mcpResultText(item).slice(0, 400),
                         isError: item.status === "failed" || Boolean(item.is_error),
                     }];
             }
@@ -88,16 +93,24 @@ export function parseCodexJsonLine(line) {
             return phase === "started"
                 ? [{ type: "tool", id, tool: "WebSearch", summary: String(item.query ?? ""), input: { query: String(item.query ?? "") } }]
                 : [];
-        case "file_change":
-            return phase === "started"
-                ? [{
-                        type: "tool",
-                        id,
-                        tool: "Edit",
-                        summary: String(item.path ?? ""),
-                        input: item.kind !== undefined ? { path: String(item.path ?? ""), kind: item.kind } : { path: String(item.path ?? "") },
-                    }]
+        case "file_change": {
+            if (phase !== "completed")
+                return [];
+            const changes = Array.isArray(item.changes)
+                ? item.changes
+                    .filter((c) => c && typeof c === "object" && typeof c.path === "string")
+                    .map((c) => ({ path: c.path, kind: c.kind }))
                 : [];
+            return [
+                { type: "tool", id, tool: "Edit", summary: changes.map((c) => c.path).join(", "), input: { changes } },
+                {
+                    type: "tool_result",
+                    id,
+                    summary: changes.map((c) => `${typeof c.kind === "string" ? c.kind : "update"} ${c.path}`).join("\n").slice(0, 400),
+                    isError: item.status === "failed",
+                },
+            ];
+        }
         default:
             return [];
     }
@@ -122,6 +135,27 @@ export function extractThreadId(line) {
     }
     return msg.type === "thread.started" && typeof msg.thread_id === "string" ? msg.thread_id : undefined;
 }
+/** Readable MCP outcome: the failure message, else the result's text content
+ *  blocks, else its structured content (an older plain-string result passes). */
+function mcpResultText(item) {
+    const failure = errText(item.error);
+    if (failure)
+        return failure;
+    const result = item.result ?? item.output;
+    if (result === undefined || result === null)
+        return "";
+    if (typeof result !== "object")
+        return String(result);
+    if (Array.isArray(result.content)) {
+        const text = result.content
+            .map((block) => (block?.type === "text" && typeof block.text === "string" ? block.text : ""))
+            .filter(Boolean)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    return JSON.stringify(result.structured_content ?? result) ?? "";
+}
 function errText(e) {
     if (typeof e === "string")
         return e;

package/dist/mobile-remote/mobile-chat-turn.d.ts

@@ -13,6 +13,7 @@ export interface DispatchMobileChatTurnInput {
     text: string;
     attachments?: MobileImageAttachment[];
     clientMessageId?: string;
+    modelTraceSource?: string;
     permissionMode?: PermissionMode;
     runId: string;
     bridge: MobileRunBridge;

package/dist/mobile-remote/mobile-chat-turn.js

@@ -44,6 +44,9 @@ export async function dispatchMobileChatTurn(input) {
         id: input.runId,
         params: {
             task: text,
+            ...(input.modelTraceSource && /^panel:[a-z][a-z0-9-]{0,63}$/.test(input.modelTraceSource)
+                ? { modelTraceSource: input.modelTraceSource }
+                : {}),
             cwd,
             sessionId: input.sessionId,
             ...(input.projectId ? { projectId: input.projectId } : {}),

package/dist/mobile-remote/mobile-client-event-validator.js

@@ -9,6 +9,7 @@ const MAX_NAME_LENGTH = 512;
 const MAX_PATH_LENGTH = 32_768;
 const MAX_MESSAGE_LENGTH = 512 * 1024;
 const MAX_HISTORY_LIMIT = 500;
+const MAX_ASK_USER_ANSWERS = 32;
 /** Runtime validation at the WebSocket boundary; TypeScript types do not validate JSON. */
 export function parseMobileClientEvent(value) {
     if (!isRecord(value) || typeof value.type !== "string")
@@ -29,6 +30,9 @@ export function parseMobileClientEvent(value) {
             valid =
                 boundedOptionalEmptyString(event.text, MAX_MESSAGE_LENGTH) &&
                     optionalBoundedString(event.sessionId, MAX_ID_LENGTH) &&
+                    (event.modelTraceSource === undefined ||
+                        (typeof event.modelTraceSource === "string" &&
+                            /^panel:[a-z][a-z0-9-]{0,63}$/.test(event.modelTraceSource))) &&
                     optionalBoundedString(event.clientMessageId, MAX_ID_LENGTH) &&
                     optionalAttachments(event.attachments);
             break;
@@ -246,12 +250,21 @@ function isAttachment(value) {
         ? boundedString(value.dataUrl, MAX_MESSAGE_LENGTH)
         : value.transport === "upload" && boundedString(value.uploadId, MAX_ID_LENGTH);
 }
+function isAnswerRecord(value) {
+    if (!isRecord(value))
+        return false;
+    const entries = Object.entries(value);
+    return (entries.length <= MAX_ASK_USER_ANSWERS &&
+        entries.every(([question, answer]) => question.length <= MAX_MESSAGE_LENGTH &&
+            boundedOptionalEmptyString(answer, MAX_MESSAGE_LENGTH)));
+}
 function isApprovalDecision(value) {
     if (!isRecord(value))
         return false;
     if (value.behavior === "allow") {
         return ((value.answer === undefined ||
             boundedOptionalEmptyString(value.answer, MAX_MESSAGE_LENGTH)) &&
+            (value.answers === undefined || isAnswerRecord(value.answers)) &&
             (value.updatedInput === undefined || isRecord(value.updatedInput)));
     }
     return value.behavior === "deny" && boundedOptionalEmptyString(value.message, MAX_MESSAGE_LENGTH);

package/dist/mobile-remote/mobile-history.d.ts

@@ -16,7 +16,16 @@
 export interface TranscriptHistoryItem {
     kind: string;
     text?: unknown;
+    /** Image blocks of a raw model-facing user input (it has no displayText). */
+    images?: unknown;
     event?: unknown;
 }
 export type SessionTranscriptReader = (sessionId: string) => Promise<readonly TranscriptHistoryItem[]>;
-export declare function buildSessionHistory(sessionId: string, getTranscript: SessionTranscriptReader): Promise<unknown[]>;
+/** The client's user-input display projection (Web transcriptUserDisplay), injected. */
+export type UserInputDisplay = (data: {
+    content: unknown;
+}) => {
+    text: string;
+    attachments: readonly unknown[];
+};
+export declare function buildSessionHistory(sessionId: string, getTranscript: SessionTranscriptReader, displayUserInput?: UserInputDisplay): Promise<unknown[]>;

package/dist/mobile-remote/mobile-history.js

@@ -1,23 +1,9 @@
-/**
- * Build a session's history as a flat list of events the phone's streamReducer
- * understands. We REUSE the desktop's transcript reader (transcriptToFoldItems
- * via its getSessionTranscript) so there is one transcript parser, then project
- * its FoldItems into reducer events:
- *   - { kind: "stream", event }  → the raw StreamEvent (reducer eats it directly)
- *   - { kind: "user", text }     → a synthetic { type: "user_message", text }
- *
- * The phone feeds these through the SAME reducer used for the live stream, so
- * replay and live are identical (design §4).
- *
- * The transcript reader itself stays in the desktop package (it depends on
- * renderer FoldItem types), so it is injected here instead of imported.
- */
-export async function buildSessionHistory(sessionId, getTranscript) {
+export async function buildSessionHistory(sessionId, getTranscript, displayUserInput) {
     const items = await getTranscript(sessionId);
     const events = [];
     for (const item of items) {
         if (item.kind === "user") {
-            events.push({ type: "user_message", text: item.text });
+            events.push(userHistoryEvent(item, displayUserInput));
         }
         else if (item.kind === "stream") {
             events.push(item.event);
@@ -25,3 +11,25 @@ export async function buildSessionHistory(sessionId, getTranscript) {
     }
     return events;
 }
+/**
+ * A user input with image blocks but no displayText (e.g. an old paired
+ * chat.send) persisted the engine's model-facing text, including the
+ * attached-image path envelope and tool hint. Project it through the client's
+ * durable-replay display rules instead of showing that as the user's text.
+ */
+function userHistoryEvent(item, displayUserInput) {
+    const images = typeof item.images === "number" && item.images > 0 ? item.images : 0;
+    if (!images || typeof item.text !== "string" || !displayUserInput)
+        return { type: "user_message", text: item.text };
+    const display = displayUserInput({
+        content: [
+            { type: "text", text: item.text },
+            ...Array.from({ length: images }, () => ({ type: "image", source: {} })),
+        ],
+    });
+    return {
+        type: "user_message",
+        text: display.text,
+        ...(display.attachments.length ? { attachments: display.attachments } : {}),
+    };
+}

package/dist/mobile-remote/remote-host-manager.d.ts

@@ -126,6 +126,14 @@ export declare class RemoteHostManager extends EventEmitter {
      *  every authenticated mobile socket. Unauthenticated sockets are skipped so
      *  a half-paired client never sees session output. */
     broadcastRaw(payload: string): void;
+    /**
+     * Queue one frame unless the peer already stopped reading. A paused tab or
+     * stalled network keeps its socket OPEN while ws buffers every live frame in
+     * Host memory; retire that socket instead so the client reconnects and
+     * recovers through its normal resume path. One large frame on a drained
+     * socket is still delivered. Returns false when retired.
+     */
+    private sendBounded;
     private releaseSocket;
     private bindSocketDevice;
     /** Call after revoking/removing a trusted device to release both transports immediately. */

package/dist/mobile-remote/remote-host-manager.js

@@ -8,6 +8,8 @@ import { serveMobile } from "./mobile-static.js";
 import { PairingTokenManager } from "./pairing.js";
 import { parseMobileClientEvent } from "./mobile-client-event-validator.js";
 import { isRelayOrigin } from "../remote-relay/protocol.js";
+/** Outbound bytes one paired socket may leave unread before it is retired. */
+const MAX_SOCKET_BACKLOG_BYTES = 4 * 1024 * 1024;
 /**
  * Pick the Mac's real LAN IPv4 so a phone on the same Wi-Fi can reach the
  * remote host. We bind to a concrete LAN address (NOT 0.0.0.0) per the design's
@@ -442,7 +444,7 @@ export class RemoteHostManager extends EventEmitter {
         const payload = JSON.stringify(event);
         for (const client of this.wss?.clients ?? []) {
             if (client.readyState === client.OPEN && this.authed.get(client) === deviceId) {
-                client.send(payload);
+                this.sendBounded(client, payload);
             }
         }
     }
@@ -464,12 +466,8 @@ export class RemoteHostManager extends EventEmitter {
                 this.viewers.get(client) === viewerId) {
                 // A selected viewer cannot accumulate an unbounded outbound page queue
                 // by issuing new reads while refusing to consume prior replies.
-                if (client.bufferedAmount + Buffer.byteLength(payload) > 4 * 1024 * 1024) {
-                    this.releaseSocket(client);
-                    client.terminate();
+                if (!this.sendBounded(client, payload))
                     return;
-                }
-                client.send(payload);
             }
         }
     }
@@ -477,7 +475,7 @@ export class RemoteHostManager extends EventEmitter {
     sendRawToDevice(deviceId, payload) {
         for (const client of this.wss?.clients ?? []) {
             if (client.readyState === client.OPEN && this.authed.get(client) === deviceId) {
-                client.send(payload);
+                this.sendBounded(client, payload);
             }
         }
     }
@@ -487,10 +485,27 @@ export class RemoteHostManager extends EventEmitter {
     broadcastRaw(payload) {
         for (const client of this.wss?.clients ?? []) {
             if (client.readyState === client.OPEN && this.authed.has(client)) {
-                client.send(payload);
+                this.sendBounded(client, payload);
             }
         }
     }
+    /**
+     * Queue one frame unless the peer already stopped reading. A paused tab or
+     * stalled network keeps its socket OPEN while ws buffers every live frame in
+     * Host memory; retire that socket instead so the client reconnects and
+     * recovers through its normal resume path. One large frame on a drained
+     * socket is still delivered. Returns false when retired.
+     */
+    sendBounded(client, payload) {
+        if (client.bufferedAmount > 0 &&
+            client.bufferedAmount + Buffer.byteLength(payload) > MAX_SOCKET_BACKLOG_BYTES) {
+            this.releaseSocket(client);
+            client.terminate();
+            return false;
+        }
+        client.send(payload);
+        return true;
+    }
     releaseSocket(ws) {
         const deviceId = this.authed.get(ws);
         const viewerId = this.viewers.get(ws);

package/dist/mobile-remote/resident-agent.js

@@ -49,6 +49,9 @@ export function parseStreamJsonLine(line) {
     catch {
         return [];
     }
+    // A valid but non-record line (e.g. `null`) carries no event.
+    if (!msg || typeof msg !== "object" || Array.isArray(msg))
+        return [];
     const out = [];
     if (msg.type === "control_request" && msg.request?.subtype === "can_use_tool") {
         return [
@@ -159,6 +162,15 @@ export class ResidentAgentProcess {
             if (/error/i.test(text))
                 this.opts.onEvent({ type: "error", error: text.trim().slice(0, 400) });
         });
+        let exited = false;
+        const finish = (code, signal) => {
+            if (exited)
+                return;
+            exited = true;
+            if (this.child === child)
+                this.child = undefined;
+            this.opts.onEvent({ type: "exit", code, signal });
+        };
         child.on("error", (err) => {
             const isMissing = err.code === "ENOENT";
             this.opts.onEvent({
@@ -167,11 +179,12 @@ export class ResidentAgentProcess {
                     ? `未找到命令 "${this.opts.command}"。请先安装 Claude Code CLI 并确保它在 PATH 中。`
                     : err.message,
             });
+            // A failed spawn (ENOENT/EACCES/missing cwd) emits `error` without
+            // `exit`. Retire that child so the room can start a replacement.
+            if (child.pid === undefined)
+                finish(null, null);
         });
-        child.on("exit", (code, signal) => {
-            this.child = undefined;
-            this.opts.onEvent({ type: "exit", code, signal });
-        });
+        child.on("exit", (code, signal) => finish(code, signal));
     }
     /** Feed one user turn. Returns false if the process isn't running. */
     send(text) {

package/dist/mobile-remote/room-manager.d.ts

@@ -14,18 +14,19 @@ export type RoomPermissionMode = "default" | "acceptEdits" | "bypassPermissions"
  * `answersByQuestion` maps question text → answer string.
  */
 export declare function buildAskUserUpdatedInput(input: unknown, answersByQuestion: Record<string, string>): Record<string, unknown>;
-/**
- * Parse an AskUserQuestion input into the first question's prompt/header/options
- * so the UI can render a choice card. The room UI answers one question at a time
- * (the first); returns undefined for a non-AskUser / malformed input (no
- * questions), which the caller treats as "fall back to auto-allow".
- */
-export declare function askUserPrompt(input: unknown): {
+type AskUserQuestionPrompt = {
     question: string;
     header?: string;
     options: string[];
     multiSelect: boolean;
-} | undefined;
+};
+/**
+ * Parse an AskUserQuestion input into the first question's prompt/header/options
+ * so the UI can render a choice card. Returns undefined for a non-AskUser /
+ * malformed input (no questions), which the caller treats as "fall back to
+ * auto-allow".
+ */
+export declare function askUserPrompt(input: unknown): AskUserQuestionPrompt | undefined;
 /** Which external CLI backs the room. "claude-code" drives `claude` (long-lived
  *  stdin process with per-tool approval); "codex" drives `codex exec` (one
  *  process per turn, resumed by thread id, no per-tool approval — the sandbox
@@ -109,6 +110,11 @@ export interface RoomAgentFactory {
 export interface RoomManagerOptions {
     rootDir: string;
     createAgent: RoomAgentFactory;
+    /** Explicit Host-owned model history target; never derived from room/client input. */
+    modelTracing?: {
+        storageDir: string;
+        parameters?: (room: Readonly<RoomMeta>) => Record<string, unknown>;
+    };
     /** Locate an already-running external CLI transcript without starting a CLI.
      * Returning null means the transcript is absent. The returned identity is
      * checked again here so a stale or mismatched locator fails closed. */
@@ -125,11 +131,8 @@ export interface RoomManagerOptions {
         displayName?: string;
         input: unknown;
         description?: string;
-        askUser?: {
-            question: string;
-            header?: string;
-            options: string[];
-            multiSelect: boolean;
+        askUser?: AskUserQuestionPrompt & {
+            questions?: AskUserQuestionPrompt[];
         };
     }) => void;
     /** Called after a room's resident process exits or the room is explicitly
@@ -146,6 +149,10 @@ export interface RoomManagerOptions {
 export declare class RoomManager {
     private readonly opts;
     private agents;
+    /** Permission mode each live agent was spawned with. The mode is a spawn-time
+     * CLI argument, so room metadata alone cannot prove what a process runs. */
+    private agentModes;
+    private modelTraces;
     /** Rooms whose visible output is currently sourced from the external CLI's
      * transcript tail. While present, the resident agent's stdout mirror is
      * suppressed so the same CLI output is not pushed twice. */
@@ -280,6 +287,7 @@ export declare class RoomManager {
         behavior: "allow";
         updatedInput?: unknown;
         answer?: string;
+        answers?: Record<string, string>;
     } | {
         behavior: "deny";
         message: string;
@@ -289,6 +297,8 @@ export declare class RoomManager {
     open(id: string): {
         status: RoomOpenStatus;
     };
+    /** Stop a live agent whose spawn-time permission mode differs from `mode`. */
+    private retireAgentUnlessMode;
     private onAgentEvent;
     /** Post a user message: persist it, ensure agent running, feed it. */
     send(id: string, text: string, attachments?: InputAttachmentMeta[]): boolean;