@cjhyy/code-shell-server 0.9.22 → 0.9.25

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/clone.d.ts

@@ -0,0 +1,13 @@
+/** Host-only optimization. Both paths are managed storage, never guest paths. */
+export declare function stageResourceClone(options: {
+    sourcePath: string;
+    stagingDirectory: string;
+    targetDevice: number;
+    verify(): Promise<void>;
+    signal?: AbortSignal;
+}): Promise<{
+    path: string;
+    handle: import("fs/promises").FileHandle;
+    verify: () => Promise<void>;
+    close: () => Promise<void>;
+} | undefined>;

package/dist/panels/resources/clone.js

@@ -0,0 +1,99 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { copyFile, lstat, mkdtemp, open, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { sameResourceIdentity } from "./directories.js";
+import { mediaSourceIdentity } from "./library.js";
+/** Host-only optimization. Both paths are managed storage, never guest paths. */
+export async function stageResourceClone(options) {
+    const { sourcePath, stagingDirectory, signal } = options;
+    signal?.throwIfAborted();
+    await options.verify();
+    signal?.throwIfAborted();
+    const source = await lstat(sourcePath);
+    if (!source.isFile() || source.isSymbolicLink())
+        throw new Error("Invalid resource clone source");
+    if (source.dev !== options.targetDevice || !["darwin", "linux"].includes(process.platform))
+        return undefined;
+    const staging = await lstat(stagingDirectory);
+    if (!staging.isDirectory() || staging.isSymbolicLink())
+        throw new Error("Invalid resource clone staging directory");
+    if (staging.dev !== source.dev)
+        return undefined;
+    const directory = await mkdtemp(join(stagingDirectory, "clone-"));
+    const identity = await lstat(directory);
+    const path = join(directory, "content");
+    let handle;
+    const verify = async () => {
+        signal?.throwIfAborted();
+        await options.verify();
+        const currentStaging = await lstat(stagingDirectory);
+        const currentDirectory = await lstat(directory);
+        const currentSource = await lstat(sourcePath);
+        if (!currentStaging.isDirectory() ||
+            currentStaging.isSymbolicLink() ||
+            !sameResourceIdentity(currentStaging, staging) ||
+            !currentDirectory.isDirectory() ||
+            currentDirectory.isSymbolicLink() ||
+            !sameResourceIdentity(currentDirectory, identity) ||
+            !currentSource.isFile() ||
+            currentSource.isSymbolicLink() ||
+            Object.entries(mediaSourceIdentity(source)).some(([key, value]) => currentSource[key] !== value))
+            throw new Error("Resource changed during clone");
+        signal?.throwIfAborted();
+    };
+    const close = async () => {
+        await handle?.close().catch(() => { });
+        handle = undefined;
+        const current = await lstat(directory).catch(() => undefined);
+        if (current?.isDirectory() && sameResourceIdentity(current, identity))
+            await rm(directory, { recursive: true, force: true }).catch(() => { });
+    };
+    try {
+        await verify();
+        try {
+            if (process.platform === "darwin") {
+                // Electron's Node/libuv does not implement FICLONE on macOS. The OS
+                // utility uses clonefile, with ordinary copy fallback on other volumes.
+                // Its target is fresh Host-private storage, outside the tool grant.
+                await new Promise((resolve, reject) => {
+                    const child = spawn("/bin/cp", ["-c", "-n", sourcePath, path], {
+                        stdio: "ignore",
+                        signal,
+                    });
+                    child.once("error", reject);
+                    child.once("close", (code) => {
+                        if (code === 0)
+                            resolve();
+                        else
+                            reject(new Error("Native resource clone failed"));
+                    });
+                });
+            }
+            else {
+                // FORCE prevents a failed Linux reflink from silently doing another
+                // full copy before the existing streaming fallback is used.
+                await copyFile(sourcePath, path, constants.COPYFILE_EXCL | constants.COPYFILE_FICLONE_FORCE);
+            }
+        }
+        catch (error) {
+            await verify();
+            if (process.platform !== "darwin" &&
+                !["ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EXDEV", "EINVAL"].includes(error.code ?? ""))
+                throw error;
+            await close();
+            return undefined;
+        }
+        await verify();
+        handle = await open(path, constants.O_RDWR | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+        const cloned = await handle.stat();
+        if (!cloned.isFile() || cloned.size !== source.size || sameResourceIdentity(cloned, source))
+            throw new Error("Invalid cloned resource");
+        await handle.chmod(0o600);
+        return { path, handle, verify, close };
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}

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/resources/service.js

@@ -2,7 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { link, lstat, open, rm } from "node:fs/promises";
 import { ResourceLibrary, mediaSourceIdentity } from "./library.js";
-import { mediaScopeKey, normalizeMediaScope } from "./storage.js";
+import { mediaDirectory, mediaScopeKey, normalizeMediaScope } from "./storage.js";
+import { stageResourceClone } from "./clone.js";
 import { openResourceDirectory, resourceRelativePath, sameResourceIdentity, } from "./directories.js";
 import { ResourceUploadIngest } from "./uploads.js";
 import { ExternalResourceReferences } from "./references.js";
@@ -138,43 +139,71 @@ export class PanelResourceService {
             await directory.close();
         }
     }
-    async materialize(scope, raw, context) {
+    async materialize(scope, raw, context, cloneManaged = true) {
         const input = object(raw, ["assetId", "directoryHandle", "path"]);
         const asset = await this.get(scope, assetId(input.assetId));
         const directory = await this.directory(scope, input, context, true);
-        const temporary = directory.location(`.${randomUUID()}.resource-partial`);
+        let temporary = directory.location(`.${randomUUID()}.resource-partial`);
+        let clone;
         let destination;
         let published = false;
         let identity;
         try {
             await directory.verify();
-            destination = await open(temporary, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 0o600);
+            if (cloneManaged && "sha256" in asset) {
+                const sourcePath = await this.library.resolvePath(scope, asset.id);
+                const stagingDirectory = await mediaDirectory(this.options.rootDirectory, [
+                    "scopes",
+                    mediaScopeKey(scope),
+                    "materialize",
+                ]);
+                clone = await stageResourceClone({
+                    sourcePath,
+                    stagingDirectory,
+                    targetDevice: directory.identities.at(-1).dev,
+                    verify: directory.verify,
+                    signal: context.signal,
+                });
+            }
+            if (clone) {
+                temporary = clone.path;
+                destination = clone.handle;
+            }
+            else {
+                destination = await open(temporary, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0), 0o600);
+            }
             identity = await destination.stat();
-            const source = await this.openRead(scope, asset.id, { signal: context.signal });
-            const hash = createHash("sha256");
-            let bytes = 0;
-            try {
-                for await (const chunk of source.body) {
-                    await directory.verify();
-                    if (bytes + chunk.length > asset.bytes)
-                        throw new Error("Resource content changed");
-                    hash.update(chunk);
-                    let offset = 0;
-                    while (offset < chunk.length) {
-                        const written = await destination.write(chunk, offset, chunk.length - offset, bytes + offset);
-                        if (!written.bytesWritten)
-                            throw new Error("Resource copy stopped making progress");
-                        offset += written.bytesWritten;
+            let sha256;
+            if (clone && "sha256" in asset) {
+                sha256 = asset.sha256;
+            }
+            else {
+                const source = await this.openRead(scope, asset.id, { signal: context.signal });
+                const hash = createHash("sha256");
+                let bytes = 0;
+                try {
+                    for await (const chunk of source.body) {
+                        await directory.verify();
+                        if (bytes + chunk.length > asset.bytes)
+                            throw new Error("Resource content changed");
+                        hash.update(chunk);
+                        let offset = 0;
+                        while (offset < chunk.length) {
+                            const written = await destination.write(chunk, offset, chunk.length - offset, bytes + offset);
+                            if (!written.bytesWritten)
+                                throw new Error("Resource copy stopped making progress");
+                            offset += written.bytesWritten;
+                        }
+                        bytes += chunk.length;
                     }
-                    bytes += chunk.length;
                 }
+                finally {
+                    source.body?.destroy();
+                }
+                sha256 = hash.digest("hex");
+                if (bytes !== asset.bytes || ("sha256" in asset && sha256 !== asset.sha256))
+                    throw new Error("Resource content failed integrity validation");
             }
-            finally {
-                source.body?.destroy();
-            }
-            const sha256 = hash.digest("hex");
-            if (bytes !== asset.bytes || ("sha256" in asset && sha256 !== asset.sha256))
-                throw new Error("Resource content failed integrity validation");
             await destination.sync();
             // A tool may share the granted directory. Verify the actual destination,
             // not only the source stream, before publishing the materialized file.
@@ -195,6 +224,7 @@ export class PanelResourceService {
                 verified.ctimeMs !== completed.ctimeMs ||
                 copiedHash.digest("hex") !== sha256)
                 throw new Error("Materialized resource failed integrity verification");
+            await clone?.verify();
             await destination.close();
             destination = undefined;
             await directory.verify();
@@ -213,15 +243,21 @@ export class PanelResourceService {
                 if (current && sameResourceIdentity(current, identity))
                     await rm(directory.path, { force: true }).catch(() => { });
             }
-            throw error;
+            // Different bind mounts can share st_dev yet refuse hard links. Retry
+            // with a temporary file inside the target grant, after releasing this
+            // private clone and all held descriptors in finally.
+            if (!(clone && !published && error.code === "EXDEV"))
+                throw error;
         }
         finally {
             await destination?.close().catch(() => { });
             const current = await lstat(temporary).catch(() => undefined);
             if (current && identity && sameResourceIdentity(current, identity))
                 await rm(temporary, { force: true }).catch(() => { });
+            await clone?.close();
             await directory.close();
         }
+        return this.materialize(scope, raw, context, false);
     }
     async capture(scope, raw, context) {
         const input = object(raw, [

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;