@cjhyy/code-shell-server 0.9.51 → 0.10.1

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

@@ -0,0 +1,422 @@
+import { randomUUID } from "node:crypto";
+/**
+ * Host-owned FIFO of turns submitted while their conversation is busy.
+ *
+ * The queue never runs anything itself: an entry is handed to the caller's
+ * ORIGINAL submit path (same validation, approvals and workspace checks) only
+ * when the exact target is idle, so it cannot bypass or duplicate an existing
+ * Core/CLI queue. Entries are bound to the conversation they were submitted
+ * for, never to a viewer's later selection.
+ */
+export const MAX_TURN_QUEUE_ENTRIES_PER_TARGET = 20;
+export const MAX_TURN_QUEUE_ENTRIES_PER_DEVICE = 50;
+export const MAX_TURN_QUEUE_ENTRIES = 200;
+/** Remembered admission outcomes so a replayed submission is never run twice. */
+const MAX_SETTLED_OUTCOMES = 512;
+const INTENT_CONFLICT = "这个消息标识已用于另一条内容，未重复提交。请作为新消息发送。";
+export function turnQueueTargetKey(target) {
+    return target.kind === "session" ? `session:${target.sessionId}` : `room:${target.roomId}`;
+}
+/** An unknown fingerprint on either side cannot prove a mismatch. */
+function sameFingerprint(left, right) {
+    return left === undefined || right === undefined || left === right;
+}
+export function sameTurnQueueTarget(left, right) {
+    return !!left && !!right && turnQueueTargetKey(left) === turnQueueTargetKey(right);
+}
+export class MobileTurnQueue {
+    deps;
+    epoch = randomUUID();
+    queues = new Map();
+    settled = new Map();
+    pumping = new Set();
+    stopGenerations = new Map();
+    now;
+    timer;
+    disposed = false;
+    /** Monotonic across targets so a recreated queue never reuses a revision. */
+    revision = 0;
+    constructor(deps) {
+        this.deps = deps;
+        this.now = deps.now ?? (() => Date.now());
+    }
+    /**
+     * The live or settled outcome of one device's intent on one target. Callers
+     * check this BEFORE retaining resources: a replay of an admitted turn must be
+     * answered from its receipt, not re-validated against consumed uploads.
+     */
+    lookup(target, deviceId, clientMessageId, fingerprint) {
+        const key = turnQueueTargetKey(target);
+        const queue = this.queues.get(key);
+        const position = queue?.entries.findIndex((entry) => entry.deviceId === deviceId && entry.clientMessageId === clientMessageId) ?? -1;
+        if (queue && position >= 0) {
+            const entry = queue.entries[position];
+            if (!sameFingerprint(entry.fingerprint, fingerprint))
+                return { kind: "conflict", message: INTENT_CONFLICT };
+            return { kind: "duplicate", entry, position };
+        }
+        const settled = this.settled.get(this.identity(deviceId, key, clientMessageId));
+        if (!settled)
+            return undefined;
+        if (!sameFingerprint(settled.fingerprint, fingerprint))
+            return { kind: "conflict", message: INTENT_CONFLICT };
+        return { kind: "settled", outcome: settled.outcome };
+    }
+    /** Admit one submission, or return its existing/settled outcome for a replay. */
+    enqueue(submission) {
+        if (this.disposed)
+            return { kind: "rejected", message: "排队服务已停止。" };
+        const key = turnQueueTargetKey(submission.target);
+        const queue = this.queues.get(key);
+        const found = this.lookup(submission.target, submission.deviceId, submission.clientMessageId, submission.fingerprint);
+        if (found?.kind === "conflict")
+            return { kind: "rejected", message: found.message };
+        if (found)
+            return found;
+        if (!submission.text.trim() && submission.attachments.length === 0)
+            return { kind: "rejected", message: "消息必须包含文字或图片。" };
+        if ((queue?.entries.length ?? 0) >= MAX_TURN_QUEUE_ENTRIES_PER_TARGET)
+            return {
+                kind: "rejected",
+                message: `每个会话最多排队 ${MAX_TURN_QUEUE_ENTRIES_PER_TARGET} 条消息。`,
+            };
+        let total = 0;
+        let device = 0;
+        for (const item of this.queues.values()) {
+            total += item.entries.length;
+            device += item.entries.filter((entry) => entry.deviceId === submission.deviceId).length;
+        }
+        if (total >= MAX_TURN_QUEUE_ENTRIES || device >= MAX_TURN_QUEUE_ENTRIES_PER_DEVICE)
+            return { kind: "rejected", message: "待执行消息过多，请等待或取消部分排队消息。" };
+        const entry = {
+            ...submission,
+            attachments: submission.attachments.map((item) => ({ ...item })),
+            uploadIds: [...submission.uploadIds],
+            id: randomUUID(),
+            createdAt: this.now(),
+            status: "queued",
+        };
+        const target = queue ?? { target: submission.target, entries: [], revision: 0 };
+        target.entries.push(entry);
+        this.queues.set(key, target);
+        this.changed(target);
+        this.ensureTimer();
+        return { kind: "queued", entry, position: target.entries.length - 1 };
+    }
+    /** Remove one entry that has not been handed to its submit path. */
+    cancel(target, entryId) {
+        const queue = this.queues.get(turnQueueTargetKey(target));
+        const index = queue?.entries.findIndex((entry) => entry.id === entryId) ?? -1;
+        if (!queue || index < 0)
+            return { ok: false, message: "这条排队消息已执行或已移除。" };
+        const entry = queue.entries[index];
+        if (entry.status === "dispatching")
+            return { ok: false, message: "这条消息正在提交，无法再取消。可在执行后停止。" };
+        queue.entries.splice(index, 1);
+        this.retire(entry, "cancelled");
+        // The pause belonged to a failed/uncertain entry; once none is left the
+        // rest may run. A Stop pause stays until an explicit resume.
+        this.releaseFailurePause(queue);
+        this.changed(queue);
+        void this.pump(target);
+        return { ok: true };
+    }
+    /** Remove every entry that is not already being submitted. */
+    clear(target) {
+        const queue = this.queues.get(turnQueueTargetKey(target));
+        if (!queue)
+            return 0;
+        const removed = queue.entries.filter((entry) => entry.status !== "dispatching");
+        if (!removed.length)
+            return 0;
+        queue.entries = queue.entries.filter((entry) => entry.status === "dispatching");
+        for (const entry of removed)
+            this.retire(entry, "cancelled");
+        queue.paused = undefined;
+        this.changed(queue);
+        return removed.length;
+    }
+    /**
+     * Stop scheduling after the current turn; nothing is discarded. An explicit
+     * Stop outranks a failure/uncertain pause: removing or retrying the entry
+     * that caused that pause must not restart the rest. Every Stop advances the
+     * target's stop generation, which fences an in-flight dispatch off before it
+     * physically submits (see stopGeneration).
+     */
+    pause(target, reason) {
+        const key = turnQueueTargetKey(target);
+        this.stopGenerations.set(key, this.stopGeneration(target) + 1);
+        const queue = this.queues.get(key);
+        if (!queue?.entries.length || queue.paused === reason)
+            return;
+        queue.paused = reason;
+        this.changed(queue);
+    }
+    /** Monotonic count of Stops of this target during this Host lifetime. */
+    stopGeneration(target) {
+        return this.stopGenerations.get(turnQueueTargetKey(target)) ?? 0;
+    }
+    /**
+     * Continue after Stop or a rejected entry. An entry whose execution cannot
+     * be ruled out must be removed first; it is never resubmitted from here.
+     */
+    resume(target) {
+        const queue = this.queues.get(turnQueueTargetKey(target));
+        if (!queue)
+            return { ok: true };
+        if (queue.entries.some((entry) => entry.status === "uncertain"))
+            return {
+                ok: false,
+                message: "有消息无法确认是否已执行。请先核对会话记录，再移除那条消息。",
+            };
+        for (const entry of queue.entries)
+            if (entry.status === "failed") {
+                entry.status = "queued";
+                entry.message = undefined;
+            }
+        queue.paused = undefined;
+        this.changed(queue);
+        void this.pump(target);
+        return { ok: true };
+    }
+    /** Retry a rejected entry with the same clientMessageId. */
+    retry(target, entryId) {
+        const queue = this.queues.get(turnQueueTargetKey(target));
+        const entry = queue?.entries.find((item) => item.id === entryId);
+        if (!queue || !entry)
+            return { ok: false, message: "这条排队消息已执行或已移除。" };
+        if (entry.status !== "failed")
+            return {
+                ok: false,
+                message: entry.status === "uncertain"
+                    ? "无法确认这条消息是否已执行，不能自动重试。请核对会话记录。"
+                    : "这条消息仍在等待，无需重试。",
+            };
+        entry.status = "queued";
+        entry.message = undefined;
+        this.releaseFailurePause(queue);
+        this.changed(queue);
+        void this.pump(target);
+        return { ok: true };
+    }
+    releaseFailurePause(queue) {
+        if ((queue.paused === "failed" || queue.paused === "uncertain") &&
+            !queue.entries.some((entry) => entry.status === "failed" || entry.status === "uncertain"))
+            queue.paused = undefined;
+    }
+    /** Publish an entry whose submitter was told it is queued rather than running. */
+    reveal(target, entryId) {
+        const queue = this.queues.get(turnQueueTargetKey(target));
+        const entry = queue?.entries.find((item) => item.id === entryId);
+        if (!queue || !entry?.transient)
+            return;
+        entry.transient = undefined;
+        this.changed(queue);
+    }
+    has(target) {
+        return (this.queues.get(turnQueueTargetKey(target))?.entries.length ?? 0) > 0;
+    }
+    entries(target) {
+        return this.queues.get(turnQueueTargetKey(target))?.entries ?? [];
+    }
+    targets() {
+        return [...this.queues.values()].map((queue) => queue.target);
+    }
+    /** Public state as seen by one recipient device. */
+    snapshot(target, recipientDeviceId) {
+        const queue = this.queues.get(turnQueueTargetKey(target));
+        return {
+            target,
+            epoch: this.epoch,
+            revision: queue?.revision ?? this.revision,
+            ...(queue?.paused ? { paused: queue.paused } : {}),
+            entries: (queue?.entries ?? [])
+                .filter((entry) => !entry.transient)
+                .map((entry) => ({
+                id: entry.id,
+                clientMessageId: entry.clientMessageId,
+                text: entry.text,
+                attachments: entry.attachments.map((item) => ({ ...item })),
+                status: entry.status,
+                ...(entry.message ? { message: entry.message } : {}),
+                createdAt: entry.createdAt,
+                ownDevice: recipientDeviceId !== undefined && entry.deviceId === recipientDeviceId,
+                ...(entry.permissionMode ? { permissionMode: entry.permissionMode } : {}),
+                ...(entry.modelKey ? { modelKey: entry.modelKey } : {}),
+                ...(entry.nativeConnectionId ? { nativeConnectionId: entry.nativeConnectionId } : {}),
+            })),
+        };
+    }
+    /** Re-evaluate every queue; used by the idle timer and Host lifecycle signals. */
+    pumpAll() {
+        return Promise.all(this.targets().map((target) => this.pump(target))).then(() => undefined);
+    }
+    /**
+     * Hand the next runnable entry to its submit path when the exact target is
+     * idle. At most one entry per target is in flight. Entries of one device
+     * keep their order; a device that cannot run now (e.g. its tab is away)
+     * does not hold back other devices' turns. A rejected or uncertain entry
+     * pauses the whole target so nothing runs past an unresolved outcome.
+     */
+    async pump(target) {
+        const key = turnQueueTargetKey(target);
+        const queue = this.queues.get(key);
+        if (this.disposed || !queue || queue.paused || this.pumping.has(key))
+            return;
+        const settleMs = this.deps.settleMs ?? 750;
+        // Give the accepted turn time to register as busy before the next one.
+        if (queue.lastDispatchAt !== undefined && this.now() - queue.lastDispatchAt < settleMs)
+            return;
+        let busy;
+        try {
+            busy = this.deps.isBusy(queue.target);
+        }
+        catch {
+            busy = true;
+        }
+        if (busy)
+            return;
+        const blocked = new Set();
+        let head;
+        let gate;
+        let waitingChanged = false;
+        for (const entry of queue.entries) {
+            if (entry.status !== "queued" && entry.status !== "waiting")
+                return;
+            if (blocked.has(entry.deviceId))
+                continue;
+            let entryGate;
+            try {
+                entryGate = this.deps.canDispatch(entry);
+            }
+            catch (error) {
+                entryGate = { ok: false, message: error instanceof Error ? error.message : String(error) };
+            }
+            if (entryGate.ok) {
+                head = entry;
+                gate = entryGate;
+                break;
+            }
+            blocked.add(entry.deviceId);
+            if (entry.status !== "waiting" || entry.message !== entryGate.message) {
+                entry.status = "waiting";
+                entry.message = entryGate.message;
+                waitingChanged = true;
+            }
+        }
+        if (waitingChanged)
+            this.changed(queue);
+        if (!head || !gate?.ok || this.queues.get(key) !== queue)
+            return;
+        if (gate.viewerId)
+            head.viewerId = gate.viewerId;
+        head.status = "dispatching";
+        head.message = undefined;
+        this.pumping.add(key);
+        this.changed(queue);
+        let result;
+        try {
+            result = await this.deps.dispatch(head);
+        }
+        catch (error) {
+            result = { ok: false, message: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            this.pumping.delete(key);
+        }
+        const index = queue.entries.indexOf(head);
+        if (index < 0)
+            return;
+        if (result.ok) {
+            queue.entries.splice(index, 1);
+            queue.lastDispatchAt = this.now();
+            this.remember(head, "dispatched");
+        }
+        else if (result.requeue) {
+            // Fenced off by a Stop before submission: unchanged, waiting for resume.
+            head.transient = undefined;
+            head.status = "queued";
+            head.message = undefined;
+        }
+        else if (head.transient && !result.uncertain) {
+            // Its submitter received the original definite rejection and still owns
+            // the draft; nothing ran.
+            queue.entries.splice(index, 1);
+        }
+        else {
+            // A possibly admitted turn stays visible (even a direct one) so its
+            // intent id keeps deduplicating replays; it is never resubmitted.
+            head.transient = undefined;
+            head.status = result.uncertain ? "uncertain" : "failed";
+            head.message = result.message;
+            if (queue.paused !== "stopped")
+                queue.paused = result.uncertain ? "uncertain" : "failed";
+        }
+        if (this.queues.get(key) === queue)
+            this.changed(queue);
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        for (const queue of this.queues.values())
+            for (const entry of queue.entries)
+                this.deps.discard?.(entry);
+        this.queues.clear();
+    }
+    identity(deviceId, key, clientMessageId) {
+        return JSON.stringify([deviceId, key, clientMessageId]);
+    }
+    retire(entry, outcome) {
+        this.remember(entry, outcome);
+        try {
+            this.deps.discard?.(entry);
+        }
+        catch {
+            // Upload expiry still reclaims an entry whose release failed.
+        }
+    }
+    remember(entry, outcome) {
+        const identity = this.identity(entry.deviceId, turnQueueTargetKey(entry.target), entry.clientMessageId);
+        this.settled.delete(identity);
+        this.settled.set(identity, {
+            outcome,
+            ...(entry.fingerprint !== undefined ? { fingerprint: entry.fingerprint } : {}),
+        });
+        while (this.settled.size > MAX_SETTLED_OUTCOMES) {
+            const oldest = this.settled.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.settled.delete(oldest);
+        }
+    }
+    changed(queue) {
+        queue.revision = ++this.revision;
+        const key = turnQueueTargetKey(queue.target);
+        if (!queue.entries.length) {
+            // Keep the revision monotonic for clients while an empty state is published.
+            this.queues.delete(key);
+        }
+        try {
+            this.deps.publish(queue.target);
+        }
+        finally {
+            if (!queue.entries.length)
+                this.stopTimerIfIdle();
+        }
+    }
+    ensureTimer() {
+        const interval = this.deps.intervalMs ?? 1_000;
+        if (this.timer || interval <= 0)
+            return;
+        this.timer = setInterval(() => void this.pumpAll(), interval);
+        this.timer.unref?.();
+    }
+    stopTimerIfIdle() {
+        if (this.queues.size || !this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+    }
+}

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

@@ -1 +1 @@
-export type { TrustedDevice, TrustedDevicePublic, PairingToken, ApprovalScope, ApprovalPathScope, MobileRemotePermissionMode as PermissionMode, CcDiscoveredSession, CcHistoryMessage, CcApprovalDecision, MobilePermissionModeSnapshotEntry, MobileProjectMeta, MobileImageMime, MobileImageBase, MobileImageAttachment, MobileAttachmentSummary, MobileClientEvent, MobileServerEvent, RoomPublic, MobileSessionMeta, } from "@cjhyy/code-shell-core";
+export type { TrustedDevice, TrustedDevicePublic, PairingToken, ApprovalScope, ApprovalPathScope, MobileRemotePermissionMode as PermissionMode, CcDiscoveredSession, CcHistoryMessage, CcApprovalDecision, MobilePermissionModeSnapshotEntry, MobileProjectMeta, MobileImageMime, MobileImageBase, MobileImageAttachment, MobileAttachmentSummary, MobileClientEvent, MobileServerEvent, MobileTurnQueueEntry, MobileTurnQueueEntryStatus, MobileTurnQueueState, MobileTurnQueueTarget, RoomPublic, MobileSessionMeta, } from "@cjhyy/code-shell-core";

package/dist/panels/agent-task-host.js

@@ -5,6 +5,7 @@ import { isAbsolute } from "node:path";
 import { SettingsManager } from "@cjhyy/code-shell-core";
 import { getMergedCatalog } from "@cjhyy/code-shell-core/internal";
 import { WorkerBridgeCore } from "../worker-bridge-core.js";
+import { headlessWorkerEnv } from "../headless-worker-env.js";
 import { PanelAppAgentTaskService, } from "./agent-task-service.js";
 import { buildPanelAgentTaskModelCatalog, } from "./agent-task-models.js";
 // Keep the request's hard tool ceiling. Scheduling, delegation, arbitrary MCP,
@@ -269,18 +270,11 @@ export function createPanelAgentTaskHost(options = {}) {
                     entryPath,
                     execPath: options.execPath,
                     fallbackCwd: () => scope.cwd,
-                    buildEnv: () => ({
-                        ...(options.buildEnv?.() ?? {
-                            ...process.env,
-                            CODE_SHELL_CAPABILITY_MODULES: `${import.meta.resolve("@cjhyy/code-shell-capability-coding")}#createCodingModule`,
-                        }),
-                        // A task worker has no Desktop main bridge, even inside Desktop Web.
-                        CODE_SHELL_REMOTE_LINK_CLIENT_SECRET: undefined,
-                        CODE_SHELL_OPERATION_BATCH_ACCESS: undefined,
-                        CODE_SHELL_MODEL_REQUEST_SIGNING: undefined,
-                        CODE_SHELL_WORKSPACE_ACCESS: undefined,
-                        CODE_SHELL_HOST_MCP_SERVERS: undefined,
-                        CODE_SHELL_CREDENTIAL_ACCESS: "local",
+                    buildEnv: () => 
+                    // A task worker has no Desktop main bridge, even inside Desktop Web.
+                    headlessWorkerEnv(options.buildEnv?.() ?? {
+                        ...process.env,
+                        CODE_SHELL_CAPABILITY_MODULES: `${import.meta.resolve("@cjhyy/code-shell-capability-coding")}#createCodingModule`,
                     }),
                     onWorkerStarted: ({ pid }) => {
                         running.pid = pid;

package/dist/panels/agent-task-service.d.ts

@@ -94,6 +94,8 @@ export declare class PanelAppAgentTaskService {
     start(owner: PanelAgentTaskOwner, raw: PanelAgentTaskStartInput): PanelAgentTaskView;
     list(owner: PanelAgentTaskOwner): PanelAgentTaskView[];
     get(owner: PanelAgentTaskOwner, id: unknown): PanelAgentTaskView;
+    /** Native Host authority for a currently executing task, never a guest-facing lookup. */
+    activeOwner(sessionId: string): PanelAgentTaskOwner | undefined;
     cancel(owner: PanelAgentTaskOwner, id: unknown): Promise<PanelAgentTaskView>;
     rebind(owner: PanelAgentTaskOwner): void;
     /** `projects` limits cancellation to tasks bound to those (canonical) projects. */

package/dist/panels/agent-task-service.js

@@ -152,6 +152,13 @@ export class PanelAppAgentTaskService {
         const task = this.scopedTask(owner, id);
         return publicTask(task);
     }
+    /** Native Host authority for a currently executing task, never a guest-facing lookup. */
+    activeOwner(sessionId) {
+        const task = [...this.tasks.values()].find((candidate) => candidate.sessionId === sessionId && candidate.status === "running");
+        if (!task || task.cancelRequested)
+            return undefined;
+        return { ...task.owner, availableSkills: [...task.owner.availableSkills] };
+    }
     async cancel(owner, id) {
         const task = this.scopedTask(owner, id);
         if (TERMINAL_STATUSES.has(task.status))

package/dist/panels/browser-capture.d.ts

@@ -1,15 +1 @@
-/** Bounded, domain-neutral requests for the trusted browser's recording chooser. */
-export declare const panelVideoLimits: Readonly<{
-    maxDurationSeconds: 1200;
-    maxBytes: number;
-    defaultDurationSeconds: 300;
-    defaultBytes: number;
-}>;
-export interface PanelVideoOptions {
-    source: "camera" | "screen";
-    microphone: boolean;
-    systemAudio: boolean;
-    maxDurationSeconds: number;
-    maxBytes: number;
-}
-export declare function panelVideoOptions(raw: unknown): PanelVideoOptions;
+export { panelVideoLimits, panelVideoOptions, type PanelVideoOptions, } from "@cjhyy/code-shell-web/panels";

package/dist/panels/browser-capture.js

@@ -1,35 +1 @@
-/** Bounded, domain-neutral requests for the trusted browser's recording chooser. */
-export const panelVideoLimits = Object.freeze({
-    maxDurationSeconds: 1200,
-    maxBytes: 200 * 1024 * 1024,
-    defaultDurationSeconds: 300,
-    defaultBytes: 64 * 1024 * 1024,
-});
-export function panelVideoOptions(raw) {
-    const value = raw;
-    if (!value ||
-        typeof value !== "object" ||
-        Array.isArray(value) ||
-        Object.keys(value).some((key) => !["source", "microphone", "systemAudio", "maxDurationSeconds", "maxBytes"].includes(key)) ||
-        (value.source !== "camera" && value.source !== "screen") ||
-        (value.microphone !== undefined && typeof value.microphone !== "boolean") ||
-        (value.systemAudio !== undefined && typeof value.systemAudio !== "boolean") ||
-        (value.source !== "screen" && value.systemAudio === true))
-        throw new Error("视频录制请求无效。");
-    const maxDurationSeconds = value.maxDurationSeconds ?? panelVideoLimits.defaultDurationSeconds;
-    const maxBytes = value.maxBytes ?? panelVideoLimits.defaultBytes;
-    if (!Number.isSafeInteger(maxDurationSeconds) ||
-        Number(maxDurationSeconds) < 1 ||
-        Number(maxDurationSeconds) > panelVideoLimits.maxDurationSeconds ||
-        !Number.isSafeInteger(maxBytes) ||
-        Number(maxBytes) < 1 ||
-        Number(maxBytes) > panelVideoLimits.maxBytes)
-        throw new Error("视频录制限制无效。");
-    return {
-        source: value.source,
-        microphone: value.microphone !== false,
-        systemAudio: value.systemAudio === true,
-        maxDurationSeconds: Number(maxDurationSeconds),
-        maxBytes: Number(maxBytes),
-    };
-}
+export { panelVideoLimits, panelVideoOptions, } from "@cjhyy/code-shell-web/panels";

package/dist/panels/directory-picker.d.ts

@@ -0,0 +1,48 @@
+export declare const directoryPickerLifetime: number;
+export interface PanelDirectorySelection {
+    path: string;
+    assertCurrent(): void;
+}
+/** Used only after a Host bookmark proves a previous choice; a client path is never sufficient. */
+export declare function capturePanelWorkspaceDirectory(cwd: string, path: string): PanelDirectorySelection;
+/** A pending parent-UI choice of an existing project directory, not filesystem authority. */
+export declare class PanelDirectoryPicker {
+    private readonly cwd;
+    private readonly now;
+    readonly rootPath: string;
+    readonly rootToken: string;
+    readonly initialToken: string;
+    readonly expiresAt: number;
+    private readonly root;
+    private readonly choices;
+    private closed;
+    private reading;
+    private tokenBytes;
+    constructor(cwd: string, now: () => number);
+    close(): void;
+    private assertRoot;
+    assertCurrent(): void;
+    private check;
+    private get;
+    private add;
+    list(token: unknown, authorize: () => Promise<void>): Promise<{
+        rootToken: string;
+        directories: {
+            name: string;
+            token: string;
+        }[];
+        truncated: boolean;
+        parentToken?: string | undefined;
+        directoryToken: string;
+        relativePath: string;
+        name: string;
+    }>;
+    assertListing(listing: {
+        directoryToken: string;
+        directories: Array<{
+            token: string;
+        }>;
+    }): void;
+    /** Called synchronously after final authorization, while this exact confirmation is pending. */
+    select(token: unknown): PanelDirectorySelection;
+}