@cjhyy/code-shell-server 0.9.48 → 0.9.50

package/dist/desktop-web/http-api.d.ts

@@ -34,8 +34,17 @@ export interface DesktopWebApiOptions {
     sessionTtlMs?: number;
 }
 export interface DesktopWebHttpApi {
+    /**
+     * Optional independent authorization for GET/HEAD Panel assets. A handler may
+     * serve only an existing short-lived capability after revalidating its owner
+     * and project grant. Return false without writing when no capability matches;
+     * the caller must then apply its ordinary access gate. Never accepts API calls.
+     */
+    handleCapabilityAsset?: (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
     handle: (request: IncomingMessage, response: ServerResponse, context: {
         baseUrl: string;
+        /** Recheck the entrance authorization captured after its access gate succeeded. */
+        isAccessAuthorized?: () => boolean;
     }) => Promise<boolean>;
     /** Reopen after RemoteHostManager.stop(), without reviving previous cookies. */
     start: () => void;

package/dist/desktop-web/http-api.js

@@ -163,6 +163,8 @@ export function createDesktopWebApi(options) {
         if (!identity || closed || identity.generation !== generation)
             return false;
         try {
+            if (identity.isAccessAuthorized?.() === false)
+                return false;
             if (principal(identity.token)?.session !== identity.session)
                 return false;
             const resolved = await options.resolveWorkspace(identity.input, identity.session.deviceId);
@@ -170,6 +172,7 @@ export function createDesktopWebApi(options) {
             return (resolved === identity.cwd &&
                 !closed &&
                 identity.generation === generation &&
+                identity.isAccessAuthorized?.() !== false &&
                 principal(identity.token)?.session === identity.session);
         }
         catch {
@@ -302,6 +305,8 @@ export function createDesktopWebApi(options) {
             try {
                 if (closed)
                     throw new HubConfigurationError(503, "桌面远程服务已停止。");
+                if (context.isAccessAuthorized?.() === false)
+                    throw new HubConfigurationError(401, "访问口令已更新，请重新连接桌面。");
                 const requestGeneration = generation;
                 const origin = sameOrigin(request, context.baseUrl);
                 const secure = origin.protocol === "https:";
@@ -310,6 +315,8 @@ export function createDesktopWebApi(options) {
                     const input = await credentials(request);
                     if (closed || requestGeneration !== generation)
                         throw new HubConfigurationError(503, "桌面远程服务已停止。");
+                    if (context.isAccessAuthorized?.() === false)
+                        throw new HubConfigurationError(401, "访问口令已更新，请重新连接桌面。");
                     const device = options.devices.authenticate(input.deviceId, input.secretHash);
                     if (!device)
                         throw new HubConfigurationError(401, "设备未配对或已被撤销，请在桌面重新配对。");
@@ -360,6 +367,7 @@ export function createDesktopWebApi(options) {
                     const id = await environmentIdentity(options.dataDir);
                     if (closed ||
                         generation !== requestGeneration ||
+                        context.isAccessAuthorized?.() === false ||
                         principal(token)?.session !== current.session)
                         throw new HubConfigurationError(401, "设备连接已失效，请重新连接桌面。");
                     json(response, 200, describeEnvironment(id, "desktop"));
@@ -369,11 +377,19 @@ export function createDesktopWebApi(options) {
                 const cwd = await options.resolveWorkspace(input, current.device.id);
                 if (closed ||
                     generation !== requestGeneration ||
+                    context.isAccessAuthorized?.() === false ||
                     principal(token)?.session !== current.session)
                     throw new HubConfigurationError(401, "设备连接已失效，请重新连接桌面。");
                 if (!cwd || !isAbsolute(cwd))
                     throw new HubConfigurationError(403, "只能访问桌面已知的项目或会话工作区。");
-                identities.set(request, { token, session: current.session, input, cwd, generation });
+                identities.set(request, {
+                    token,
+                    session: current.session,
+                    input,
+                    cwd,
+                    generation,
+                    isAccessAuthorized: context.isAccessAuthorized,
+                });
                 const services = servicesFor(cwd);
                 services.active++;
                 try {

package/dist/http-byte-range.d.ts

@@ -0,0 +1,5 @@
+/** A bounded single HTTP byte range. Multipart ranges are deliberately unsupported. */
+export declare function rangeBounds(range: string, size: number): {
+    start: number;
+    end: number;
+} | null;

package/dist/http-byte-range.js

@@ -0,0 +1,19 @@
+/** A bounded single HTTP byte range. Multipart ranges are deliberately unsupported. */
+export function rangeBounds(range, size) {
+    const match = /^bytes=(\d*)-(\d*)$/.exec(range);
+    if (!match || (!match[1] && !match[2]) || !Number.isSafeInteger(size) || size <= 0)
+        return null;
+    const first = match[1] ? Number(match[1]) : undefined;
+    const last = match[2] ? Number(match[2]) : undefined;
+    if ((first !== undefined && !Number.isSafeInteger(first)) ||
+        (last !== undefined && !Number.isSafeInteger(last)))
+        return null;
+    if (first === undefined) {
+        if (!last || last <= 0)
+            return null;
+        return { start: Math.max(0, size - last), end: size - 1 };
+    }
+    if (first >= size || (last !== undefined && last < first))
+        return null;
+    return { start: first, end: Math.min(last ?? size - 1, size - 1) };
+}

package/dist/hub/files.js

@@ -2,8 +2,10 @@ import { constants } from "node:fs";
 import { lstat, open, opendir, realpath } from "node:fs/promises";
 import { basename, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { rangeBounds } from "../http-byte-range.js";
 import { hubJson } from "./uploads.js";
-const MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
+const MAX_DOWNLOAD_BYTES = 2 * 1024 * 1024 * 1024;
 const MAX_PREVIEW_BYTES = 512 * 1024;
 const IMAGE_TYPES = {
     ".png": "image/png",
@@ -121,7 +123,7 @@ export function createHubFiles(options) {
         try {
             if (closed)
                 throw new FileRequestError(503, "服务正在关闭。");
-            if (req.method !== "GET")
+            if (req.method !== "GET" && !(req.method === "HEAD" && url.pathname.endsWith("/content")))
                 throw new FileRequestError(405, "文件页面只支持读取。");
             if (!(await options.isAuthorized(req)))
                 throw new FileRequestError(401, "请重新登录。");
@@ -184,14 +186,16 @@ export function createHubFiles(options) {
                 if (!(await options.isAuthorized(req)))
                     throw new FileRequestError(401, "请重新登录。");
                 await opened.verify();
+                if (!(await options.isAuthorized(req)))
+                    throw new FileRequestError(401, "请重新登录。");
                 hubJson(res, 200, { path: location.relativePath, files, truncated });
             }
             else {
-                if (info.size > MAX_DOWNLOAD_BYTES)
-                    throw new FileRequestError(413, "文件超过 100 MB，请从服务器工作目录获取。");
                 if (!(await options.isAuthorized(req)))
                     throw new FileRequestError(401, "请重新登录。");
                 await opened.verify();
+                if (!(await options.isAuthorized(req)))
+                    throw new FileRequestError(401, "请重新登录。");
                 const imageType = IMAGE_TYPES[extname(location.path).toLowerCase()];
                 const preview = url.searchParams.get("preview") === "true";
                 if (preview) {
@@ -199,6 +203,9 @@ export function createHubFiles(options) {
                     const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
                     const bytes = buffer.subarray(0, bytesRead);
                     const binary = bytes.includes(0) || !!imageType;
+                    await opened.verify();
+                    if (!(await options.isAuthorized(req)))
+                        throw new FileRequestError(401, "请重新登录。");
                     hubJson(res, 200, {
                         path: location.relativePath,
                         name: basename(location.path),
@@ -211,21 +218,76 @@ export function createHubFiles(options) {
                     });
                 }
                 else {
+                    if (info.size > MAX_DOWNLOAD_BYTES)
+                        throw new FileRequestError(413, "文件超过 2 GiB 下载上限。");
                     const inline = url.searchParams.get("inline") === "true" && !!imageType;
                     const filename = basename(location.path);
                     const encoded = encodeURIComponent(filename).replace(/[!'()*]/g, (value) => `%${value.charCodeAt(0).toString(16).toUpperCase()}`);
-                    res.writeHead(200, {
+                    // Workspace outputs are mutable; without a matching validator an
+                    // If-Range request must receive the complete current representation.
+                    const range = req.headers["if-range"] === undefined ? req.headers.range : undefined;
+                    const bounds = range === undefined ? { start: 0, end: info.size - 1 } : rangeBounds(range, info.size);
+                    const headers = {
                         "content-type": inline ? imageType : "application/octet-stream",
-                        "content-length": info.size,
                         "content-disposition": `${inline ? "inline" : "attachment"}; filename="download${extname(filename).replace(/[^.A-Za-z0-9]/g, "")}"; filename*=UTF-8''${encoded}`,
+                        "accept-ranges": "bytes",
                         "cache-control": "no-store",
                         "x-content-type-options": "nosniff",
                         "content-security-policy": "default-src 'none'; sandbox",
+                        "referrer-policy": "no-referrer",
+                    };
+                    if (!bounds) {
+                        res.writeHead(416, {
+                            ...headers,
+                            "content-range": `bytes */${info.size}`,
+                            "content-length": 0,
+                        });
+                        res.end();
+                        return true;
+                    }
+                    res.writeHead(range === undefined ? 200 : 206, {
+                        ...headers,
+                        "content-length": bounds.end - bounds.start + 1,
+                        ...(range === undefined
+                            ? {}
+                            : { "content-range": `bytes ${bounds.start}-${bounds.end}/${info.size}` }),
                     });
-                    if (info.size === 0)
+                    if (req.method === "HEAD" || info.size === 0)
                         res.end();
-                    else
-                        await pipeline(handle.createReadStream({ autoClose: false, end: Math.max(0, info.size - 1) }), res);
+                    else {
+                        const input = handle.createReadStream({ autoClose: false, ...bounds });
+                        const authorize = async () => {
+                            if (closed || res.destroyed || !(await options.isAuthorized(req)))
+                                throw new FileRequestError(401, "下载授权已失效。");
+                        };
+                        let checking = false;
+                        const timer = setInterval(() => {
+                            if (checking)
+                                return;
+                            checking = true;
+                            void authorize()
+                                .catch(() => {
+                                input.destroy();
+                                res.destroy();
+                            })
+                                .finally(() => {
+                                checking = false;
+                            });
+                        }, 250);
+                        timer.unref();
+                        try {
+                            await pipeline(Readable.from((async function* () {
+                                for await (const chunk of input) {
+                                    await authorize();
+                                    yield chunk;
+                                }
+                            })(), { objectMode: false }), res);
+                        }
+                        finally {
+                            clearInterval(timer);
+                            input.destroy();
+                        }
+                    }
                 }
             }
         }

package/dist/index.panels.d.ts

@@ -26,3 +26,4 @@ export * from "./panels/task-cookie-host.js";
 export * from "./panels/execution-gate.js";
 export * from "./panels/package-mutation.js";
 export * from "./panels/model-traces.js";
+export * from "./panels/background-services.js";

package/dist/index.panels.js

@@ -25,3 +25,4 @@ export * from "./panels/task-cookie-host.js";
 export * from "./panels/execution-gate.js";
 export * from "./panels/package-mutation.js";
 export * from "./panels/model-traces.js";
+export * from "./panels/background-services.js";

package/dist/mobile-remote/access-passcode.d.ts

@@ -49,6 +49,11 @@ export declare class AccessPasscode {
     private lockedUntil;
     constructor(opts: AccessPasscodeOptions);
     isSet(): boolean;
+    /**
+     * After a successful gate, retain its passcode generation for derived grants.
+     * Rechecks never retain/retry the plaintext or spend the verification budget.
+     */
+    captureValidity(): () => boolean;
     /** Set (or rotate) the passcode. Rotating `secret` invalidates old tokens. */
     set(passcode: string): void;
     /**

package/dist/mobile-remote/access-passcode.js

@@ -11,6 +11,10 @@ const SCRYPT_KEYLEN = 32;
 export const MIN_ACCESS_PASSCODE_LENGTH = 4;
 export const MAX_ACCESS_PASSCODE_LENGTH = 256;
 const MAX_REMEMBER_TOKEN_LENGTH = 128;
+/** Marks which gate decision produced a response: "granted", "denied" or
+ *  "unconfigured". The challenge page reports a passcode outcome only from this
+ *  marker, never from a status a tunnel edge or proxy could also produce. */
+const ACCESS_OUTCOME_HEADER = "X-CodeShell-Access";
 const MAX_ACCESS_RECORD_BYTES = 4 * 1024;
 /**
  * The public-tunnel access gate. A single shared passcode (set by the desktop
@@ -49,6 +53,14 @@ export class AccessPasscode {
     isSet() {
         return this.read() !== undefined;
     }
+    /**
+     * After a successful gate, retain its passcode generation for derived grants.
+     * Rechecks never retain/retry the plaintext or spend the verification budget.
+     */
+    captureValidity() {
+        const secret = this.read()?.secret;
+        return () => secret !== undefined && this.read()?.secret === secret;
+    }
     /** Set (or rotate) the passcode. Rotating `secret` invalidates old tokens. */
     set(passcode) {
         if (!isValidPasscode(passcode)) {
@@ -132,13 +144,18 @@ export class AccessPasscode {
     gate(req, res) {
         if (!this.isSet()) {
             // No passcode configured → tunnel must not be reachable. Refuse.
-            res.writeHead(403, { "content-type": "text/plain; charset=utf-8" });
+            res.writeHead(403, {
+                "content-type": "text/plain; charset=utf-8",
+                [ACCESS_OUTCOME_HEADER]: "unconfigured",
+            });
             res.end("access passcode not configured");
             return false;
         }
         const cookieToken = readCookie(req.headers.cookie, COOKIE_NAME);
-        if (cookieToken && this.verifyToken(cookieToken))
+        if (cookieToken && this.verifyToken(cookieToken)) {
+            res.setHeader(ACCESS_OUTCOME_HEADER, "granted");
             return true;
+        }
         const supplied = readPasscodeParam(req);
         let wrongAttempt = false;
         if (supplied) {
@@ -151,6 +168,7 @@ export class AccessPasscode {
                 // user every visit. Lax sends it on top-level navigations. Secure
                 // because the tunnel terminates TLS (always https).
                 `${COOKIE_NAME}=${token}; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=${Math.floor(this.tokenMaxAgeMs / 1000)}`);
+                res.setHeader(ACCESS_OUTCOME_HEADER, "granted");
                 const cleanLocation = acceptsHtml(req) ? locationWithoutPasscode(req.url) : undefined;
                 if (cleanLocation) {
                     // The HTML challenge has a no-query JavaScript path below, but keep a
@@ -176,11 +194,17 @@ export class AccessPasscode {
         // to enter the passcode). Non-navigation requests (WS upgrade, fetch) keep
         // the lightweight text 401.
         if (acceptsHtml(req)) {
-            res.writeHead(401, { "content-type": "text/html; charset=utf-8" });
+            res.writeHead(401, {
+                "content-type": "text/html; charset=utf-8",
+                [ACCESS_OUTCOME_HEADER]: "denied",
+            });
             res.end(challengePage(req.url, wrongAttempt, this.isLocked()));
             return false;
         }
-        res.writeHead(401, { "content-type": "text/plain; charset=utf-8" });
+        res.writeHead(401, {
+            "content-type": "text/plain; charset=utf-8",
+            [ACCESS_OUTCOME_HEADER]: "denied",
+        });
         res.end("访问口令无效或缺失");
         return false;
     }
@@ -457,17 +481,32 @@ function challengePage(url, wrong, locked) {
     const value = input?.value ?? "";
     if (!value) return;
     try {
+      // Request the page as the following navigation will (HTML), so SPA
+      // routes resolve the same way. A passcode outcome is reported only from
+      // the gate's own marker: a tunnel edge or proxy can answer 4xx/5xx
+      // without the request ever reaching the gate.
       const response = await fetch(window.location.href, {
-        headers: { "X-Access-Passcode": value, Accept: "application/json" },
+        headers: { "X-Access-Passcode": value, Accept: "text/html" },
         credentials: "same-origin",
       });
-      if (!response.ok) {
+      if (response.ok) {
+        window.location.replace(${cleanLocation});
+        return;
+      }
+      const access = response.headers.get("${ACCESS_OUTCOME_HEADER}");
+      const status = "（HTTP " + response.status + "）";
+      if (access === "denied") {
         if (note) note.textContent = "口令不正确或尝试过多，请稍后重试。";
-        if (note) note.className = "err";
         if (input) input.value = "";
-        return;
+      } else if (note) {
+        note.textContent =
+          access === "granted"
+            ? "访问验证已通过，但页面加载失败" + status + "，请稍后重试或检查桌面端。"
+            : access === "unconfigured"
+              ? "远程访问未就绪" + status + "，请在桌面端检查手机遥控设置。"
+              : "请求未完成" + status + "，口令尚未得到验证，请稍后重试。";
       }
-      window.location.replace(${cleanLocation});
+      if (note) note.className = "err";
     } catch {
       if (note) note.textContent = "连接失败，请重试。";
       if (note) note.className = "err";

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

@@ -28,7 +28,11 @@ export function parseMobileClientEvent(value) {
             break;
         case "chat.send":
             valid =
-                boundedOptionalEmptyString(event.text, MAX_MESSAGE_LENGTH) &&
+                optionalMember(event.permissionMode, PERMISSION_MODES) &&
+                    boundedOptionalEmptyString(event.text, MAX_MESSAGE_LENGTH) &&
+                    (event.modelKey === undefined ||
+                        (boundedString(event.modelKey, MAX_ID_LENGTH) &&
+                            /^(codex|claude-code)\/[^\r\n\0]*$/.test(event.modelKey))) &&
                     optionalBoundedString(event.sessionId, MAX_ID_LENGTH) &&
                     (event.modelTraceSource === undefined ||
                         (typeof event.modelTraceSource === "string" &&
@@ -52,6 +56,17 @@ export function parseMobileClientEvent(value) {
         case "session.recovery.cancel":
             valid = true;
             break;
+        case "session.outputRecovery.plan":
+        case "session.outputRecovery.apply":
+            valid =
+                boundedString(event.sessionId, 128) &&
+                    boundedString(event.requestId, 128) &&
+                    (event.type === "session.outputRecovery.plan" ||
+                        (boundedString(event.planId, 128) && event.acceptHistoricalGap === true)) &&
+                    Object.keys(event).every((key) => (event.type === "session.outputRecovery.plan"
+                        ? ["type", "sessionId", "requestId"]
+                        : ["type", "sessionId", "requestId", "planId", "acceptHistoricalGap"]).includes(key));
+            break;
         case "session.legacyBase":
             valid =
                 boundedString(event.sessionId, 128) &&
@@ -60,20 +75,37 @@ export function parseMobileClientEvent(value) {
                     ((boundedString(event.throughEventId, 512) && event.cursor === undefined) ||
                         (boundedString(event.cursor, 2048) && event.throughEventId === undefined));
             break;
+        case "session.historyView":
+        case "session.historyDetail":
+            valid =
+                boundedString(event.sessionId, 128) &&
+                    boundedString(event.recoveryId, 128) &&
+                    boundedString(event.requestId, 128) &&
+                    (event.type === "session.historyView"
+                        ? optionalBoundedString(event.before, 2048) &&
+                            Object.keys(event).every((key) => ["type", "sessionId", "recoveryId", "requestId", "before"].includes(key))
+                        : boundedString(event.ref, 2048) &&
+                            optionalBoundedString(event.cursor, 2048) &&
+                            Object.keys(event).every((key) => ["type", "sessionId", "recoveryId", "requestId", "ref", "cursor"].includes(key)));
+            break;
         case "session.outputJournal":
             valid =
                 boundedString(event.sessionId, 128) &&
                     boundedString(event.recoveryId, 128) &&
                     boundedString(event.requestId, 128) &&
                     optionalBoundedString(event.after, 2048) &&
-                    optionalBoundedString(event.through, 2048);
+                    optionalBoundedString(event.through, 2048) &&
+                    (event.frozenSnapshot === undefined || event.frozenSnapshot === true) &&
+                    (event.maxFrames === undefined ||
+                        (isPositiveInteger(event.maxFrames) && event.maxFrames <= 2048));
             break;
         case "session.history":
             valid = boundedString(event.sessionId, MAX_ID_LENGTH);
             break;
         case "session.create":
             valid =
-                optionalBoundedString(event.clientRequestId, MAX_ID_LENGTH) &&
+                optionalMember(event.permissionMode, PERMISSION_MODES) &&
+                    optionalBoundedString(event.clientRequestId, MAX_ID_LENGTH) &&
                     (event.cwd === undefined || event.cwd === null || boundedPath(event.cwd)) &&
                     (event.projectId === undefined ||
                         event.projectId === null ||
@@ -91,12 +123,24 @@ export function parseMobileClientEvent(value) {
                 boundedString(event.approvalId, MAX_ID_LENGTH) &&
                     (event.decision === "approve" || event.decision === "reject") &&
                     optionalBoundedString(event.sessionId, MAX_ID_LENGTH) &&
+                    optionalBoundedString(event.connectionId, MAX_ID_LENGTH) &&
+                    (event.generation === undefined ||
+                        (Number.isSafeInteger(event.generation) && event.generation >= 0)) &&
                     optionalBoundedString(event.reason, MAX_MESSAGE_LENGTH) &&
                     optionalBoundedString(event.answer, MAX_MESSAGE_LENGTH) &&
                     optionalMember(event.scope, SCOPES) &&
                     optionalMember(event.pathScope, PATH_SCOPES);
             break;
         case "session.list":
+            valid =
+                optionalBoundedString(event.requestId, 128) &&
+                    optionalBoundedString(event.cursor, 2048) &&
+                    (event.cwds === undefined ||
+                        (Array.isArray(event.cwds) &&
+                            event.cwds.length > 0 &&
+                            event.cwds.length <= 256 &&
+                            event.cwds.every(boundedPath)));
+            break;
         case "room.list":
         case "room.projects":
             valid = true;
@@ -115,6 +159,9 @@ export function parseMobileClientEvent(value) {
         case "model.set":
             valid = boundedString(event.model, MAX_ID_LENGTH);
             break;
+        case "runtime.models":
+            valid = true;
+            break;
         case "goal.extend":
             valid =
                 boundedString(event.sessionId, MAX_ID_LENGTH) &&
@@ -164,7 +211,10 @@ export function parseMobileClientEvent(value) {
                     optionalMember(event.kind, KINDS);
             break;
         case "ccRoom.listSessions":
-            valid = boundedPath(event.cwd) && optionalMember(event.kind, KINDS);
+            valid =
+                boundedPath(event.cwd) &&
+                    optionalMember(event.kind, KINDS) &&
+                    (event.all === undefined || typeof event.all === "boolean");
             break;
         case "ccRoom.openSession":
             valid =

package/dist/mobile-remote/pending-approvals.d.ts

@@ -5,15 +5,27 @@
  * are stateful: keep the latest unresolved raw JSON-RPC request here and replay
  * it to a phone when that phone binds to the matching session.
  */
+export interface PendingMobileApprovalRoute {
+    sessionId: string;
+    requestId: string;
+    connectionId?: string;
+    generation?: number;
+    expiresAt?: number;
+}
 export declare class PendingMobileApprovals {
+    private readonly now;
     private readonly bySession;
     private workerGeneration;
+    constructor(now?: () => number);
     /** Requests belong to the worker that can answer them, never its successor. */
     setWorkerState(generation: number, alive: boolean): void;
     observeOutboundLine(line: string): void;
-    resolve(requestId: string): void;
+    resolve(requestId: string, route?: Partial<PendingMobileApprovalRoute>): void;
     replayLines(sessionId: string): string[];
+    /** The stored worker envelope, rather than a phone's mutable current session, owns routing. */
+    find(sessionId: string, requestId: string): PendingMobileApprovalRoute | undefined;
     /** The desktop has a queue across sessions; return only its current pending requests. */
     replayAllLines(): string[];
     forgetSession(sessionId: string): void;
+    private pruneExpired;
 }

package/dist/mobile-remote/pending-approvals.js

@@ -1,13 +1,10 @@
-/**
- * Tracks currently pending core approval requests for mobile clients.
- *
- * Session snapshots intentionally contain only stream events. Approval requests
- * are stateful: keep the latest unresolved raw JSON-RPC request here and replay
- * it to a phone when that phone binds to the matching session.
- */
 export class PendingMobileApprovals {
+    now;
     bySession = new Map();
     workerGeneration;
+    constructor(now = Date.now) {
+        this.now = now;
+    }
     /** Requests belong to the worker that can answer them, never its successor. */
     setWorkerState(generation, alive) {
         if (!alive || this.workerGeneration !== generation)
@@ -32,6 +29,8 @@ export class PendingMobileApprovals {
                 return;
             if (typeof requestId !== "string" || !requestId)
                 return;
+            if (typeof params?.expiresAt === "number" && params.expiresAt <= this.now())
+                return;
             let pending = this.bySession.get(sessionId);
             if (!pending) {
                 pending = new Map();
@@ -44,24 +43,61 @@ export class PendingMobileApprovals {
             const params = msg.params;
             const requestId = params?.requestId;
             if (typeof requestId === "string" && requestId)
-                this.resolve(requestId);
+                this.resolve(requestId, params ?? {});
         }
     }
-    resolve(requestId) {
+    resolve(requestId, route = {}) {
         for (const [sessionId, pending] of this.bySession) {
+            if (route.sessionId !== undefined && route.sessionId !== sessionId)
+                continue;
+            const line = pending.get(requestId);
+            if (!line)
+                continue;
+            const params = JSON.parse(line).params;
+            if ((params.connectionId !== undefined || params.generation !== undefined) &&
+                (route.sessionId !== sessionId ||
+                    route.connectionId !== params.connectionId ||
+                    route.generation !== params.generation))
+                continue;
+            if ((route.connectionId !== undefined && route.connectionId !== params.connectionId) ||
+                (route.generation !== undefined && route.generation !== params.generation))
+                continue;
             pending.delete(requestId);
             if (pending.size === 0)
                 this.bySession.delete(sessionId);
         }
     }
     replayLines(sessionId) {
+        this.pruneExpired();
         return [...(this.bySession.get(sessionId)?.values() ?? [])];
     }
+    /** The stored worker envelope, rather than a phone's mutable current session, owns routing. */
+    find(sessionId, requestId) {
+        this.pruneExpired();
+        const line = this.bySession.get(sessionId)?.get(requestId);
+        if (!line)
+            return undefined;
+        const { connectionId, generation, expiresAt } = JSON.parse(line).params;
+        return { sessionId, requestId, connectionId, generation, expiresAt };
+    }
     /** The desktop has a queue across sessions; return only its current pending requests. */
     replayAllLines() {
+        this.pruneExpired();
         return [...this.bySession.values()].flatMap((pending) => [...pending.values()]);
     }
     forgetSession(sessionId) {
         this.bySession.delete(sessionId);
     }
+    pruneExpired() {
+        const now = this.now();
+        for (const [sessionId, pending] of this.bySession) {
+            for (const [requestId, line] of pending) {
+                const expiresAt = JSON.parse(line).params.expiresAt;
+                if (typeof expiresAt === "number" && expiresAt <= now)
+                    pending.delete(requestId);
+            }
+            if (!pending.size)
+                this.bySession.delete(sessionId);
+        }
+    }
 }