@cjhyy/code-shell-server 0.9.21 → 0.9.23

package/dist/panels/process-service.js

@@ -271,6 +271,7 @@ export class PanelAppProcessService {
         await this.authorize(owner, epoch);
         const info = await stat(resolved);
         await this.authorize(owner, epoch);
+        await input.validate?.();
         this.assertLive(owner, epoch);
         if (!info.isFile())
             throw new Error("sealed process input is not a file");
@@ -283,6 +284,7 @@ export class PanelAppProcessService {
             argumentName: input.argumentName,
             path: resolved,
             cleanup: input.cleanup ?? (() => undefined),
+            validate: input.validate,
         });
         return { handle };
     }
@@ -391,6 +393,31 @@ export class PanelAppProcessService {
         }
         const rawArgs = validateArguments(input.args);
         const fileArgumentHandles = validateFileArgumentHandles(input.fileArgumentHandles);
+        const validateInputs = async () => {
+            for (const handle of fileArgumentHandles) {
+                const grant = this.fileArguments.get(handle);
+                if (!grant || !sameProcessOwner(grant, owner))
+                    throw new Error("sealed process input was revoked");
+                try {
+                    await grant.validate?.();
+                }
+                catch {
+                    if (this.fileArguments.get(handle) === grant) {
+                        this.fileArguments.delete(handle);
+                        try {
+                            grant.cleanup();
+                        }
+                        catch {
+                            /* Revocation still takes effect. */
+                        }
+                    }
+                    throw new Error("sealed process input authorization changed; authorize it again");
+                }
+                this.assertLive(owner, epoch);
+                if (this.fileArguments.get(handle) !== grant)
+                    throw new Error("sealed process input was revoked");
+            }
+        };
         const sealedArgs = [];
         for (const handle of fileArgumentHandles) {
             const grant = this.fileArguments.get(handle);
@@ -411,6 +438,8 @@ export class PanelAppProcessService {
             throw new Error(`Panel App may run at most ${MAX_CONCURRENT_PROCESSES} processes at once`);
         }
         // Admission is reserved before the first await, including a user's approval dialog.
+        const releaseExecution = this.options.acquireExecution?.(owner);
+        let processOwnsExecution = false;
         this.reservations.set(owner.guestId, reserved + 1);
         try {
             await this.authorize(owner, epoch);
@@ -463,6 +492,8 @@ export class PanelAppProcessService {
                 if ((await verifyProcessEntry(entry.path, entry.sha256)) !== entry.identity)
                     throw new Error("reviewed package entry was replaced; resolve it again");
             }
+            await validateInputs();
+            await this.authorize(owner, epoch);
             const env = safeProcessEnv(this.options.env ?? process.env, this.options.extraPathDirectories?.() ?? []);
             this.assertLive(owner, epoch);
             if (this.executables.get(input.executableHandle) !== executable ||
@@ -570,29 +601,71 @@ export class PanelAppProcessService {
                 }),
             };
             this.processes.set(processId, running);
+            let checkingInputs = false;
+            const inputChecks = fileArgumentHandles.some((handle) => this.fileArguments.get(handle)?.validate)
+                ? setInterval(() => {
+                    if (checkingInputs || this.processes.get(processId) !== running || running.termination)
+                        return;
+                    checkingInputs = true;
+                    void validateInputs()
+                        .catch(() => {
+                        if (this.processes.get(processId) !== running || running.termination)
+                            return;
+                        emit("process.output", {
+                            processId,
+                            stream: "stderr",
+                            text: "Process input authorization changed; CodeShell stopped it.\n",
+                        });
+                        this.terminate(running);
+                    })
+                        .finally(() => {
+                        checkingInputs = false;
+                    });
+                }, 1000)
+                : undefined;
+            inputChecks?.unref();
             child.once("close", (code, signal) => {
                 void (async () => {
                     clearTimeout(lifetime);
+                    if (inputChecks)
+                        clearInterval(inputChecks);
                     // Cancellation also waits for the process group, not just its leader.
                     await running.termination;
-                    finishExit({ code, signal });
+                    let finalCode = code;
+                    if (inputChecks && this.processes.get(processId) === running) {
+                        try {
+                            await validateInputs();
+                        }
+                        catch {
+                            finalCode = code === 0 ? 1 : code;
+                            emit("process.output", {
+                                processId,
+                                stream: "stderr",
+                                text: "Process input authorization changed; results were rejected.\n",
+                            });
+                        }
+                    }
+                    finishExit({ code: finalCode, signal });
                     this.retiring.delete(processId);
                     if (this.processes.get(processId)?.child !== child)
                         return;
                     this.processes.delete(processId);
                     record.status = "exited";
                     record.exitedAt = this.now();
-                    record.code = code;
+                    record.code = finalCode;
                     record.signal = signal;
-                    emit("process.exit", { processId, code, signal });
+                    emit("process.exit", { processId, code: finalCode, signal });
                     // Keep the receipt only after the operating system reports the real close.
                     if (!this.closed && (this.guestEpochs.get(owner.guestId) ?? 0) === epoch)
                         this.receipts.add(record);
-                })();
+                })().finally(() => releaseExecution?.());
             });
+            processOwnsExecution = true;
             return { processId, executable: executable.name };
         }
         finally {
+            if (!processOwnsExecution)
+                releaseExecution?.();
             const remaining = (this.reservations.get(owner.guestId) ?? 1) - 1;
             if (remaining)
                 this.reservations.set(owner.guestId, remaining);

package/dist/panels/resources/http.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { PanelResourceService } from "./service.js";
+import type { ResourceScope } from "./types.js";
+/** Browser byte transport; scope and reader are resolved by the authenticated Host. */
+export declare function servePanelResource(request: IncomingMessage, response: ServerResponse, options: {
+    service: PanelResourceService;
+    scope: ResourceScope;
+    id: string;
+    download: boolean;
+    isAuthorized(): Promise<boolean>;
+}): Promise<void>;

package/dist/panels/resources/http.js

@@ -0,0 +1,74 @@
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+/** Browser byte transport; scope and reader are resolved by the authenticated Host. */
+export async function servePanelResource(request, response, options) {
+    let source = null;
+    const authorize = async () => {
+        if (request.aborted || response.destroyed || !(await options.isAuthorized()))
+            throw new Error("Resource authorization expired");
+    };
+    try {
+        await authorize();
+        if (!["GET", "HEAD"].includes(request.method ?? "")) {
+            response.writeHead(405, { Allow: "GET, HEAD" }).end();
+            return;
+        }
+        const asset = await options.service.get(options.scope, options.id);
+        const result = await options.service.openRead(options.scope, options.id, {
+            range: request.headers.range,
+            method: asset.bytes === 0 ? "HEAD" : request.method,
+        });
+        source = result.body;
+        await authorize();
+        const headers = { ...result.headers, "Referrer-Policy": "no-referrer" };
+        if (options.download)
+            headers["Content-Disposition"] =
+                `attachment; filename*=UTF-8''${encodeURIComponent(asset.name).replace(/['()*!]/g, (value) => `%${value.charCodeAt(0).toString(16).toUpperCase()}`)}`;
+        response.writeHead(result.status, headers);
+        if (!source) {
+            response.end();
+            return;
+        }
+        let checking = false;
+        const timer = setInterval(() => {
+            if (checking)
+                return;
+            checking = true;
+            void authorize()
+                .catch(() => {
+                source?.destroy();
+                response.destroy();
+            })
+                .finally(() => {
+                checking = false;
+            });
+        }, 250);
+        timer.unref();
+        try {
+            await pipeline(Readable.from((async function* () {
+                for await (const chunk of source) {
+                    await authorize();
+                    yield chunk;
+                }
+            })(), { objectMode: false }), response);
+        }
+        finally {
+            clearInterval(timer);
+        }
+    }
+    catch {
+        if (response.headersSent || response.destroyed)
+            response.destroy();
+        else
+            response
+                .writeHead(404, {
+                "Content-Type": "text/plain; charset=utf-8",
+                "Cache-Control": "no-store",
+                "X-Content-Type-Options": "nosniff",
+            })
+                .end(request.method === "HEAD" ? undefined : "文件不可用或访问授权已失效，请重新打开面板。");
+    }
+    finally {
+        source?.destroy();
+    }
+}

package/dist/panels/resources/references.d.ts

@@ -30,6 +30,11 @@ export declare class ExternalResourceReferences {
     createFromDirectory(scope: ResourceScope, root: string, path: string, options?: ExternalReferenceOptions): Promise<ExternalResourceReference>;
     createFromSelectedPath(scope: ResourceScope, path: string, options?: ExternalReferenceOptions): Promise<ExternalResourceReference>;
     get(scope: ResourceScope, id: string): Promise<ExternalResourceReference>;
+    /**
+     * Host-only: the verified absolute location of a reference, for a read-only
+     * handoff to a reviewed tool. Never return it to a Guest.
+     */
+    location(scope: ResourceScope, id: string, options?: ExternalReferenceOptions): Promise<string>;
     relinkFromDirectory(scope: ResourceScope, id: string, root: string, path: string, options?: ExternalReferenceOptions): Promise<ExternalResourceReference>;
     relinkFromSelectedPath(scope: ResourceScope, id: string, path: string, options?: ExternalReferenceOptions): Promise<ExternalResourceReference>;
     forget(scope: ResourceScope, id: string): Promise<{

package/dist/panels/resources/references.js

@@ -270,6 +270,32 @@ export class ExternalResourceReferences {
             }
         });
     }
+    /**
+     * Host-only: the verified absolute location of a reference, for a read-only
+     * handoff to a reviewed tool. Never return it to a Guest.
+     */
+    location(scope, id, options = {}) {
+        return this.locked(scope, async () => {
+            const record = await this.record(scope, id);
+            const source = await this.checked(scope, record, options);
+            try {
+                await source.verify();
+                return join(record.root, record.path);
+            }
+            catch (error) {
+                // A drive may disappear after checked() returns. Preserve revocation
+                // and abort semantics before hiding native errors containing its path.
+                await this.authorize(scope, options);
+                if (error instanceof ReferenceUnavailable)
+                    throw error;
+                const code = error.code;
+                throw new ReferenceUnavailable(["ENOENT", "ENOTDIR", "EACCES", "EPERM"].includes(code ?? "") ? "missing" : "changed");
+            }
+            finally {
+                await source.close();
+            }
+        });
+    }
     relinkFromDirectory(scope, id, root, path, options = {}) {
         return this.locked(scope, async () => {
             const previous = await this.record(scope, id);

package/dist/panels/runtime-services.js

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { chmod, link, lstat, mkdir, open, opendir, realpath, rename, rm, writeFile, } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
 import { acquireLockOnPath } from "@cjhyy/code-shell-core/internal";
-import { DEFAULT_PANEL_APP_STORAGE_QUOTA_BYTES, panelAppStorageKey, panelAppStoragePath, preparePanelAppStorage, readPanelAppStorage, writePanelAppStorage, } from "./storage-store.js";
+import { DEFAULT_PANEL_APP_STORAGE_QUOTA_BYTES, panelAppStorageSnapshot, panelAppStorageChange, applyPanelAppStorageChange, panelAppStorageKey, panelAppStoragePath, preparePanelAppStorage, readPanelAppStorage, writePanelAppStorage, } from "./storage-store.js";
 const MAX_READ_BYTES = 480 * 1024;
 const MAX_WRITE_BYTES = 384 * 1024;
 const MAX_LIST_ENTRIES = 200;
@@ -21,6 +21,8 @@ const TEXT_EXTENSIONS = new Set([
 ]);
 const METHOD_PERMISSIONS = {
     "storage.get": "storage",
+    "storage.getSnapshot": "storage",
+    "storage.compareAndSet": "storage",
     "storage.set": "storage",
     "storage.delete": "storage",
     "workspace.info": "workspace.info",
@@ -134,10 +136,15 @@ export class PanelRuntimeServices {
         const key = panelAppStorageKey(params);
         const file = panelAppStoragePath(this.dataDir, scope.appId, scope.projectPath);
         const quota = DEFAULT_PANEL_APP_STORAGE_QUOTA_BYTES;
-        if (method === "storage.get") {
+        if (method === "storage.get" || method === "storage.getSnapshot") {
             const state = await readPanelAppStorage(file, quota);
-            return Object.hasOwn(state, key) ? state[key] : null;
+            return method === "storage.getSnapshot"
+                ? panelAppStorageSnapshot(state, key)
+                : Object.hasOwn(state, key)
+                    ? state[key]
+                    : null;
         }
+        const change = method === "storage.compareAndSet" ? panelAppStorageChange(params) : null;
         const encoded = method === "storage.set" ? JSON.stringify(params?.value) : null;
         if (method === "storage.set" && encoded === undefined)
             throw new Error("Panel App storage only accepts JSON values");
@@ -147,6 +154,12 @@ export class PanelRuntimeServices {
             const release = await storageLock(file);
             try {
                 const state = await readPanelAppStorage(file, quota);
+                if (change) {
+                    const result = applyPanelAppStorageChange(state, change);
+                    if (result.updated)
+                        await writePanelAppStorage(file, state, quota, () => authorized(scope));
+                    return result;
+                }
                 const existed = Object.hasOwn(state, key);
                 if (method === "storage.set")
                     state[key] = JSON.parse(encoded);

package/dist/panels/runtime.d.ts

@@ -1,8 +1,15 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type InstalledPanelApp } from "@cjhyy/code-shell-core";
-import { type PanelManagementOptions } from "./management.js";
+import type { SharedPanelToolHost } from "./shared-tool-jobs.js";
+import { type PanelDirectoryAuthorizer } from "./directory-bookmarks.js";
 import type { PanelSnapshot } from "./types.js";
-export declare const panelWebCompatibility: NonNullable<PanelManagementOptions["compatibility"]>;
+import { type PanelAutomationHost } from "./automations.js";
+export declare const panelWebCompatibility: (app: Pick<InstalledPanelApp, "permissions">, options?: {
+    automations?: boolean;
+}) => {
+    supported: boolean;
+    reasons: string[];
+};
 export interface PanelTaskScope {
     instanceId: string;
     ownerId: string;
@@ -24,16 +31,21 @@ export interface PanelTaskHost {
 export interface PanelRuntimeOptions {
     cwd: string;
     bindingCwd?: string;
+    projectPackages?: boolean;
     dataDir: string;
     host: "hub" | "desktop";
     publicPathPrefix?: string;
-    snapshot: () => Promise<PanelSnapshot>;
+    snapshot: (appId?: string) => Promise<PanelSnapshot>;
     ownerId: (request: IncomingMessage) => Promise<string | undefined>;
     isAuthorized: (request: IncomingMessage) => Promise<boolean>;
     /** Host/test seam. HTTP callers never provide install paths or this catalog. */
-    listInstalled?: () => Promise<InstalledPanelApp[]>;
+    listInstalled?: (appId?: string) => Promise<InstalledPanelApp[]>;
     now?: () => number;
     agentTasks?: PanelTaskHost;
+    automations?: PanelAutomationHost;
+    /** Reuse the Desktop coordinator; this transport never owns its lifetime. */
+    sharedToolJobs?: SharedPanelToolHost;
+    authorizePanelDirectory?: PanelDirectoryAuthorizer;
     createAgentTasks?: (hooks: {
         onPanelAction(scope: PanelTaskScope, input: Record<string, unknown>): Promise<unknown>;
     }) => PanelTaskHost;