@secure-exec/core 0.0.0-main.bccb3a2

package/dist/sidecar-client.js

@@ -0,0 +1,797 @@
+import { decodeGuestFilesystemContent, encodeGuestFilesystemContent, } from "./filesystem.js";
+import { DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY, DEFAULT_SIDECAR_FORCE_EXIT_MS, DEFAULT_SIDECAR_FRAME_TIMEOUT_MS, DEFAULT_SIDECAR_GRACEFUL_EXIT_MS, StdioSidecarProtocolClient, } from "./native-client.js";
+import { SIDECAR_PROTOCOL_SCHEMA } from "./protocol-schema.js";
+export { SidecarProcessError, SidecarProcessExited, } from "./process.js";
+export { SidecarEventBufferOverflow } from "./event-buffer.js";
+const BRIDGE_CONTRACT_VERSION = 1;
+export const NATIVE_SIDECAR_FRAME_TIMEOUT_MS = DEFAULT_SIDECAR_FRAME_TIMEOUT_MS;
+export class Sidecar {
+    protocolClient;
+    constructor(protocolClient) {
+        this.protocolClient = protocolClient;
+    }
+    static spawn(options = {}) {
+        const protocolClient = StdioSidecarProtocolClient.spawn({
+            command: options.command,
+            args: options.args ?? [],
+            cwd: options.cwd,
+            frameTimeoutMs: options.frameTimeoutMs ?? NATIVE_SIDECAR_FRAME_TIMEOUT_MS,
+            eventBufferCapacity: options.eventBufferCapacity ?? DEFAULT_SIDECAR_EVENT_BUFFER_CAPACITY,
+            gracefulExitMs: DEFAULT_SIDECAR_GRACEFUL_EXIT_MS,
+            forceExitMs: DEFAULT_SIDECAR_FORCE_EXIT_MS,
+            disposedErrorMessage: "native sidecar disposed",
+            payloadCodec: options.payloadCodec ?? "bare",
+        });
+        return new Sidecar(protocolClient);
+    }
+    setSidecarRequestHandler(handler) {
+        this.protocolClient.setSidecarRequestHandler(handler);
+    }
+    onEvent(handler) {
+        return this.protocolClient.onEvent(handler);
+    }
+    async authenticateAndOpenSession(sessionMetadata = {}) {
+        const authenticated = await this.sendRequest({
+            ownership: {
+                scope: "connection",
+                connection_id: "client-hint",
+            },
+            payload: {
+                type: "authenticate",
+                client_name: "secure-exec-core-client",
+                auth_token: "secure-exec-core-client-token",
+                protocol_version: SIDECAR_PROTOCOL_SCHEMA.version,
+                bridge_version: BRIDGE_CONTRACT_VERSION,
+            },
+        });
+        if (authenticated.payload.type !== "authenticated") {
+            throw new Error(`unexpected authenticate response: ${authenticated.payload.type}`);
+        }
+        const opened = await this.sendRequest({
+            ownership: {
+                scope: "connection",
+                connection_id: authenticated.payload.connection_id,
+            },
+            payload: {
+                type: "open_session",
+                placement: {
+                    kind: "shared",
+                    pool: null,
+                },
+                metadata: sessionMetadata,
+            },
+        });
+        if (opened.payload.type !== "session_opened") {
+            throw new Error(`unexpected open_session response: ${opened.payload.type}`);
+        }
+        return {
+            connectionId: authenticated.payload.connection_id,
+            sessionId: opened.payload.session_id,
+        };
+    }
+    async createVm(session, options) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "session",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+            },
+            payload: {
+                type: "create_vm",
+                runtime: options.runtime,
+                config: options.config,
+            },
+        });
+        if (response.payload.type !== "vm_created") {
+            throw new Error(`unexpected create_vm response: ${response.payload.type}`);
+        }
+        return {
+            vmId: response.payload.vm_id,
+        };
+    }
+    async extensionRequest(session, vm, envelope) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "ext",
+                envelope,
+            },
+        });
+        if (response.payload.type !== "ext_result") {
+            throw new Error(`unexpected ext response: ${response.payload.type}`);
+        }
+        return response.payload.envelope;
+    }
+    async configureVm(session, vm, options) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "configure_vm",
+                mounts: (options.mounts ?? []).map(toWireMountDescriptor),
+                software: (options.software ?? []).map(toWireSoftwareDescriptor),
+                permissions: toWirePermissionsPolicy(options.permissions),
+                module_access_cwd: options.moduleAccessCwd,
+                instructions: options.instructions ?? [],
+                projected_modules: (options.projectedModules ?? []).map(toWireProjectedModuleDescriptor),
+                command_permissions: options.commandPermissions ?? {},
+                ...(options.loopbackExemptPorts
+                    ? { loopback_exempt_ports: options.loopbackExemptPorts }
+                    : {}),
+            },
+        });
+        if (response.payload.type !== "vm_configured") {
+            throw new Error(`unexpected configure_vm response: ${response.payload.type}`);
+        }
+    }
+    async registerHostCallbacks(session, vm, registration) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "register_host_callbacks",
+                name: registration.name,
+                description: registration.description,
+                command_aliases: registration.commandAliases ?? [],
+                registry_command_aliases: registration.registryCommandAliases ?? [],
+                callbacks: Object.fromEntries(Object.entries(registration.callbacks).map(([callbackName, callback]) => [
+                    callbackName,
+                    {
+                        description: callback.description,
+                        input_schema: callback.inputSchema,
+                        ...(callback.timeoutMs !== undefined
+                            ? { timeout_ms: callback.timeoutMs }
+                            : {}),
+                        ...(callback.examples && callback.examples.length > 0
+                            ? {
+                                examples: callback.examples.map((example) => ({
+                                    description: example.description,
+                                    input: example.input,
+                                })),
+                            }
+                            : {}),
+                    },
+                ])),
+            },
+        });
+        if (response.payload.type !== "host_callbacks_registered") {
+            throw new Error(`unexpected register_host_callbacks response: ${response.payload.type}`);
+        }
+        return {
+            registration: response.payload.registration,
+            commandCount: response.payload.command_count,
+        };
+    }
+    async createLayer(session, vm) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "create_layer",
+            },
+        });
+        if (response.payload.type !== "layer_created") {
+            throw new Error(`unexpected create_layer response: ${response.payload.type}`);
+        }
+        return response.payload.layer_id;
+    }
+    async sealLayer(session, vm, layerId) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "seal_layer",
+                layer_id: layerId,
+            },
+        });
+        if (response.payload.type !== "layer_sealed") {
+            throw new Error(`unexpected seal_layer response: ${response.payload.type}`);
+        }
+        return response.payload.layer_id;
+    }
+    async importSnapshot(session, vm, entries) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "import_snapshot",
+                entries,
+            },
+        });
+        if (response.payload.type !== "snapshot_imported") {
+            throw new Error(`unexpected import_snapshot response: ${response.payload.type}`);
+        }
+        return response.payload.layer_id;
+    }
+    async exportSnapshot(session, vm, layerId) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "export_snapshot",
+                layer_id: layerId,
+            },
+        });
+        if (response.payload.type !== "snapshot_exported") {
+            throw new Error(`unexpected export_snapshot response: ${response.payload.type}`);
+        }
+        return response.payload.entries;
+    }
+    async createOverlay(session, vm, options) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "create_overlay",
+                mode: options.mode,
+                upper_layer_id: options.upperLayerId,
+                lower_layer_ids: options.lowerLayerIds,
+            },
+        });
+        if (response.payload.type !== "overlay_created") {
+            throw new Error(`unexpected create_overlay response: ${response.payload.type}`);
+        }
+        return response.payload.layer_id;
+    }
+    async bootstrapRootFilesystem(session, vm, entries) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "bootstrap_root_filesystem",
+                entries,
+            },
+        });
+        if (response.payload.type !== "root_filesystem_bootstrapped") {
+            throw new Error(`unexpected bootstrap_root_filesystem response: ${response.payload.type}`);
+        }
+    }
+    async snapshotRootFilesystem(session, vm) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "snapshot_root_filesystem",
+            },
+        });
+        if (response.payload.type !== "root_filesystem_snapshot") {
+            throw new Error(`unexpected snapshot_root_filesystem response: ${response.payload.type}`);
+        }
+        return response.payload.entries;
+    }
+    async readFile(session, vm, path) {
+        const response = await this.guestFilesystemCall(session, vm, {
+            operation: "read_file",
+            path,
+        });
+        return decodeGuestFilesystemContent(response);
+    }
+    async pread(session, vm, path, offset, length) {
+        const response = await this.guestFilesystemCall(session, vm, {
+            operation: "pread",
+            path,
+            offset,
+            len: length,
+        });
+        return decodeGuestFilesystemContent(response);
+    }
+    async writeFile(session, vm, path, content) {
+        const encoded = encodeGuestFilesystemContent(content);
+        await this.guestFilesystemCall(session, vm, {
+            operation: "write_file",
+            path,
+            content: encoded.content,
+            encoding: encoded.encoding,
+        });
+    }
+    async mkdir(session, vm, path, options) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: options?.recursive ? "mkdir" : "create_dir",
+            path,
+            recursive: options?.recursive ?? false,
+        });
+    }
+    async readdir(session, vm, path) {
+        const response = await this.guestFilesystemCall(session, vm, {
+            operation: "read_dir",
+            path,
+        });
+        return response.entries ?? [];
+    }
+    async exists(session, vm, path) {
+        const response = await this.guestFilesystemCall(session, vm, {
+            operation: "exists",
+            path,
+        });
+        return response.exists ?? false;
+    }
+    async stat(session, vm, path, options) {
+        const response = await this.guestFilesystemCall(session, vm, {
+            operation: options?.dereference === false ? "lstat" : "stat",
+            path,
+        });
+        if (!response.stat) {
+            throw new Error(`sidecar returned no stat payload for ${path}`);
+        }
+        return response.stat;
+    }
+    async lstat(session, vm, path) {
+        return this.stat(session, vm, path, { dereference: false });
+    }
+    async rename(session, vm, fromPath, toPath) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "rename",
+            path: fromPath,
+            destination_path: toPath,
+        });
+    }
+    async realpath(session, vm, path) {
+        const response = await this.guestFilesystemCall(session, vm, {
+            operation: "realpath",
+            path,
+        });
+        if (response.target === undefined) {
+            throw new Error(`sidecar returned no realpath payload for ${path}`);
+        }
+        return response.target;
+    }
+    async removeFile(session, vm, path) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "remove_file",
+            path,
+        });
+    }
+    async removeDir(session, vm, path) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "remove_dir",
+            path,
+        });
+    }
+    async symlink(session, vm, target, linkPath) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "symlink",
+            path: linkPath,
+            target,
+        });
+    }
+    async readLink(session, vm, path) {
+        const response = await this.guestFilesystemCall(session, vm, {
+            operation: "read_link",
+            path,
+        });
+        if (response.target === undefined) {
+            throw new Error(`sidecar returned no symlink target for ${path}`);
+        }
+        return response.target;
+    }
+    async link(session, vm, fromPath, toPath) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "link",
+            path: fromPath,
+            destination_path: toPath,
+        });
+    }
+    async chmod(session, vm, path, mode) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "chmod",
+            path,
+            mode,
+        });
+    }
+    async chown(session, vm, path, uid, gid) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "chown",
+            path,
+            uid,
+            gid,
+        });
+    }
+    async utimes(session, vm, path, atimeMs, mtimeMs) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "utimes",
+            path,
+            atime_ms: atimeMs,
+            mtime_ms: mtimeMs,
+        });
+    }
+    async truncate(session, vm, path, length) {
+        await this.guestFilesystemCall(session, vm, {
+            operation: "truncate",
+            path,
+            len: length,
+        });
+    }
+    async disposeVm(session, vm) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "dispose_vm",
+                reason: "requested",
+            },
+        });
+        if (response.payload.type !== "vm_disposed") {
+            throw new Error(`unexpected dispose_vm response: ${response.payload.type}`);
+        }
+    }
+    async execute(session, vm, options) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "execute",
+                process_id: options.processId,
+                args: options.args ?? [],
+                ...(options.command ? { command: options.command } : {}),
+                ...(options.runtime ? { runtime: options.runtime } : {}),
+                ...(options.entrypoint ? { entrypoint: options.entrypoint } : {}),
+                ...(options.env ? { env: options.env } : {}),
+                ...(options.cwd ? { cwd: options.cwd } : {}),
+                ...(options.wasmPermissionTier
+                    ? { wasm_permission_tier: options.wasmPermissionTier }
+                    : {}),
+            },
+        });
+        if (response.payload.type !== "process_started") {
+            throw new Error(`unexpected execute response: ${response.payload.type}`);
+        }
+        return {
+            pid: response.payload.pid ?? null,
+        };
+    }
+    async writeStdin(session, vm, processId, chunk) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "write_stdin",
+                process_id: processId,
+                chunk: typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk,
+            },
+        });
+        if (response.payload.type !== "stdin_written") {
+            throw new Error(`unexpected write_stdin response: ${response.payload.type}`);
+        }
+    }
+    async closeStdin(session, vm, processId) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "close_stdin",
+                process_id: processId,
+            },
+        });
+        if (response.payload.type !== "stdin_closed") {
+            throw new Error(`unexpected close_stdin response: ${response.payload.type}`);
+        }
+    }
+    async killProcess(session, vm, processId, signal = "SIGTERM") {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "kill_process",
+                process_id: processId,
+                signal,
+            },
+        });
+        if (response.payload.type !== "process_killed") {
+            throw new Error(`unexpected kill_process response: ${response.payload.type}`);
+        }
+    }
+    async findListener(session, vm, request) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "find_listener",
+                ...(request.host !== undefined ? { host: request.host } : {}),
+                ...(request.port !== undefined ? { port: request.port } : {}),
+                ...(request.path !== undefined ? { path: request.path } : {}),
+            },
+        });
+        if (response.payload.type !== "listener_snapshot") {
+            throw new Error(`unexpected find_listener response: ${response.payload.type}`);
+        }
+        return response.payload.listener
+            ? toSidecarSocketStateEntry(response.payload.listener)
+            : null;
+    }
+    async getProcessSnapshot(session, vm) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "get_process_snapshot",
+            },
+        });
+        if (response.payload.type !== "process_snapshot") {
+            throw new Error(`unexpected get_process_snapshot response: ${response.payload.type}`);
+        }
+        return response.payload.processes.map(toSidecarProcessSnapshotEntry);
+    }
+    async findBoundUdp(session, vm, request) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "find_bound_udp",
+                ...(request.host !== undefined ? { host: request.host } : {}),
+                ...(request.port !== undefined ? { port: request.port } : {}),
+            },
+        });
+        if (response.payload.type !== "bound_udp_snapshot") {
+            throw new Error(`unexpected find_bound_udp response: ${response.payload.type}`);
+        }
+        return response.payload.socket
+            ? toSidecarSocketStateEntry(response.payload.socket)
+            : null;
+    }
+    async vmFetch(session, vm, request) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "vm_fetch",
+                port: request.port,
+                method: request.method,
+                path: request.path,
+                headers_json: request.headersJson,
+                ...(request.body !== undefined ? { body: request.body } : {}),
+            },
+        });
+        if (response.payload.type !== "vm_fetch_result") {
+            throw new Error(`unexpected vm_fetch response: ${response.payload.type}`);
+        }
+        return response.payload.response_json;
+    }
+    async getSignalState(session, vm, processId) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "get_signal_state",
+                process_id: processId,
+            },
+        });
+        if (response.payload.type !== "signal_state") {
+            throw new Error(`unexpected get_signal_state response: ${response.payload.type}`);
+        }
+        return {
+            processId: response.payload.process_id,
+            handlers: new Map(Object.entries(response.payload.handlers).map(([signal, registration]) => [
+                Number(signal),
+                {
+                    action: registration.action,
+                    mask: [...registration.mask],
+                    flags: registration.flags,
+                },
+            ])),
+        };
+    }
+    async getZombieTimerCount(session, vm) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "get_zombie_timer_count",
+            },
+        });
+        if (response.payload.type !== "zombie_timer_count") {
+            throw new Error(`unexpected get_zombie_timer_count response: ${response.payload.type}`);
+        }
+        return {
+            count: response.payload.count,
+        };
+    }
+    async waitForEvent(matcher, timeoutMs, options) {
+        return await this.protocolClient.waitForEvent(matcher, timeoutMs, options);
+    }
+    async dispose() {
+        await this.protocolClient.dispose();
+    }
+    async sendRequest(input) {
+        return await this.protocolClient.sendRequest(input);
+    }
+    async guestFilesystemCall(session, vm, payload) {
+        const response = await this.sendRequest({
+            ownership: {
+                scope: "vm",
+                connection_id: session.connectionId,
+                session_id: session.sessionId,
+                vm_id: vm.vmId,
+            },
+            payload: {
+                type: "guest_filesystem_call",
+                ...payload,
+            },
+        });
+        if (response.payload.type !== "guest_filesystem_result") {
+            throw new Error(`unexpected guest_filesystem_call response: ${response.payload.type}`);
+        }
+        return response.payload;
+    }
+}
+function toSidecarSocketStateEntry(entry) {
+    return {
+        processId: entry.process_id,
+        ...(entry.host !== undefined ? { host: entry.host } : {}),
+        ...(entry.port !== undefined ? { port: entry.port } : {}),
+        ...(entry.path !== undefined ? { path: entry.path } : {}),
+    };
+}
+function toSidecarProcessSnapshotEntry(entry) {
+    return {
+        processId: entry.process_id,
+        pid: entry.pid,
+        ppid: entry.ppid,
+        pgid: entry.pgid,
+        sid: entry.sid,
+        driver: entry.driver,
+        command: entry.command,
+        args: [...(entry.args ?? [])],
+        cwd: entry.cwd,
+        status: entry.status,
+        exitCode: entry.exit_code ?? null,
+    };
+}
+function toWireRootFilesystemDescriptor(descriptor) {
+    if (!descriptor) {
+        return {};
+    }
+    return {
+        ...(descriptor.mode ? { mode: descriptor.mode } : {}),
+        ...(descriptor.disableDefaultBaseLayer !== undefined
+            ? { disable_default_base_layer: descriptor.disableDefaultBaseLayer }
+            : {}),
+        ...(descriptor.lowers
+            ? {
+                lowers: descriptor.lowers.map((lower) => lower.kind === "bundled_base_filesystem"
+                    ? { kind: "bundled_base_filesystem" }
+                    : {
+                        kind: "snapshot",
+                        entries: (lower.entries ?? []).map(toWireRootFilesystemEntry),
+                    }),
+            }
+            : {}),
+        ...(descriptor.bootstrapEntries
+            ? {
+                bootstrap_entries: descriptor.bootstrapEntries.map(toWireRootFilesystemEntry),
+            }
+            : {}),
+    };
+}
+function toWireRootFilesystemEntry(entry) {
+    return {
+        path: entry.path,
+        kind: entry.kind,
+        ...(entry.mode !== undefined ? { mode: entry.mode } : {}),
+        ...(entry.uid !== undefined ? { uid: entry.uid } : {}),
+        ...(entry.gid !== undefined ? { gid: entry.gid } : {}),
+        ...(entry.content !== undefined ? { content: entry.content } : {}),
+        ...(entry.encoding !== undefined ? { encoding: entry.encoding } : {}),
+        ...(entry.target !== undefined ? { target: entry.target } : {}),
+        ...(entry.executable !== undefined ? { executable: entry.executable } : {}),
+    };
+}
+function toWireMountDescriptor(descriptor) {
+    return {
+        guest_path: descriptor.guestPath,
+        read_only: descriptor.readOnly,
+        plugin: {
+            id: descriptor.plugin.id,
+            config: descriptor.plugin.config ?? {},
+        },
+    };
+}
+function toWireSoftwareDescriptor(descriptor) {
+    return {
+        package_name: descriptor.packageName,
+        root: descriptor.root,
+    };
+}
+function toWirePermissionsPolicy(policy) {
+    if (!policy) {
+        return undefined;
+    }
+    return {
+        fs: policy.fs,
+        network: policy.network,
+        child_process: policy.childProcess,
+        process: policy.process,
+        env: policy.env,
+        tool: policy.tool,
+    };
+}
+function toWireProjectedModuleDescriptor(descriptor) {
+    return {
+        package_name: descriptor.packageName,
+        entrypoint: descriptor.entrypoint,
+    };
+}