@cjhyy/code-shell-server 0.9.19 → 0.9.21

package/dist/index.panels.d.ts

@@ -15,3 +15,4 @@ export * from "./panels/bridge-contract.js";
 export * from "./panels/connections.js";
 export * from "./panels/tool-jobs.js";
 export * from "./panels/tool-executor.js";
+export * from "./panels/directory-bookmarks.js";

package/dist/index.panels.js

@@ -14,3 +14,4 @@ export * from "./panels/bridge-contract.js";
 export * from "./panels/connections.js";
 export * from "./panels/tool-jobs.js";
 export * from "./panels/tool-executor.js";
+export * from "./panels/directory-bookmarks.js";

package/dist/panels/bridge-contract.js

@@ -11,6 +11,7 @@ export const panelProcessMethods = [
     "process.end",
     "filesystem.getKnownDirectory",
     "filesystem.pickDirectory",
+    "filesystem.restoreDirectory",
     "filesystem.openDirectory",
 ];
 export const panelResourceMethods = [

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

@@ -0,0 +1,7 @@
+/** The guest receives only a random bookmark. A path saved in guest storage grants nothing. */
+export declare class PanelAppDirectoryBookmarks {
+    private readonly file;
+    constructor(file: string);
+    remember(appId: string, projectPath: string, path: string): string;
+    restore(appId: string, projectPath: string, id: unknown): string;
+}

package/dist/panels/directory-bookmarks.js

@@ -0,0 +1,141 @@
+import { randomUUID } from "node:crypto";
+import { chmodSync, closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute } from "node:path";
+import { acquireFileLock } from "@cjhyy/code-shell-core/internal";
+const MAX_RECORDS = 256;
+const MAX_BYTES = 256 * 1024;
+const ID = /^[a-f0-9-]{36}$/i;
+function valid(record) {
+    if (!record || typeof record !== "object" || Array.isArray(record))
+        return false;
+    const item = record;
+    return (typeof item.id === "string" &&
+        ID.test(item.id) &&
+        typeof item.appId === "string" &&
+        /^[a-z][a-z0-9-]{0,63}$/.test(item.appId) &&
+        typeof item.projectPath === "string" &&
+        isAbsolute(item.projectPath) &&
+        typeof item.path === "string" &&
+        isAbsolute(item.path) &&
+        item.path.length <= 32_768 &&
+        item.projectPath.length <= 32_768 &&
+        Number.isSafeInteger(item.dev) &&
+        Number.isSafeInteger(item.ino) &&
+        Number.isSafeInteger(item.savedAt));
+}
+function read(file) {
+    let fd;
+    try {
+        const entry = lstatSync(file);
+        if (!entry.isFile() || entry.isSymbolicLink() || entry.size > MAX_BYTES)
+            throw new Error("Panel directory bookmarks are not a bounded regular file");
+        fd = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const opened = fstatSync(fd);
+        if (!opened.isFile() || opened.size > MAX_BYTES)
+            throw new Error("Panel directory bookmarks are not a bounded regular file");
+        const document = JSON.parse(readFileSync(fd, "utf8"));
+        if (!document || typeof document !== "object" || Array.isArray(document))
+            throw new Error("Invalid Panel directory bookmarks");
+        const value = document;
+        if (value.version !== 1 ||
+            !Array.isArray(value.bookmarks) ||
+            value.bookmarks.length > MAX_RECORDS ||
+            !value.bookmarks.every(valid))
+            throw new Error("Invalid Panel directory bookmarks");
+        return value.bookmarks;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function write(file, bookmarks) {
+    const parent = dirname(file);
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    const directory = lstatSync(parent);
+    if (!directory.isDirectory() || directory.isSymbolicLink())
+        throw new Error("Invalid Panel bookmark directory");
+    try {
+        const existing = lstatSync(file);
+        if (!existing.isFile() || existing.isSymbolicLink())
+            throw new Error("Invalid Panel bookmark file");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const serialized = JSON.stringify({ version: 1, bookmarks });
+    if (Buffer.byteLength(serialized) > MAX_BYTES)
+        throw new Error("Panel directory bookmarks are full");
+    const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, serialized, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        renameSync(temporary, file);
+        if (process.platform !== "win32")
+            chmodSync(file, 0o600);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+}
+/** The guest receives only a random bookmark. A path saved in guest storage grants nothing. */
+export class PanelAppDirectoryBookmarks {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    remember(appId, projectPath, path) {
+        if (!/^[a-z][a-z0-9-]{0,63}$/.test(appId) || !isAbsolute(projectPath) || !isAbsolute(path))
+            throw new Error("Invalid Panel directory bookmark scope");
+        const info = lstatSync(path);
+        if (!info.isDirectory() || info.isSymbolicLink() || realpathSync(path) !== path)
+            throw new Error("Selected directory changed; choose it again");
+        const bookmark = {
+            id: randomUUID(),
+            appId,
+            projectPath,
+            path,
+            dev: info.dev,
+            ino: info.ino,
+            savedAt: Date.now(),
+        };
+        mkdirSync(dirname(this.file), { recursive: true, mode: 0o700 });
+        const release = acquireFileLock(this.file);
+        try {
+            const previous = read(this.file);
+            write(this.file, [
+                bookmark,
+                ...previous.filter((item) => !(item.appId === appId && item.projectPath === projectPath && item.path === path)),
+            ].slice(0, MAX_RECORDS));
+        }
+        finally {
+            release();
+        }
+        return bookmark.id;
+    }
+    restore(appId, projectPath, id) {
+        if (typeof id !== "string" || !ID.test(id))
+            throw new Error("Invalid directory bookmark");
+        const bookmark = read(this.file).find((item) => item.id === id && item.appId === appId && item.projectPath === projectPath);
+        if (!bookmark)
+            throw new Error("Saved directory is unavailable; choose it again");
+        try {
+            const info = lstatSync(bookmark.path);
+            if (!info.isDirectory() ||
+                info.isSymbolicLink() ||
+                info.dev !== bookmark.dev ||
+                info.ino !== bookmark.ino ||
+                realpathSync(bookmark.path) !== bookmark.path)
+                throw new Error("Saved directory changed");
+        }
+        catch {
+            throw new Error("Saved directory changed; choose it again");
+        }
+        return bookmark.path;
+    }
+}

package/dist/panels/http.d.ts

@@ -25,10 +25,10 @@ export declare function createPanelHttp(options: PanelManagementHttpOptions & {
     };
     activeTaskCount: () => number;
     panelAction: (ownerId: string, sessionId: string, input: Record<string, unknown>) => Promise<unknown>;
-    invalidate: (appId?: string) => void;
+    invalidate: (appId?: string) => Promise<void>;
     ownsAssets: (request: IncomingMessage) => boolean;
     handleAssets: (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
     handle(request: IncomingMessage, response: ServerResponse): Promise<boolean>;
     cancelOwner(owner: string): void;
-    close(): void;
+    close(): Promise<void>;
 };

package/dist/panels/http.js

@@ -6,7 +6,7 @@ export function createPanelHttp(options) {
         ...options,
         compatibility: options.compatibility ?? panelWebCompatibility,
         onChanged: async (id, kind) => {
-            runtime?.invalidate(id);
+            await runtime?.invalidate(id);
             await options.onChanged?.(id, kind);
         },
     });
@@ -29,8 +29,8 @@ export function createPanelHttp(options) {
             runtime.cancelOwner(owner);
             management.cancelOwner(owner);
         },
-        close() {
-            runtime.close();
+        async close() {
+            await runtime.close();
             management.close();
         },
     };

package/dist/panels/runtime.d.ts

@@ -44,8 +44,8 @@ export declare function createPanelRuntime(options: PanelRuntimeOptions): {
     panelAction(ownerId: string, sessionId: string, input: Record<string, unknown>): Promise<unknown>;
     ownsAssets(request: IncomingMessage): boolean;
     cancelOwner: (owner: string) => void;
-    invalidate(appId?: string): void;
-    close(): Promise<undefined>;
+    invalidate(appId?: string): Promise<void>;
+    close(): Promise<void>;
     handle(request: IncomingMessage, response: ServerResponse): Promise<boolean>;
     handleAssets(request: IncomingMessage, response: ServerResponse): Promise<boolean>;
 };

package/dist/panels/runtime.js

@@ -4,10 +4,13 @@ import { lstat, mkdir, open, opendir, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, resolve, sep } from "node:path";
 import { listInstalledPanelApps, validateToolArgsStrict, } from "@cjhyy/code-shell-core";
-import { panelRuntimeApiVersion, panelProcessMethods, panelResourceMethods, panelRuntimeCapabilities, PanelBridgeError, panelBridgeFailure, } from "./bridge-contract.js";
+import { panelRuntimeApiVersion, panelProcessMethods, panelResourceMethods, panelToolJobMethods, panelRuntimeCapabilities, PanelBridgeError, panelBridgeFailure, } from "./bridge-contract.js";
 import { PanelResourceService } from "./resources/service.js";
 import { panelConnections, panelConnectionIds, materializePanelConnections, } from "./connections.js";
 import { PanelRuntimeServices } from "./runtime-services.js";
+import { PanelToolJobService, toolJobLimits, } from "./tool-jobs.js";
+import { createPanelToolExecutor } from "./tool-executor.js";
+import { PanelAppDirectoryBookmarks } from "./directory-bookmarks.js";
 import { handlePanelProcessDirectory } from "./process-files.js";
 import { PanelAppProcessService, panelExecutableDirectories, panelProcessInfo, } from "./process-service.js";
 import { PanelManagementError } from "./management.js";
@@ -29,6 +32,7 @@ const METHODS = [
     "notifications.send",
     ...panelProcessMethods,
     ...panelResourceMethods,
+    ...panelToolJobMethods,
     "credentials.connections.list",
     "credentials.connections.authorizeProcess",
     "agent.task.models",
@@ -244,7 +248,7 @@ function bridgeScript(id, origin) {
       const requestId = String(++next);
       const timer = setTimeout(() => {
         pending.delete(requestId); reject(new Error("Panel request timed out"));
-      }, 60000);
+      }, method === "tasks.start" ? 30 * 60 * 1000 : 60000);
       pending.set(requestId, { resolve, reject, timer });
       try {
         parent.postMessage({ type: "codeshell-panel:call", instanceId: id, requestId, method, params }, origin);
@@ -288,7 +292,7 @@ function bridgeScript(id, origin) {
         call: ask,
         callResult: (method, params) => ask(method, params).then(value => ({ ok: true, value }), error => ({ ok: false, error: { code: error.code || "OPERATION_FAILED", message: error.message, ...(typeof error.retryAfterMs === "number" ? { retryAfterMs: error.retryAfterMs } : {}) } })),
         on: (name, listener) => {
-          if (!["context.changed", "process.output", "process.exit", "agent.task.changed", "media.job.changed"].includes(name) || typeof listener !== "function") {
+          if (!["context.changed", "process.output", "process.exit", "agent.task.changed", "tasks.changed", "media.job.changed"].includes(name) || typeof listener !== "function") {
             throw new Error("Invalid event listener");
           }
           let list = listeners.get(name);
@@ -364,10 +368,36 @@ export function createPanelRuntime(options) {
     let closed = false;
     let generation = 0;
     let nextGuest = 0;
+    let nextToolOwner = -1;
     const byGuest = new Map();
+    const directoryBookmarks = new PanelAppDirectoryBookmarks(join(options.dataDir, "panel-web-directory-bookmarks.json"));
+    const panelDataDirectory = (appId) => join(options.dataDir, "panel-data", appId, digest(Buffer.from(options.bindingCwd ?? options.cwd)).slice(0, 24));
+    const toolOwners = new Map();
+    const jobOwners = new Map();
+    let toolJobs;
+    async function installedToolApp(scope) {
+        if (closed || scope.projectPath !== (options.bindingCwd ?? options.cwd))
+            throw new PanelBridgeError("REVOKED", "Tool task workspace is unavailable");
+        const panel = (await snapshot()).panels.find((candidate) => candidate.id === scope.appId);
+        const app = (await installed()).find((candidate) => candidate.id === scope.appId);
+        if (!panel?.enabled ||
+            panel.revision !== scope.revision ||
+            !app?.permissions.includes("process") ||
+            !app.permissions.includes("resources"))
+            throw new PanelBridgeError("REVOKED", "Installed tool task is no longer authorized");
+        return app;
+    }
     const processes = new PanelAppProcessService({
         approvalScope: "guest",
         resolvePackageEntry: async (owner, name) => {
+            const taskScope = toolOwners.get(owner.guestId);
+            if (taskScope) {
+                const app = await installedToolApp(taskScope);
+                const entry = app.nativeEntries?.[name];
+                if (!entry)
+                    throw new PanelBridgeError("REVOKED", "Installed tool entry is unavailable");
+                return { path: join(app.installPath, entry.entry), sha256: entry.sha256 };
+            }
             const grant = byGuest.get(owner.guestId);
             const entry = grant?.app.nativeEntries?.[name];
             if (!grant ||
@@ -379,10 +409,15 @@ export function createPanelRuntime(options) {
         },
         extraPathDirectories: () => panelExecutableDirectories(join(options.dataDir, "panel-bin"), { home: homedir() }),
         isOwnerAuthorized: async (owner) => {
+            const taskScope = toolOwners.get(owner.guestId);
+            if (taskScope)
+                return !!(await installedToolApp(taskScope).catch(() => null));
             const grant = byGuest.get(owner.guestId);
             return !!grant && (await authorized(grant));
         },
         confirmExecution: async (input) => {
+            if (toolOwners.has(input.guestId))
+                return true;
             const grant = byGuest.get(input.guestId);
             return (!!grant &&
                 (await confirm(grant, `允许 ${input.appTitle} 运行 ${input.executable}？`, `程序将在服务端运行，可使用当前运行用户的文件与网络权限。\n程序：${input.executablePath}`)));
@@ -391,6 +426,11 @@ export function createPanelRuntime(options) {
     const resources = new PanelResourceService({
         rootDirectory: join(options.dataDir, "panel-app-media"),
         isScopeAuthorized: async (scope) => {
+            if (scope.projectPath === (options.bindingCwd ?? options.cwd)) {
+                const panel = (await snapshot()).panels.find((candidate) => candidate.id === scope.appId);
+                if (panel?.enabled && panel.permissions.includes("resources"))
+                    return true;
+            }
             for (const grant of grants.values())
                 if (grant.app.id === scope.appId &&
                     scope.projectPath === (options.bindingCwd ?? options.cwd) &&
@@ -407,6 +447,156 @@ export function createPanelRuntime(options) {
     }, 60_000);
     reaper.unref();
     const preparing = new Set();
+    const preparingTools = new Set();
+    async function dispatchToolJobs(grant, method, params) {
+        if (!grant.app.permissions.includes("process") || !grant.app.permissions.includes("resources"))
+            error(403, "原生后台任务需要 process 和 resources 权限。");
+        const scope = {
+            appId: grant.app.id,
+            projectPath: options.bindingCwd ?? options.cwd,
+            revision: grant.revision,
+        };
+        const input = (params ?? {});
+        const service = getToolJobs();
+        if (method === "tasks.start") {
+            const app = await installedToolApp(scope);
+            const entry = app.nativeEntries?.[input.entry ?? ""];
+            if (!entry)
+                error(501, "安装的原生工具不可用。");
+            if (!(await confirm(grant, `启动 ${grant.app.title.default} 的后台工具？`, input.entry)))
+                error(403, "你取消了后台工具执行。");
+            if (!(await authorized(grant)))
+                error(410, "面板授权已失效。");
+            const preparation = {
+                owner: grant.owner,
+                appId: scope.appId,
+                controller: new AbortController(),
+            };
+            preparingTools.add(preparation);
+            try {
+                const job = await service.start(scope, {
+                    entry: { name: input.entry, sha256: entry.sha256 },
+                    input: input.input,
+                    recovery: input.recovery ?? "manual",
+                    requestKey: input.requestKey,
+                }, preparation.controller.signal);
+                if (!jobOwners.has(job.id))
+                    jobOwners.set(job.id, { owner: grant.owner, scope });
+                if (!(await authorized(grant))) {
+                    if (jobOwners.get(job.id)?.owner === grant.owner)
+                        await service.cancel(scope, job.id);
+                    error(410, "登录授权已撤销。");
+                }
+                emitTaskEvent(await service.get(scope, job.id));
+                return job;
+            }
+            catch (cause) {
+                if (preparation.controller.signal.aborted)
+                    error(410, "登录授权已撤销，输入准备已取消。");
+                throw cause;
+            }
+            finally {
+                preparingTools.delete(preparation);
+            }
+        }
+        if (method === "tasks.list") {
+            const offset = input.offset ?? 0, limit = input.limit ?? 50;
+            if (!Number.isSafeInteger(offset) ||
+                offset < 0 ||
+                !Number.isSafeInteger(limit) ||
+                limit < 1 ||
+                limit > 50)
+                throw new PanelBridgeError("INVALID_ARGUMENT", "Invalid task page");
+            return (await service.list(scope))
+                .slice(offset, offset + limit)
+                .map((job) => toolSummary(job));
+        }
+        if (method === "tasks.get")
+            return service.get(scope, input.id);
+        if (method === "tasks.cancel")
+            return service.cancel(scope, input.id);
+        if (method === "tasks.retry") {
+            if (!(await confirm(grant, `重试 ${grant.app.title.default} 的后台工具？`, input.id ?? "")))
+                error(403, "你取消了后台工具重试。");
+            if (!(await authorized(grant)))
+                error(410, "面板授权已失效。");
+            const job = await service.retry(scope, input.id);
+            jobOwners.set(job.id, { owner: grant.owner, scope });
+            if (!(await authorized(grant))) {
+                await service.cancel(scope, job.id);
+                error(410, "登录授权已撤销，后台工具已取消。");
+            }
+            emitTaskEvent(await service.get(scope, job.id));
+            return job;
+        }
+        throw new PanelBridgeError("NOT_SUPPORTED", "Unknown tool task operation");
+    }
+    function toolSummary(job) {
+        const { input: _input, result: _result, ...summary } = job;
+        return summary;
+    }
+    function emitTaskEvent(job) {
+        const owner = jobOwners.get(job.id)?.owner;
+        if (!owner)
+            return;
+        for (const grant of grants.values())
+            if (grant.owner === owner &&
+                grant.app.id === job.scope.appId &&
+                grant.revision === job.scope.revision &&
+                grant.app.permissions.includes("process") &&
+                grant.app.permissions.includes("resources"))
+                emit(grant, "tasks.changed", toolSummary(job));
+        if (["succeeded", "failed", "cancelled", "interrupted"].includes(job.status))
+            jobOwners.delete(job.id);
+    }
+    function getToolJobs() {
+        if (toolJobs)
+            return toolJobs;
+        const executor = createPanelToolExecutor({
+            processes,
+            resources,
+            owner: (job, send) => {
+                const guestId = nextToolOwner--;
+                toolOwners.set(guestId, job.scope);
+                return {
+                    guestId,
+                    appId: job.scope.appId,
+                    appTitle: job.scope.appId,
+                    revision: job.scope.revision,
+                    send,
+                };
+            },
+            releaseOwner: (owner) => {
+                toolOwners.delete(owner.guestId);
+            },
+            authorize: async (scope) => {
+                await installedToolApp(scope);
+            },
+            authorizeConnections: async (scope) => {
+                const app = await installedToolApp(scope);
+                if (!app.permissions.includes("credentials.connections"))
+                    throw new PanelBridgeError("PERMISSION_DENIED", "Tool requires connection permission");
+            },
+            appDataDirectory: async (scope) => {
+                await installedToolApp(scope);
+                const path = panelDataDirectory(scope.appId);
+                await mkdir(path, { recursive: true, mode: 0o700 });
+                return path;
+            },
+            sealedRoot: join(options.dataDir, "panel-app-sealed"),
+        });
+        toolJobs = new PanelToolJobService({
+            // Desktop's IPC bridge has its own in-memory coordinator for panel-tool-jobs.
+            // A Desktop Web workspace must not open the same store concurrently.
+            rootDir: options.host === "desktop"
+                ? join(options.dataDir, "panel-web-tool-jobs", digest(Buffer.from(options.cwd)).slice(0, 24))
+                : join(options.dataDir, "panel-tool-jobs"),
+            ...executor,
+            isAuthorized: async (scope) => !!(await installedToolApp(scope).catch(() => null)),
+            onEvent: emitTaskEvent,
+        });
+        return toolJobs;
+    }
     let readingSnapshot;
     function snapshot() {
         // Parallel module requests share current disk work, without a stale TTL
@@ -570,12 +760,18 @@ export function createPanelRuntime(options) {
         };
     }
     function cancelOwner(owner) {
+        for (const preparation of preparingTools)
+            if (preparation.owner === owner)
+                preparation.controller.abort();
         for (const preparation of preparing)
             if (preparation.owner === owner)
                 preparation.cancelled = true;
         for (const grant of grants.values())
             if (grant.owner === owner)
                 remove(grant);
+        for (const [id, record] of jobOwners)
+            if (record.owner === owner)
+                void toolJobs?.cancel(record.scope, id).catch(() => { });
     }
     async function authorized(grant) {
         if (closed ||
@@ -661,23 +857,48 @@ export function createPanelRuntime(options) {
                 theme: input.theme === "dark" ? "dark" : "light",
                 locale: typeof input.locale === "string" ? input.locale.slice(0, 32) : "zh-CN",
                 apiVersion: panelRuntimeApiVersion,
-                capabilities: panelRuntimeCapabilities({
-                    process: app.permissions.includes("process"),
-                    resources: app.permissions.includes("resources") ? resources.capabilities() : undefined,
-                    limits: {
-                        maxParamsBytes: 3 * 1024 * 1024,
-                        maxResultBytes: 3 * 1024 * 1024,
-                        rateWindowMs: 60000,
-                        maxCallsPerWindow: 240,
-                        maxTransferCallsPerWindow: 2048,
-                        callTimeoutMs: 60000,
-                        consentTimeoutMs: 50000,
-                    },
-                }),
+                capabilities: {
+                    ...panelRuntimeCapabilities({
+                        process: app.permissions.includes("process"),
+                        resources: app.permissions.includes("resources") ? resources.capabilities() : undefined,
+                        tasks: app.permissions.includes("process") && app.permissions.includes("resources")
+                            ? {
+                                available: true,
+                                ...toolJobLimits,
+                                maxHttpResultBytes: toolJobLimits.maxRecordBytes + 128 * 1024,
+                            }
+                            : undefined,
+                        limits: {
+                            maxParamsBytes: 3 * 1024 * 1024,
+                            maxResultBytes: 3 * 1024 * 1024,
+                            rateWindowMs: 60000,
+                            maxCallsPerWindow: 240,
+                            maxTransferCallsPerWindow: 2048,
+                            callTimeoutMs: 60000,
+                            consentTimeoutMs: 50000,
+                        },
+                    }),
+                    ...(app.permissions.includes("process") && app.permissions.includes("resources")
+                        ? {
+                            methodLimits: {
+                                "tasks.start": {
+                                    maxParamsBytes: toolJobLimits.maxInputBytes,
+                                    maxResultBytes: toolJobLimits.maxRecordBytes + 128 * 1024,
+                                    timeoutMs: 30 * 60 * 1000,
+                                },
+                                "tasks.get": { maxResultBytes: toolJobLimits.maxRecordBytes + 128 * 1024 },
+                                "tasks.retry": { maxResultBytes: toolJobLimits.maxRecordBytes + 128 * 1024 },
+                                "tasks.cancel": { maxResultBytes: toolJobLimits.maxRecordBytes + 128 * 1024 },
+                            },
+                        }
+                        : {}),
+                },
                 host: options.host,
                 availableMethods: METHODS.filter((method) => {
                     if (method.startsWith("agent.task.") && !agentTasks)
                         return false;
+                    if (method.startsWith("tasks."))
+                        return app.permissions.includes("process") && app.permissions.includes("resources");
                     if ([
                         "resources.materialize",
                         "resources.capture",
@@ -767,6 +988,8 @@ export function createPanelRuntime(options) {
             grant.calls = history;
         if (method === "context.get")
             return grant.context;
+        if (method.startsWith("tasks."))
+            return dispatchToolJobs(grant, method, params);
         if (method.startsWith("tools.")) {
             const name = params?.name;
             if (typeof name !== "string" || !grant.app.agent?.tools.some((tool) => tool.name === name))
@@ -865,23 +1088,40 @@ export function createPanelRuntime(options) {
                     url: `${ROOT}${grant.id}/directory/${handle}`,
                 };
             }
+            if (method === "filesystem.restoreDirectory") {
+                const saved = directoryBookmarks.restore(grant.app.id, options.bindingCwd ?? options.cwd, params?.bookmark);
+                if (saved !== (await realpath(join(options.cwd, "downloads"))))
+                    throw new PanelBridgeError("PERMISSION_DENIED", "Saved server directory is unavailable");
+                const restored = await processes.grantDirectory(owner, saved);
+                directoryBookmarks.restore(grant.app.id, options.bindingCwd ?? options.cwd, params?.bookmark);
+                return { ...restored, bookmark: params.bookmark };
+            }
             const name = method === "filesystem.pickDirectory" ? "downloads" : params?.name;
-            const directory = name === "downloads"
-                ? join(options.cwd, "downloads")
-                : name === "user-bin"
-                    ? join(options.dataDir, "panel-bin")
-                    : name === "app-data"
-                        ? join(options.dataDir, "panel-data", grant.app.id, digest(Buffer.from(options.bindingCwd ?? options.cwd)).slice(0, 24))
-                        : undefined;
+            const directory = name === "project"
+                ? options.cwd
+                : name === "downloads"
+                    ? join(options.cwd, "downloads")
+                    : name === "user-bin"
+                        ? join(options.dataDir, "panel-bin")
+                        : name === "app-data"
+                            ? panelDataDirectory(grant.app.id)
+                            : undefined;
             if (!directory)
                 error(400, "不支持这个服务端目录。");
             if (method === "filesystem.pickDirectory" &&
                 !(await confirm(grant, "使用服务端下载目录？", directory)))
                 return null;
-            await mkdir(directory, { recursive: true, mode: 0o700 });
+            if (name !== "project")
+                await mkdir(directory, { recursive: true, mode: 0o700 });
             if (!(await authorized(grant)))
                 error(410, "面板授权已失效。");
-            return processes.grantDirectory(owner, directory);
+            const selected = await processes.grantDirectory(owner, directory);
+            if (method !== "filesystem.pickDirectory")
+                return selected;
+            const bookmark = directoryBookmarks.remember(grant.app.id, options.bindingCwd ?? options.cwd, selected.path);
+            if (!(await authorized(grant)))
+                error(410, "面板授权已失效。");
+            return { ...selected, bookmark };
         }
         if (["external.open", "agent.submitPrompt", "notifications.send"].includes(method)) {
             if (!grant.app.permissions.includes(method))
@@ -935,7 +1175,7 @@ export function createPanelRuntime(options) {
         }, method, params);
     }
     return {
-        activeTaskCount: () => agentTasks?.activeTaskCount?.() ?? 0,
+        activeTaskCount: () => (agentTasks?.activeTaskCount?.() ?? 0) + (toolJobs?.activeCount() ?? 0),
         async panelAction(ownerId, sessionId, input) {
             const candidates = [];
             for (const grant of grants.values()) {
@@ -967,20 +1207,36 @@ export function createPanelRuntime(options) {
         cancelOwner,
         invalidate(appId) {
             generation++;
+            for (const preparation of preparingTools)
+                if (!appId || preparation.appId === appId)
+                    preparation.controller.abort();
             for (const grant of grants.values())
                 if (!appId || grant.app.id === appId)
                     remove(grant);
+            if (!toolJobs)
+                return Promise.resolve();
+            const appIds = appId
+                ? [appId]
+                : [...new Set([...jobOwners.values()].map((record) => record.scope.appId))];
+            return Promise.all(appIds.map((id) => toolJobs.cancelApp(id))).then(() => undefined);
         },
-        close() {
+        async close() {
             closed = true;
+            for (const preparation of preparingTools)
+                preparation.controller.abort();
             clearInterval(reaper);
             for (const grant of grants.values())
                 remove(grant);
-            processes.close();
             assets.clear();
             for (const preparation of preparing)
                 preparation.cancelled = true;
-            return Promise.all([resources.shutdown(), Promise.resolve(agentTasks?.close())]).then(() => undefined);
+            try {
+                await toolJobs?.shutdown();
+            }
+            finally {
+                processes.close();
+                await Promise.all([resources.shutdown(), Promise.resolve(agentTasks?.close())]);
+            }
         },
         async handle(request, response) {
             const url = new URL(request.url ?? "/", "http://localhost");
@@ -1075,10 +1331,14 @@ export function createPanelRuntime(options) {
                     json(response, 200, { accepted: true });
                 }
                 else if (request.method === "POST" && match[2] === "call") {
-                    const value = await call(grant, await body(request));
+                    const input = await body(request);
+                    const value = await call(grant, input);
                     if (!(await authorized(grant)))
                         error(410, "面板授权已失效，请重新打开。");
-                    if (Buffer.byteLength(JSON.stringify(value) ?? "null") > 3 * 1024 * 1024)
+                    const resultLimit = typeof input.method === "string" && input.method.startsWith("tasks.")
+                        ? toolJobLimits.maxRecordBytes + 128 * 1024
+                        : 3 * 1024 * 1024;
+                    if (Buffer.byteLength(JSON.stringify(value) ?? "null") > resultLimit)
                         throw new PanelBridgeError("RESULT_TOO_LARGE", "Panel result exceeds the response limit");
                     json(response, 200, value);
                 }

package/dist/panels/tool-jobs.d.ts

@@ -78,6 +78,7 @@ export declare class PanelToolJobService {
     private pumping;
     private shutdownPromise?;
     constructor(options: PanelToolJobServiceOptions);
+    activeCount(): number;
     private now;
     private exclusive;
     private authorize;
@@ -91,7 +92,7 @@ export declare class PanelToolJobService {
     get(rawScope: ToolJobScope, id: string): Promise<ToolJob & {
         readOnly: boolean;
     }>;
-    start(rawScope: ToolJobScope, request: ToolJobRequest): Promise<ToolJob>;
+    start(rawScope: ToolJobScope, request: ToolJobRequest, signal?: AbortSignal): Promise<ToolJob>;
     private schedule;
     private pump;
     private run;

package/dist/panels/tool-jobs.js

@@ -110,6 +110,10 @@ export class PanelToolJobService {
         this.options = options;
         this.storage = new ToolJobStorage(options.rootDir);
     }
+    activeCount() {
+        return (this.preparing.size +
+            [...this.jobs.values()].filter((job) => !TERMINAL.has(job.status)).length);
+    }
     now() {
         return this.options.now?.() ?? Date.now();
     }
@@ -204,7 +208,8 @@ export class PanelToolJobService {
         const job = this.lookup(scope, id);
         return { ...publicJob(job), readOnly: job.scope.revision !== scope.revision };
     }
-    async start(rawScope, request) {
+    async start(rawScope, request, signal) {
+        signal?.throwIfAborted();
         const scope = scopeValue(rawScope);
         const entry = entryValue(request?.entry);
         if (!["manual", "retry"].includes(request.recovery))
@@ -228,6 +233,7 @@ export class PanelToolJobService {
         await this.authorize(scope);
         let done;
         const reservation = await this.exclusive(async () => {
+            signal?.throwIfAborted();
             if (this.stopping)
                 throw new Error("tool job service is shutting down");
             if (request.requestKey) {
@@ -264,8 +270,14 @@ export class PanelToolJobService {
         if (reservation.existing)
             return publicJob(reservation.existing);
         const { id, controller } = reservation;
+        const abort = () => controller.abort(signal?.reason);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
         try {
+            controller.signal.throwIfAborted();
             const workDir = await this.storage.directory(id, true, true);
+            controller.signal.throwIfAborted();
             const prepared = this.options.prepareInput
                 ? await this.options.prepareInput(scope, input, workDir, controller.signal)
                 : input;
@@ -292,6 +304,19 @@ export class PanelToolJobService {
                     [...this.jobs.values()].some((other) => sameScope(other.scope, scope) && other.requestKey === request.requestKey))
                     throw new Error("tool job request key is already being prepared");
                 await this.commit(job);
+                // Cancellation can arrive during the durable write. The serial fence
+                // prevents the scheduler from selecting this job before cancellation.
+                if (controller.signal.aborted) {
+                    job.status = "cancelled";
+                    job.completedAt = this.now();
+                    job.error = {
+                        code: "CANCELLED",
+                        message: "Task was cancelled before execution.",
+                        retryable: job.recovery === "retry",
+                    };
+                    await this.commit(job);
+                    controller.signal.throwIfAborted();
+                }
             });
             this.schedule();
             return publicJob(job);
@@ -303,6 +328,7 @@ export class PanelToolJobService {
             throw error;
         }
         finally {
+            signal?.removeEventListener("abort", abort);
             this.preparing.delete(id);
             done();
         }

package/dist/serve/headless-server.js

@@ -917,7 +917,7 @@ export async function startHeadlessServer(opts) {
         await mcp?.close();
         configuration?.close();
         links?.close();
-        panels?.close();
+        await panels?.close();
         files?.close();
         bridge.kill();
         wss.close();
@@ -947,7 +947,7 @@ export async function startHeadlessServer(opts) {
             await mcp?.close();
             configuration?.close();
             links?.close();
-            panels?.close();
+            await panels?.close();
             files?.close();
             for (const tab of tabs) {
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-server",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "CodeShell server transport layer — mobile remote HTTP/WS host, pairing, passcode gate, tunnel, rooms, uploads, and session/attachment services. Electron-free; precursor of the auth gateway.",
   "type": "module",
   "main": "./dist/index.js",
@@ -51,13 +51,13 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-capability-coding": "0.9.19",
-    "@cjhyy/code-shell-core": "0.9.19",
-    "@cjhyy/code-shell-web": "0.9.19",
+    "@cjhyy/code-shell-capability-coding": "0.9.21",
+    "@cjhyy/code-shell-core": "0.9.21",
+    "@cjhyy/code-shell-web": "0.9.21",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0",
-    "@cjhyy/code-shell-link": "0.9.19"
+    "@cjhyy/code-shell-link": "0.9.21"
   },
   "engines": {
     "node": ">=20.10"