@cjhyy/code-shell-server 0.9.51 → 0.10.1

package/dist/panels/directory-picker.js

@@ -0,0 +1,247 @@
+import { randomBytes } from "node:crypto";
+import { lstatSync, realpathSync } from "node:fs";
+import { opendir } from "node:fs/promises";
+import { basename, isAbsolute, join, relative, sep } from "node:path";
+import { PanelManagementError } from "./management.js";
+import { PanelBridgeError } from "./bridge-contract.js";
+export const directoryPickerLifetime = 5 * 60_000;
+const TOKEN = /^[A-Za-z0-9_-]{24}$/;
+const MAX_TOKENS = 1024;
+const MAX_ENTRIES = 200;
+const MAX_SCAN = 4096;
+const MAX_TOKEN_BYTES = 1024 * 1024;
+function unavailable() {
+    throw new PanelManagementError(409, "panel_directory_picker", "目录选择已失效，请重新发起。");
+}
+function identity(path) {
+    try {
+        const info = lstatSync(path, { bigint: true });
+        if (!info.isDirectory() || info.isSymbolicLink() || realpathSync(path) !== path)
+            unavailable();
+        return { path, dev: info.dev, ino: info.ino };
+    }
+    catch {
+        return unavailable();
+    }
+}
+function assertIdentity(expected) {
+    const actual = identity(expected.path);
+    if (actual.dev !== expected.dev || actual.ino !== expected.ino)
+        unavailable();
+}
+function visibleName(name) {
+    return (name.length > 0 &&
+        name.length <= 255 &&
+        !name.startsWith(".") &&
+        !/[\\/\u0000-\u001f\u007f]/u.test(name));
+}
+/** Used only after a Host bookmark proves a previous choice; a client path is never sufficient. */
+export function capturePanelWorkspaceDirectory(cwd, path) {
+    let root;
+    try {
+        root = realpathSync(cwd);
+    }
+    catch {
+        return unavailable();
+    }
+    const rel = relative(root, path);
+    if (isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`))
+        unavailable();
+    const parts = rel.split(sep).filter(Boolean);
+    if (parts.length > 64)
+        unavailable();
+    const chain = [identity(root)];
+    for (let i = 0; i < parts.length; i++)
+        chain.push(identity(join(root, ...parts.slice(0, i + 1))));
+    const assertCurrent = () => {
+        try {
+            if (realpathSync(cwd) !== root)
+                unavailable();
+        }
+        catch {
+            unavailable();
+        }
+        for (const entry of chain)
+            assertIdentity(entry);
+    };
+    assertCurrent();
+    return { path, assertCurrent };
+}
+/** A pending parent-UI choice of an existing project directory, not filesystem authority. */
+export class PanelDirectoryPicker {
+    cwd;
+    now;
+    rootPath;
+    rootToken;
+    initialToken;
+    expiresAt;
+    root;
+    choices = new Map();
+    closed = false;
+    reading = false;
+    tokenBytes = 0;
+    constructor(cwd, now) {
+        this.cwd = cwd;
+        this.now = now;
+        this.rootPath = realpathSync(cwd);
+        this.root = identity(this.rootPath);
+        this.expiresAt = now() + directoryPickerLifetime;
+        this.rootToken = this.add([], [this.root]).token;
+        const path = join(this.rootPath, "downloads");
+        let child;
+        try {
+            child = identity(path);
+        }
+        catch (error) {
+            if (!(error instanceof PanelManagementError) &&
+                error.code !== "ENOENT")
+                throw error;
+        }
+        this.initialToken = child
+            ? this.add(["downloads"], [this.root, child], this.rootToken).token
+            : this.rootToken;
+        this.assertCurrent();
+    }
+    close() {
+        this.closed = true;
+        this.choices.clear();
+        this.tokenBytes = 0;
+    }
+    assertRoot() {
+        try {
+            if (realpathSync(this.cwd) !== this.rootPath)
+                unavailable();
+        }
+        catch {
+            unavailable();
+        }
+        assertIdentity(this.root);
+    }
+    assertCurrent() {
+        if (this.closed || this.now() >= this.expiresAt)
+            unavailable();
+        this.assertRoot();
+    }
+    check(choice) {
+        this.assertCurrent();
+        for (const entry of choice.chain)
+            assertIdentity(entry);
+    }
+    get(token) {
+        const choice = typeof token === "string" && TOKEN.test(token) && this.choices.get(token);
+        if (!choice)
+            unavailable();
+        this.check(choice);
+        return choice;
+    }
+    add(parts, chain, parentToken) {
+        const existing = [...this.choices.values()].find((item) => item.parts.join("/") === parts.join("/"));
+        if (existing) {
+            this.check(existing);
+            return existing;
+        }
+        const bytes = Buffer.byteLength(join(this.rootPath, ...parts)) +
+            Buffer.byteLength(parts.join("/")) +
+            chain.length * 32 +
+            256;
+        if (this.choices.size >= MAX_TOKENS ||
+            parts.length > 64 ||
+            this.tokenBytes + bytes > MAX_TOKEN_BYTES)
+            unavailable();
+        const choice = {
+            token: randomBytes(18).toString("base64url"),
+            parts,
+            chain,
+            ...(parentToken ? { parentToken } : {}),
+        };
+        this.choices.set(choice.token, choice);
+        this.tokenBytes += bytes;
+        return choice;
+    }
+    async list(token, authorize) {
+        if (this.reading)
+            throw new PanelBridgeError("RATE_LIMITED", "目录正在读取，请稍后重试。", 50);
+        this.reading = true;
+        try {
+            const choice = this.get(token);
+            await authorize();
+            this.check(choice);
+            const directories = [];
+            let truncated = false;
+            {
+                const directory = await opendir(join(this.rootPath, ...choice.parts));
+                let scanned = 0;
+                try {
+                    this.check(choice);
+                    for await (const entry of directory) {
+                        this.check(choice);
+                        if (++scanned > MAX_SCAN) {
+                            truncated = true;
+                            break;
+                        }
+                        if (!entry.isDirectory() || entry.isSymbolicLink() || !visibleName(entry.name))
+                            continue;
+                        if (directories.length >= MAX_ENTRIES) {
+                            truncated = true;
+                            break;
+                        }
+                        const parts = [...choice.parts, entry.name];
+                        const path = join(this.rootPath, ...parts);
+                        let child;
+                        try {
+                            child = identity(path);
+                        }
+                        catch {
+                            continue;
+                        }
+                        const item = this.add(parts, [...choice.chain, child], choice.token);
+                        directories.push({ name: entry.name, token: item.token });
+                    }
+                }
+                finally {
+                    // for-await closes its directory; the explicit close covers failure before iteration.
+                    try {
+                        await directory.close();
+                    }
+                    catch {
+                        /* Already closed by the iterator. */
+                    }
+                }
+            }
+            await authorize();
+            this.check(choice);
+            for (const item of directories)
+                this.get(item.token);
+            return {
+                directoryToken: choice.token,
+                relativePath: choice.parts.join("/"),
+                name: choice.parts.at(-1) ?? (basename(this.rootPath) || this.rootPath),
+                ...(choice.parentToken ? { parentToken: choice.parentToken } : {}),
+                rootToken: this.rootToken,
+                directories: directories.sort((a, b) => a.name.localeCompare(b.name)),
+                truncated,
+            };
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    assertListing(listing) {
+        this.get(listing.directoryToken);
+        for (const item of listing.directories)
+            this.get(item.token);
+    }
+    /** Called synchronously after final authorization, while this exact confirmation is pending. */
+    select(token) {
+        const choice = this.get(token);
+        const path = join(this.rootPath, ...choice.parts);
+        const chain = [...choice.chain];
+        const assertCurrent = () => {
+            this.assertRoot();
+            for (const entry of chain)
+                assertIdentity(entry);
+        };
+        assertCurrent();
+        return { path, assertCurrent };
+    }
+}

package/dist/panels/http.d.ts

@@ -17,26 +17,26 @@ export declare function createPanelHttp(options: PanelManagementHttpOptions & {
     authorizePanelDirectory?: PanelDirectoryAuthorizer;
 }): {
     service: {
-        snapshot: (appId?: string, reads?: import("./management.js").PanelSnapshotReads) => Promise<import("./types.js").PanelSnapshot>;
-        packageHistory(context: import("./types.js").PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelPackageHistory>;
-        previewRestore(context: import("./types.js").PanelOperationContext, id: unknown, digest: unknown, expected: unknown): Promise<import("./types.js").PanelPackageRestoreReview>;
-        cancelRestore(context: import("./types.js").PanelOperationContext, token: unknown): Promise<{
+        snapshot: (appId?: string, reads?: import("./management.js").PanelSnapshotReads) => Promise<import("@cjhyy/code-shell-web/panels").PanelSnapshot>;
+        packageHistory(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, id: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelPackageHistory>;
+        previewRestore(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, id: unknown, digest: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelPackageRestoreReview>;
+        cancelRestore(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, token: unknown): Promise<{
             cancelled: boolean;
         }>;
-        restore(context: import("./types.js").PanelOperationContext, token: unknown): Promise<{
+        restore(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, token: unknown): Promise<{
             id: string;
             packageDigest: string;
         }>;
-        assertAuthorized: (context: import("./types.js").PanelOperationContext, expected?: number) => Promise<void>;
-        discover(context: import("./types.js").PanelOperationContext, input: unknown): Promise<import("./types.js").PanelDiscovery>;
-        preview: (context: import("./types.js").PanelOperationContext, input: unknown) => Promise<import("./types.js").PanelReview>;
-        previewUpdate(context: import("./types.js").PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelReview>;
-        previewProjectSource: (context: import("./types.js").PanelOperationContext, input: import("@cjhyy/code-shell-core").PanelAppSourceInput, expected?: {
+        assertAuthorized: (context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, expected?: number) => Promise<void>;
+        discover(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, input: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelDiscovery>;
+        preview: (context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, input: unknown) => Promise<import("@cjhyy/code-shell-web/panels").PanelReview>;
+        previewUpdate(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, id: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelReview>;
+        previewProjectSource: (context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, input: import("@cjhyy/code-shell-core").PanelAppSourceInput, expected?: {
             id: string;
             revision: string;
-        }) => Promise<import("./types.js").PanelProjectReview>;
-        previewProjectUpdate(context: import("./types.js").PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelProjectReview>;
-        install(context: import("./types.js").PanelOperationContext, token: unknown, bind?: boolean, approval?: {
+        }) => Promise<import("@cjhyy/code-shell-web/panels").PanelProjectReview>;
+        previewProjectUpdate(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, id: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelProjectReview>;
+        install(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, token: unknown, bind?: boolean, approval?: {
             overwrite?: boolean;
             expectedId?: string;
             releaseExecutions?: (appId: string, matches: (scope: import("./execution-gate.js").PanelExecutionScope) => boolean) => Promise<void>;
@@ -44,8 +44,8 @@ export declare function createPanelHttp(options: PanelManagementHttpOptions & {
             id: string;
             packageDigest: string | undefined;
         }>;
-        binding(context: import("./types.js").PanelOperationContext, id: unknown, bound: unknown, expected: unknown): Promise<import("./types.js").PanelSnapshot>;
-        remove(context: import("./types.js").PanelOperationContext, id: unknown, expected: unknown): Promise<{
+        binding(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, id: unknown, bound: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelSnapshot>;
+        remove(context: import("@cjhyy/code-shell-web/panels").PanelOperationContext, id: unknown, expected: unknown): Promise<{
             removed: true;
         }>;
         cancelOwner(owner: string): void;

package/dist/panels/management-http.d.ts

@@ -8,9 +8,9 @@ export interface PanelManagementHttpOptions extends PanelManagementOptions {
 /** Call only after the host's same-origin authentication boundary. */
 export declare function createPanelManagementHttp(options: PanelManagementHttpOptions): {
     service: {
-        snapshot: (appId?: string, reads?: import("./management.js").PanelSnapshotReads) => Promise<import("./types.js").PanelSnapshot>;
-        packageHistory(context: PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelPackageHistory>;
-        previewRestore(context: PanelOperationContext, id: unknown, digest: unknown, expected: unknown): Promise<import("./types.js").PanelPackageRestoreReview>;
+        snapshot: (appId?: string, reads?: import("./management.js").PanelSnapshotReads) => Promise<import("@cjhyy/code-shell-web/panels").PanelSnapshot>;
+        packageHistory(context: PanelOperationContext, id: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelPackageHistory>;
+        previewRestore(context: PanelOperationContext, id: unknown, digest: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelPackageRestoreReview>;
         cancelRestore(context: PanelOperationContext, token: unknown): Promise<{
             cancelled: boolean;
         }>;
@@ -19,14 +19,14 @@ export declare function createPanelManagementHttp(options: PanelManagementHttpOp
             packageDigest: string;
         }>;
         assertAuthorized: (context: PanelOperationContext, expected?: number) => Promise<void>;
-        discover(context: PanelOperationContext, input: unknown): Promise<import("./types.js").PanelDiscovery>;
-        preview: (context: PanelOperationContext, input: unknown) => Promise<import("./types.js").PanelReview>;
-        previewUpdate(context: PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelReview>;
+        discover(context: PanelOperationContext, input: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelDiscovery>;
+        preview: (context: PanelOperationContext, input: unknown) => Promise<import("@cjhyy/code-shell-web/panels").PanelReview>;
+        previewUpdate(context: PanelOperationContext, id: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelReview>;
         previewProjectSource: (context: PanelOperationContext, input: import("@cjhyy/code-shell-core").PanelAppSourceInput, expected?: {
             id: string;
             revision: string;
-        }) => Promise<import("./types.js").PanelProjectReview>;
-        previewProjectUpdate(context: PanelOperationContext, id: unknown, expected: unknown): Promise<import("./types.js").PanelProjectReview>;
+        }) => Promise<import("@cjhyy/code-shell-web/panels").PanelProjectReview>;
+        previewProjectUpdate(context: PanelOperationContext, id: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelProjectReview>;
         install(context: PanelOperationContext, token: unknown, bind?: boolean, approval?: {
             overwrite?: boolean;
             expectedId?: string;
@@ -35,7 +35,7 @@ export declare function createPanelManagementHttp(options: PanelManagementHttpOp
             id: string;
             packageDigest: string | undefined;
         }>;
-        binding(context: PanelOperationContext, id: unknown, bound: unknown, expected: unknown): Promise<import("./types.js").PanelSnapshot>;
+        binding(context: PanelOperationContext, id: unknown, bound: unknown, expected: unknown): Promise<import("@cjhyy/code-shell-web/panels").PanelSnapshot>;
         remove(context: PanelOperationContext, id: unknown, expected: unknown): Promise<{
             removed: true;
         }>;

package/dist/panels/process-service.d.ts

@@ -26,9 +26,9 @@ export interface PanelAppProcessServiceOptions {
     /** Rechecked after asynchronous work and immediately before admitting a process. */
     isOwnerAuthorized?(owner: PanelProcessOwner): boolean | Promise<boolean>;
     /**
-     * Desktop delegates durable approval lifetime to its Host hooks. Web uses guest
-     * to isolate each authenticated instance; guest approvals never use the
-     * app-wide durable hooks.
+     * When executable confirmation is required, app scope can delegate durable
+     * approval to Host hooks. Guest scope isolates authenticated instances and
+     * never uses the app-wide durable hooks.
      */
     approvalScope?: "app" | "guest";
     confirmExecution(input: {
@@ -40,7 +40,7 @@ export interface PanelAppProcessServiceOptions {
     }): Promise<boolean>;
     isExecutionApproved?(scope: PanelProcessApprovalScope): Promise<boolean>;
     rememberExecutionApproval?(scope: PanelProcessApprovalScope): Promise<void>;
-    /** Desktop can use installed-app process permission and trusted-project binding as consent. */
+    /** Hosts can use installed-app process permission and authorized-project binding as consent. */
     allowAuthorizedProcessWithoutPrompt?: boolean;
     /** Resolve a declared entry in this app revision; return a canonical, reviewed file. */
     resolvePackageEntry?(owner: PanelProcessOwner, name: string): Promise<{
@@ -75,6 +75,7 @@ export declare class PanelAppProcessService {
     private readonly retiring;
     private readonly receipts;
     private readonly approvedExecutables;
+    private readonly pendingExecutionApprovals;
     private readonly guestEpochs;
     private readonly reservations;
     private closed;

package/dist/panels/process-service.js

@@ -169,6 +169,7 @@ export class PanelAppProcessService {
     retiring = new Map();
     receipts;
     approvedExecutables = new Set();
+    pendingExecutionApprovals = new Map();
     guestEpochs = new Map();
     reservations = new Map();
     closed = false;
@@ -447,6 +448,7 @@ export class PanelAppProcessService {
         // Admission is reserved before the first await, including a user's approval dialog.
         const releaseExecution = this.options.acquireExecution?.(owner);
         let processOwnsExecution = false;
+        let pendingApproval;
         this.reservations.set(owner.guestId, reserved + 1);
         try {
             await this.authorize(owner, epoch);
@@ -462,29 +464,45 @@ export class PanelAppProcessService {
             const guestScoped = this.options.approvalScope === "guest";
             const approvalKey = (guestScoped ? `${owner.guestId}\0${epoch}\0` : "") +
                 `${scope.appId}\0${scope.revision}\0${scope.executablePath}\0${scope.executableFingerprint}`;
-            // Desktop already checks installed-app process permission and a trusted,
-            // bound project in authorize(). Web keeps its per-guest confirmation path.
+            // Hosts may use installed-app process permission and their authorized,
+            // bound project as consent; authorize() still runs before every spawn.
             let approved = this.options.allowAuthorizedProcessWithoutPrompt === true ||
                 this.approvedExecutables.has(approvalKey);
             if (!approved && !guestScoped && this.options.isExecutionApproved) {
                 approved = await this.options.isExecutionApproved(scope).catch(() => false);
                 await this.authorize(owner, epoch);
             }
+            approved ||= this.approvedExecutables.has(approvalKey);
             if (!approved) {
-                const allowed = await this.options.confirmExecution({
-                    guestId: owner.guestId,
-                    appId: owner.appId,
-                    appTitle: owner.appTitle,
-                    executable: executable.name,
-                    executablePath: executable.path,
-                });
-                await this.authorize(owner, epoch);
-                if (!allowed)
-                    throw new Error(`User denied running ${executable.name}`);
-                if (!guestScoped) {
-                    await this.options.rememberExecutionApproval?.(scope).catch(() => undefined);
-                    await this.authorize(owner, epoch);
+                let approval = this.pendingExecutionApprovals.get(approvalKey);
+                if (!approval) {
+                    approval = {
+                        guestId: owner.guestId,
+                        waiters: 0,
+                        result: (async () => {
+                            const allowed = await this.options.confirmExecution({
+                                guestId: owner.guestId,
+                                appId: owner.appId,
+                                appTitle: owner.appTitle,
+                                executable: executable.name,
+                                executablePath: executable.path,
+                            });
+                            await this.authorize(owner, epoch);
+                            if (!allowed)
+                                throw new Error(`User denied running ${executable.name}`);
+                            if (!guestScoped) {
+                                await this.options.rememberExecutionApproval?.(scope).catch(() => undefined);
+                                await this.authorize(owner, epoch);
+                            }
+                        })(),
+                    };
+                    this.pendingExecutionApprovals.set(approvalKey, approval);
                 }
+                approval.waiters++;
+                pendingApproval = { key: approvalKey, approval };
+                await approval.result;
+                // Sharing consent does not share a caller's authority or process handles.
+                await this.authorize(owner, epoch);
             }
             // A binary replaced while a dialog was open must earn a new approval.
             if ((await executableFingerprint(executable.path)) !== scope.executableFingerprint) {
@@ -618,6 +636,13 @@ export class PanelAppProcessService {
                 }),
             };
             this.processes.set(processId, running);
+            // A successful launcher may leave children behind (including children
+            // retaining stdout). Reap its group on leader exit, before close/lease release.
+            child.once("exit", () => {
+                const pid = child.pid;
+                if (!running.termination && typeof pid === "number" && pid > 1)
+                    running.termination = killProcessGroup(pid).catch(() => { });
+            });
             if (modelTraceOwner && this.options.modelTraces) {
                 const channel = new PanelModelTraceChannel({
                     service: this.options.modelTraces,
@@ -668,7 +693,7 @@ export class PanelAppProcessService {
                     clearTimeout(lifetime);
                     if (inputChecks)
                         clearInterval(inputChecks);
-                    // Cancellation also waits for the process group, not just its leader.
+                    // Natural exit and cancellation both wait for the entire process group.
                     await running.termination;
                     let finalCode = code;
                     if (inputChecks && this.processes.get(processId) === running) {
@@ -704,6 +729,14 @@ export class PanelAppProcessService {
             return { processId, executable: executable.name };
         }
         finally {
+            if (pendingApproval) {
+                const { key, approval } = pendingApproval;
+                approval.waiters--;
+                // Keep successful consent in flight until a caller has cached it after
+                // all spawn checks. Rejections disappear once every waiter has observed them.
+                if (!approval.waiters && this.pendingExecutionApprovals.get(key) === approval)
+                    this.pendingExecutionApprovals.delete(key);
+            }
             if (!processOwnsExecution)
                 releaseExecution?.();
             const remaining = (this.reservations.get(owner.guestId) ?? 1) - 1;
@@ -874,6 +907,10 @@ export class PanelAppProcessService {
     }
     revokeGuest(guestId) {
         this.guestEpochs.set(guestId, (this.guestEpochs.get(guestId) ?? 0) + 1);
+        for (const [key, approval] of this.pendingExecutionApprovals) {
+            if (approval.guestId === guestId)
+                this.pendingExecutionApprovals.delete(key);
+        }
         if (this.options.approvalScope === "guest") {
             for (const key of this.approvedExecutables) {
                 if (key.startsWith(`${guestId}\0`))
@@ -938,6 +975,7 @@ export class PanelAppProcessService {
         for (const guestId of guests)
             this.revokeGuest(guestId);
         this.approvedExecutables.clear();
+        this.pendingExecutionApprovals.clear();
         this.receipts.close();
     }
     terminate(running) {