@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/plugins/runtime.js

@@ -0,0 +1,836 @@
+import { validateBeforeRequest, validateBeforeResult } from "./lifecycle/index.js";
+import { fork } from "node:child_process";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { PROVIDER_CAPABILITIES, requireProviderCapabilities, } from "@camerontaylor/paseo-plugin/server/provider";
+import { compilePlugin } from "./compiler.js";
+import { readPluginManifest } from "./manifest.js";
+import { assertPluginCompatibility } from "@camerontaylor/paseo-protocol/plugin-requirements";
+import { PluginProcessMessageSchema } from "./plugin-process-protocol.js";
+import { PluginSessionSocket } from "./session-socket.js";
+const CLIENT_ENTRY_FILENAMES = ["index.client.ts", "index.client.tsx"];
+const SERVER_ENTRY_FILENAMES = ["index.server.ts", "index.server.tsx"];
+const REQUEST_TIMEOUT_MS = 30000;
+const MAX_LOG_ENTRIES = 500;
+const MAX_LOG_BYTES = 256 * 1024;
+const MAX_LOG_LINE_BYTES = 16 * 1024;
+const SOFT_SHUTDOWN_TIMEOUT_MS = 2000;
+class PluginOutputCapture {
+    constructor(child, emit) {
+        this.emit = emit;
+        this.pending = new Map([
+            ["stdout", Buffer.alloc(0)],
+            ["stderr", Buffer.alloc(0)],
+        ]);
+        this.overflowed = new Set();
+        this.lastActivity = new Map();
+        this.activitySequence = 0;
+        this.flushed = false;
+        child.stdout?.on("data", (chunk) => this.write("stdout", chunk));
+        child.stderr?.on("data", (chunk) => this.write("stderr", chunk));
+        child.on("close", () => this.flush());
+    }
+    write(stream, chunk) {
+        if (this.flushed)
+            return;
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        let offset = 0;
+        while (offset < data.length) {
+            const newline = data.indexOf(0x0a, offset);
+            const end = newline === -1 ? data.length : newline;
+            this.append(stream, data.subarray(offset, end));
+            if (newline === -1)
+                return;
+            this.emitLine(stream);
+            offset = newline + 1;
+        }
+    }
+    append(stream, chunk) {
+        if (chunk.length > 0)
+            this.lastActivity.set(stream, ++this.activitySequence);
+        const current = this.pending.get(stream) ?? Buffer.alloc(0);
+        const remaining = MAX_LOG_LINE_BYTES - current.length;
+        if (chunk.length > remaining)
+            this.overflowed.add(stream);
+        if (remaining <= 0)
+            return;
+        this.pending.set(stream, Buffer.concat([current, chunk.subarray(0, remaining)]));
+    }
+    emitLine(stream) {
+        let line = this.pending.get(stream) ?? Buffer.alloc(0);
+        if (!this.overflowed.has(stream) && line.at(-1) === 0x0d)
+            line = line.subarray(0, -1);
+        this.emit(stream, line.toString("utf8"));
+        this.pending.set(stream, Buffer.alloc(0));
+        this.overflowed.delete(stream);
+        this.lastActivity.delete(stream);
+    }
+    flush() {
+        if (this.flushed)
+            return;
+        this.flushed = true;
+        const pendingStreams = ["stdout", "stderr"]
+            .filter((stream) => (this.pending.get(stream)?.length ?? 0) > 0 || this.overflowed.has(stream))
+            .sort((left, right) => (this.lastActivity.get(left) ?? 0) - (this.lastActivity.get(right) ?? 0));
+        for (const stream of pendingStreams) {
+            this.emitLine(stream);
+        }
+    }
+}
+function resolveWorkerUrl() {
+    return new URL(import.meta.url.endsWith(".ts") ? "./plugin-process.ts" : "./plugin-process.js", import.meta.url);
+}
+function resolveWorkerExecArgv() {
+    if (!import.meta.url.endsWith(".ts"))
+        return [];
+    const loaderUrl = new URL("../../terminal/terminal-ts-loader.mjs", import.meta.url).href;
+    const importSource = [
+        'import { register } from "node:module";',
+        'import { pathToFileURL } from "node:url";',
+        `register(${JSON.stringify(loaderUrl)}, pathToFileURL("./"));`,
+    ].join(" ");
+    return [
+        "--experimental-strip-types",
+        "--import",
+        `data:text/javascript,${encodeURIComponent(importSource)}`,
+    ];
+}
+function spawnPluginChild() {
+    return fork(fileURLToPath(resolveWorkerUrl()), [], {
+        execArgv: resolveWorkerExecArgv(),
+        serialization: "advanced",
+        stdio: ["ignore", "pipe", "pipe", "ipc"],
+    });
+}
+function terminatePluginChild(child) {
+    if (child.connected)
+        child.disconnect();
+    if (!child.killed)
+        child.kill();
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function jsonTransportValue(value) {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        throw new Error("Provider value is not JSON-serializable");
+    return JSON.parse(encoded);
+}
+function send(child, message) {
+    return new Promise((resolve, reject) => {
+        child.send(message, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function findEntry(directory, filenames) {
+    for (const filename of filenames) {
+        const filePath = path.join(directory, filename);
+        const info = await stat(filePath).catch(() => null);
+        if (info?.isFile())
+            return filePath;
+    }
+    return null;
+}
+async function resolveEntryPaths(directory) {
+    const [client, server] = await Promise.all([
+        findEntry(directory, CLIENT_ENTRY_FILENAMES),
+        findEntry(directory, SERVER_ENTRY_FILENAMES),
+    ]);
+    if (client || server)
+        return { client, server };
+    const legacyEntry = await findEntry(directory, ["index.ts", "index.tsx"]);
+    if (legacyEntry) {
+        throw new Error("This plugin was made for an older version of Paseo and cannot run on Paseo v0.8. Ask its author to update it. Plugin authors can follow the migration guide: https://paseo.sh/docs/plugins/v0.8/migration");
+    }
+    throw new Error(`Plugin entry points are missing: expected ${CLIENT_ENTRY_FILENAMES.join(" or ")} and/or ${SERVER_ENTRY_FILENAMES.join(" or ")} in ${directory}`);
+}
+export class PluginRuntime {
+    constructor(logger, daemonVersion, dependencies = {}) {
+        this.daemonVersion = daemonVersion;
+        this.dependencies = dependencies;
+        this.plugins = new Map();
+        this.logTails = new Map();
+        this.listeners = new Set();
+        this.logger = logger.child({ module: "plugins" });
+        this.spawnChild = dependencies.spawnChild ?? spawnPluginChild;
+        this.sessionHost = dependencies.sessionHost ?? null;
+    }
+    bindPaseoSessionHost(sessionHost) {
+        if (this.plugins.size > 0)
+            throw new Error("Cannot replace the plugin session host while running");
+        this.sessionHost = sessionHost;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async startPlugin(pluginId, configuredPath, canPublish = () => true) {
+        if (this.plugins.has(pluginId))
+            throw new Error(`Plugin is already running: ${pluginId}`);
+        this.appendLog(pluginId, "stdout", "[paseo] Loading plugin");
+        const loaded = await this.loadDirectoryPlugin(pluginId, configuredPath).catch((error) => {
+            this.appendLog(pluginId, "stderr", `[paseo] Plugin failed to load: ${describeError(error)}`);
+            throw error;
+        });
+        if (!canPublish()) {
+            await this.stopPlugin(loaded);
+            throw new Error(`Plugin start cancelled: ${pluginId}`);
+        }
+        this.plugins.set(pluginId, loaded);
+        this.appendLog(pluginId, "stdout", "[paseo] Plugin ready");
+    }
+    async validatePlugin(configuredPath) {
+        const directory = path.resolve(configuredPath);
+        const manifest = await readPluginManifest(directory);
+        assertPluginCompatibility({ ...manifest, version: this.daemonVersion, runtime: "daemon" });
+        const entryPaths = await resolveEntryPaths(directory);
+        await compilePlugin(entryPaths);
+    }
+    async stopPluginById(pluginId) {
+        const loaded = this.plugins.get(pluginId);
+        if (!loaded)
+            return false;
+        this.plugins.delete(pluginId);
+        this.rejectPending(loaded, `Plugin stopped: ${pluginId}`);
+        await this.stopPlugin(loaded);
+        return true;
+    }
+    catalog() {
+        return [...this.plugins.values()]
+            .map(({ id, clientBundle, requirements }) => ({ id, clientBundle, requirements }))
+            .sort((left, right) => left.id.localeCompare(right.id));
+    }
+    getProviderRegistrations(pluginId) {
+        return this.plugins.get(pluginId)?.providers ?? [];
+    }
+    async connectProvider(pluginId, providerId, request) {
+        const loaded = this.plugins.get(pluginId);
+        if (!loaded?.child)
+            throw new Error(`Plugin is not available: ${pluginId}`);
+        if (!loaded.providers.some((provider) => provider.id === providerId)) {
+            throw new Error(`Plugin ${pluginId} does not contribute provider ${providerId}`);
+        }
+        const connectionId = randomUUID();
+        let resolveConnected;
+        let rejectConnected;
+        let resolveClosed;
+        let rejectClosed;
+        const connected = new Promise((resolve, reject) => {
+            resolveConnected = resolve;
+            rejectConnected = reject;
+        });
+        const closed = new Promise((resolve, reject) => {
+            resolveClosed = resolve;
+            rejectClosed = reject;
+        });
+        void closed.catch(() => undefined);
+        const state = {
+            request,
+            capabilities: [],
+            listeners: new Set(),
+            pendingSends: new Map(),
+            sessions: new Map(),
+            connected: false,
+            closed: false,
+            closedPromise: closed,
+            resolveConnected,
+            rejectConnected,
+            resolveClosed,
+            rejectClosed,
+        };
+        loaded.providerConnections.set(connectionId, state);
+        const timeout = setTimeout(() => {
+            if (state.connected)
+                return;
+            this.abandonProviderConnect(loaded, connectionId, state, new Error(`Plugin provider connection timed out: ${pluginId}.${providerId}`));
+        }, REQUEST_TIMEOUT_MS);
+        void send(loaded.child, {
+            type: "provider.connect",
+            providerId,
+            connectionId,
+            request,
+        }).catch((error) => {
+            clearTimeout(timeout);
+            this.abandonProviderConnect(loaded, connectionId, state, error);
+        });
+        return connected.finally(() => clearTimeout(timeout));
+    }
+    getLogs(pluginId) {
+        return (this.logTails.get(pluginId)?.entries.map((entry) => ({
+            sequence: entry.sequence,
+            timestamp: entry.timestamp,
+            stream: entry.stream,
+            message: entry.message,
+        })) ?? []);
+    }
+    clearLogs(pluginId) {
+        this.logTails.delete(pluginId);
+    }
+    async invoke(pluginId, method, input) {
+        const loaded = this.plugins.get(pluginId);
+        if (!loaded)
+            throw new Error(`Plugin is not available: ${pluginId}`);
+        if (!loaded.methods.has(method))
+            throw new Error(`Plugin ${pluginId} does not contribute RPC ${method}`);
+        return this.request(loaded, { type: "invoke", requestId: randomUUID(), method, input });
+    }
+    emit(name, event) {
+        for (const loaded of this.plugins.values()) {
+            if (!loaded.hooks.events.includes(name)) {
+                continue;
+            }
+            void this.request(loaded, {
+                type: "hook",
+                requestId: randomUUID(),
+                kind: "event",
+                name,
+                input: event,
+            }).catch((error) => {
+                this.appendLog(loaded.id, "stderr", `Lifecycle hook ${name} failed: ${describeError(error)}`);
+            });
+        }
+    }
+    async before(name, input) {
+        let request = validateBeforeRequest(name, input);
+        const plugins = [...this.plugins.values()].sort((left, right) => {
+            return left.id.localeCompare(right.id);
+        });
+        for (const loaded of plugins) {
+            if (!loaded.hooks.before.includes(name)) {
+                continue;
+            }
+            try {
+                const output = await this.request(loaded, {
+                    type: "hook",
+                    requestId: randomUUID(),
+                    kind: "before",
+                    name,
+                    input: request,
+                });
+                request = validateBeforeResult(name, request, output);
+            }
+            catch (error) {
+                throw new Error(`Plugin ${loaded.id} before ${name} failed: ${describeError(error)}`, {
+                    cause: error,
+                });
+            }
+        }
+        return request;
+    }
+    async getProviderCatalogCacheKey(pluginId, providerId, options) {
+        const loaded = this.plugins.get(pluginId);
+        if (!loaded)
+            throw new Error(`Plugin is not available: ${pluginId}`);
+        const output = await this.request(loaded, {
+            type: "provider.catalog_key",
+            requestId: randomUUID(),
+            providerId,
+            options,
+        });
+        if (output !== undefined && typeof output !== "string")
+            throw new Error("Invalid catalogue key from plugin");
+        return output;
+    }
+    request(loaded, message) {
+        const child = loaded.child;
+        const pluginId = loaded.id;
+        if (!child)
+            throw new Error(`Plugin ${pluginId} has no server entry`);
+        const requestId = message.requestId;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                loaded.pending.delete(requestId);
+                if (message.type === "hook") {
+                    void send(child, { type: "hook.cancel", requestId }).catch(() => { });
+                }
+                reject(new Error(`Plugin RPC timed out: ${pluginId}.${message.type}`));
+            }, REQUEST_TIMEOUT_MS);
+            loaded.pending.set(requestId, { resolve, reject, timeout });
+            void send(child, message).catch((error) => {
+                clearTimeout(timeout);
+                loaded.pending.delete(requestId);
+                reject(error);
+            });
+        });
+    }
+    async stopAll() {
+        const loaded = [...this.plugins.values()];
+        this.plugins.clear();
+        for (const plugin of loaded) {
+            this.rejectPending(plugin, `Plugin stopped: ${plugin.id}`);
+        }
+        await Promise.all(loaded.map((plugin) => this.stopPlugin(plugin)));
+    }
+    async loadDirectoryPlugin(pluginId, configuredPath) {
+        const directory = path.resolve(configuredPath);
+        const manifest = await readPluginManifest(directory);
+        assertPluginCompatibility({ ...manifest, version: this.daemonVersion, runtime: "daemon" });
+        const entryPaths = await resolveEntryPaths(directory);
+        const bundles = await compilePlugin(entryPaths);
+        const serverBundle = bundles.serverBundle;
+        if (!serverBundle) {
+            return {
+                id: pluginId,
+                clientBundle: bundles.clientBundle ?? "",
+                requirements: manifest.requirements,
+                methods: new Set(),
+                hooks: { events: [], before: [] },
+                providers: [],
+                child: null,
+                outputCapture: null,
+                pending: new Map(),
+                providerConnections: new Map(),
+                providerConnectionTombstones: new Set(),
+                sessionSocket: null,
+                sessionClosed: null,
+            };
+        }
+        const sessionHost = this.sessionHost;
+        if (!sessionHost)
+            throw new Error("Plugin Paseo session host is not attached");
+        const child = this.spawnChild();
+        const outputCapture = new PluginOutputCapture(child, (stream, message) => {
+            this.appendLog(pluginId, stream, message);
+        });
+        const sessionSocket = new PluginSessionSocket(child);
+        const pending = new Map();
+        const sessionAttachment = await sessionHost
+            .attachPluginSocket(pluginId, sessionSocket)
+            .catch((error) => {
+            terminatePluginChild(child);
+            throw error;
+        });
+        let loaded = null;
+        let ready;
+        try {
+            ready = await new Promise((resolve, reject) => {
+                let settled = false;
+                const timeout = setTimeout(() => fail(new Error(`Plugin ${pluginId} did not initialize`)), REQUEST_TIMEOUT_MS);
+                const fail = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timeout);
+                    reject(error);
+                };
+                child.on("message", (rawMessage) => {
+                    const parsed = PluginProcessMessageSchema.safeParse(rawMessage);
+                    if (!parsed.success) {
+                        const error = new Error(`Plugin ${pluginId} sent an invalid message: ${parsed.error.message}`);
+                        if (loaded)
+                            this.handleMalformedChildMessage(loaded, rawMessage, error);
+                        else
+                            fail(error);
+                        return;
+                    }
+                    const message = parsed.data;
+                    if (message.type === "paseo_frame") {
+                        sessionSocket.receive(message.data, message.isBinary);
+                    }
+                    else if (message.type === "paseo_close") {
+                        sessionSocket.peerClosed();
+                    }
+                    else if (message.type === "ready") {
+                        if (settled)
+                            return;
+                        settled = true;
+                        clearTimeout(timeout);
+                        resolve(message);
+                    }
+                    else if (message.type === "fatal") {
+                        fail(new Error(message.error));
+                    }
+                    else if (loaded) {
+                        this.handleChildMessage(loaded, message);
+                    }
+                });
+                child.on("close", () => {
+                    sessionSocket.peerClosed();
+                    if (!loaded) {
+                        fail(new Error(`Plugin ${pluginId} exited during initialization`));
+                        return;
+                    }
+                    void this.handleChildClose(loaded);
+                });
+                void send(child, {
+                    type: "initialize",
+                    pluginId,
+                    appVersion: this.daemonVersion,
+                    bundle: serverBundle,
+                    settingsDirectory: this.dependencies.settingsDirectory
+                        ? path.join(this.dependencies.settingsDirectory, pluginId)
+                        : undefined,
+                }).catch(fail);
+            });
+        }
+        catch (error) {
+            sessionSocket.close();
+            await sessionAttachment.closed;
+            terminatePluginChild(child);
+            throw error;
+        }
+        loaded = {
+            id: pluginId,
+            clientBundle: bundles.clientBundle ?? "",
+            requirements: manifest.requirements,
+            methods: new Set(ready.methods),
+            hooks: ready.hooks ?? { events: [], before: [] },
+            providers: ready.providers ?? [],
+            child,
+            outputCapture,
+            pending,
+            providerConnections: new Map(),
+            providerConnectionTombstones: new Set(),
+            sessionSocket,
+            sessionClosed: sessionAttachment.closed,
+        };
+        this.logger.info({ pluginId, methods: ready.methods, providers: ready.providers }, "Loaded plugin");
+        return loaded;
+    }
+    handleChildMessage(loaded, message) {
+        if (message.type === "hooks.changed") {
+            loaded.hooks = message.hooks;
+            return;
+        }
+        if (message.type === "settings.changed") {
+            this.dependencies.onSettingsChanged?.(loaded.id, message.settingsId);
+            return;
+        }
+        if (message.type.startsWith("provider.")) {
+            this.handleProviderMessage(loaded, message);
+            return;
+        }
+        if (message.type !== "result" && message.type !== "error")
+            return;
+        const pending = loaded.pending.get(message.requestId);
+        if (!pending)
+            return;
+        loaded.pending.delete(message.requestId);
+        clearTimeout(pending.timeout);
+        if (message.type === "result")
+            pending.resolve(message.output);
+        else
+            pending.reject(new Error(message.error));
+    }
+    handleProviderMessage(loaded, message) {
+        if (!("connectionId" in message))
+            return;
+        const state = loaded.providerConnections.get(message.connectionId);
+        if (!state) {
+            if (!loaded.providerConnectionTombstones.has(message.connectionId))
+                return;
+            if (message.type === "provider.connected" && loaded.child?.connected) {
+                void send(loaded.child, {
+                    type: "provider.close",
+                    connectionId: message.connectionId,
+                }).catch(() => undefined);
+            }
+            if (message.type === "provider.closed" || message.type === "provider.connect_failed") {
+                loaded.providerConnectionTombstones.delete(message.connectionId);
+            }
+            return;
+        }
+        if (message.type === "provider.connected") {
+            this.finishProviderConnect(loaded, message.connectionId, state, message);
+            return;
+        }
+        if (message.type === "provider.connect_failed") {
+            this.abandonProviderConnect(loaded, message.connectionId, state, new Error(message.error));
+            return;
+        }
+        if (message.type === "provider.accepted" || message.type === "provider.rejected") {
+            const pending = state.pendingSends.get(message.acceptanceId);
+            if (!pending)
+                return;
+            state.pendingSends.delete(message.acceptanceId);
+            if (message.type === "provider.accepted") {
+                this.trackAcceptedProviderInput(state, pending.input);
+                pending.resolve();
+            }
+            else
+                pending.reject(new Error(message.error));
+            return;
+        }
+        if (message.type === "provider.event") {
+            this.publishProviderEvent(loaded, message.connectionId, state, message.event);
+            return;
+        }
+        if (message.type === "provider.closed") {
+            loaded.providerConnections.delete(message.connectionId);
+            if (message.error) {
+                this.failRemoteProviderConnection(state, new Error(message.error));
+                return;
+            }
+            state.closed = true;
+            this.rejectProviderSends(state, "Provider connection closed");
+            state.resolveClosed();
+        }
+    }
+    finishProviderConnect(loaded, connectionId, state, message) {
+        if (!Number.isInteger(message.version) || message.version < 1) {
+            this.abandonProviderConnect(loaded, connectionId, state, new Error(`Plugin provider selected invalid version: ${message.version}`));
+            return;
+        }
+        if (!state.request.versions.includes(message.version)) {
+            this.abandonProviderConnect(loaded, connectionId, state, new Error(`Plugin provider selected an unoffered version: ${message.version}`));
+            return;
+        }
+        const knownCapabilities = new Set(PROVIDER_CAPABILITIES);
+        const invalidCapability = message.capabilities.find((capability) => knownCapabilities.has(capability) && !state.request.capabilities.includes(capability));
+        if (invalidCapability) {
+            this.abandonProviderConnect(loaded, connectionId, state, new Error(`Plugin provider selected an unoffered capability: ${invalidCapability}`));
+            return;
+        }
+        const capabilities = PROVIDER_CAPABILITIES.filter((capability) => message.capabilities.includes(capability));
+        const connection = {
+            version: message.version,
+            capabilities,
+            send: (input) => this.sendProviderInput(loaded, connectionId, state, input),
+            onEvent(listener) {
+                state.listeners.add(listener);
+                return () => state.listeners.delete(listener);
+            },
+            close: () => this.closeProviderConnection(loaded, connectionId, state),
+        };
+        state.capabilities = capabilities;
+        state.connected = true;
+        state.resolveConnected(connection);
+    }
+    abandonProviderConnect(loaded, connectionId, state, error) {
+        if (state.connected || state.closed)
+            return;
+        loaded.providerConnections.delete(connectionId);
+        loaded.providerConnectionTombstones.add(connectionId);
+        state.closed = true;
+        state.rejectConnected(error);
+        state.rejectClosed(error);
+        if (loaded.child?.connected) {
+            void send(loaded.child, { type: "provider.close", connectionId }).catch(() => undefined);
+        }
+    }
+    sendProviderInput(loaded, connectionId, state, input) {
+        if (state.closed)
+            return Promise.reject(new Error("Provider connection is closed"));
+        try {
+            if (input.type === "session.open" || !("sessionId" in input)) {
+                requireProviderCapabilities(state.capabilities, input);
+            }
+            else {
+                const capabilities = state.sessions.get(input.sessionId);
+                if (!capabilities)
+                    throw new Error(`Unknown provider session: ${input.sessionId}`);
+                requireProviderCapabilities(capabilities, input);
+            }
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const child = loaded.child;
+        if (!child)
+            return Promise.reject(new Error(`Plugin has no server entry: ${loaded.id}`));
+        const acceptanceId = randomUUID();
+        return new Promise((resolve, reject) => {
+            state.pendingSends.set(acceptanceId, { input, resolve, reject });
+            void send(child, {
+                type: "provider.send",
+                connectionId,
+                acceptanceId,
+                input: jsonTransportValue(input),
+            }).catch((error) => {
+                state.pendingSends.delete(acceptanceId);
+                reject(error);
+            });
+        });
+    }
+    async closeProviderConnection(loaded, connectionId, state) {
+        if (state.closed)
+            return;
+        const child = loaded.child;
+        if (!child)
+            throw new Error(`Plugin has no server entry: ${loaded.id}`);
+        await send(child, { type: "provider.close", connectionId });
+        await state.closedPromise;
+    }
+    publishProviderEvent(loaded, connectionId, state, event) {
+        if (event.type === "timeline.item" &&
+            event.item.type === "plugin" &&
+            event.item.pluginId !== loaded.id) {
+            this.failProviderConnection(loaded, connectionId, state, new Error(`Provider plugin ${loaded.id} cannot emit timeline items for ${event.item.pluginId}`));
+            return;
+        }
+        if (event.type === "session.opened") {
+            const knownCapabilities = new Set(PROVIDER_CAPABILITIES);
+            const invalidCapability = event.capabilities.find((capability) => knownCapabilities.has(capability) && !state.capabilities.includes(capability));
+            if (invalidCapability) {
+                this.failProviderConnection(loaded, connectionId, state, new Error(`Provider session selected an unoffered capability: ${invalidCapability}`));
+                return;
+            }
+            const selectedCapabilities = event.capabilities;
+            event = {
+                ...event,
+                capabilities: PROVIDER_CAPABILITIES.filter((capability) => selectedCapabilities.includes(capability)),
+            };
+            if (event.parentSessionId &&
+                !state.sessions.get(event.parentSessionId)?.includes("session.subsession")) {
+                this.failProviderConnection(loaded, connectionId, state, new Error(`Provider parent session did not negotiate session.subsession`));
+                return;
+            }
+        }
+        if (event.type === "session.opened") {
+            state.sessions.set(event.sessionId, event.capabilities);
+        }
+        for (const listener of state.listeners)
+            listener(event);
+        if (event.type === "session.closed")
+            state.sessions.delete(event.sessionId);
+    }
+    failProviderConnection(loaded, connectionId, state, error) {
+        loaded.providerConnections.delete(connectionId);
+        this.failRemoteProviderConnection(state, error);
+        if (loaded.child?.connected) {
+            void send(loaded.child, { type: "provider.close", connectionId }).catch(() => undefined);
+        }
+    }
+    trackAcceptedProviderInput(state, input) {
+        if (input.type === "session.open" && !state.sessions.has(input.sessionId)) {
+            state.sessions.set(input.sessionId, []);
+        }
+        if (input.type === "session.close")
+            state.sessions.delete(input.sessionId);
+    }
+    handleMalformedChildMessage(loaded, rawMessage, error) {
+        const connectionId = readConnectionId(rawMessage);
+        const state = connectionId ? loaded.providerConnections.get(connectionId) : undefined;
+        if (!connectionId || !state) {
+            this.appendLog(loaded.id, "stderr", `[paseo] ${error.message}`);
+            terminatePluginChild(loaded.child);
+            return;
+        }
+        this.failProviderConnection(loaded, connectionId, state, error);
+    }
+    failRemoteProviderConnection(state, error) {
+        if (state.closed)
+            return;
+        for (const sessionId of state.sessions.keys()) {
+            const event = {
+                type: "session.runtime_failed",
+                sessionId,
+                error: { message: error.message },
+            };
+            for (const listener of state.listeners)
+                listener(event);
+        }
+        state.closed = true;
+        state.rejectConnected(error);
+        this.rejectProviderSends(state, error.message);
+        state.rejectClosed(error);
+    }
+    rejectProviderSends(state, message) {
+        for (const pending of state.pendingSends.values())
+            pending.reject(new Error(message));
+        state.pendingSends.clear();
+    }
+    async handleChildClose(loaded) {
+        loaded.sessionSocket?.peerClosed();
+        const wasPublished = this.plugins.get(loaded.id) === loaded;
+        if (wasPublished) {
+            this.plugins.delete(loaded.id);
+        }
+        this.rejectPending(loaded, `Plugin process exited: ${loaded.id}`);
+        for (const state of loaded.providerConnections.values()) {
+            this.failRemoteProviderConnection(state, new Error(`Plugin process exited: ${loaded.id}`));
+        }
+        loaded.providerConnections.clear();
+        await loaded.sessionClosed;
+        if (wasPublished)
+            this.notify(loaded.id, `Plugin process exited: ${loaded.id}`);
+    }
+    async stopPlugin(loaded) {
+        this.appendLog(loaded.id, "stdout", "[paseo] Stopping plugin");
+        for (const [connectionId, state] of loaded.providerConnections) {
+            if (state.connected)
+                continue;
+            this.abandonProviderConnect(loaded, connectionId, state, new Error(`Plugin stopped: ${loaded.id}`));
+        }
+        const { child, sessionSocket, sessionClosed } = loaded;
+        if (!child || !sessionSocket || !sessionClosed) {
+            this.appendLog(loaded.id, "stdout", "[paseo] Plugin stopped");
+            return;
+        }
+        if (child.killed) {
+            sessionSocket.peerClosed();
+            await sessionClosed;
+            this.appendLog(loaded.id, "stdout", "[paseo] Plugin stopped");
+            return;
+        }
+        const closed = new Promise((resolve) => child.on("close", () => {
+            resolve();
+        }));
+        if (child.connected) {
+            await send(child, { type: "shutdown" }).catch(() => undefined);
+        }
+        let forceTimer = setTimeout(() => {
+            if (!child.killed)
+                child.kill("SIGTERM");
+            forceTimer = setTimeout(() => {
+                child.kill("SIGKILL");
+            }, SOFT_SHUTDOWN_TIMEOUT_MS);
+        }, SOFT_SHUTDOWN_TIMEOUT_MS);
+        await closed.finally(() => {
+            if (forceTimer)
+                clearTimeout(forceTimer);
+        });
+        sessionSocket.peerClosed();
+        await sessionClosed;
+        this.appendLog(loaded.id, "stdout", "[paseo] Plugin stopped");
+    }
+    rejectPending(loaded, message) {
+        for (const invocation of loaded.pending.values()) {
+            clearTimeout(invocation.timeout);
+            invocation.reject(new Error(message));
+        }
+        loaded.pending.clear();
+    }
+    appendLog(pluginId, stream, message) {
+        const boundedMessage = Buffer.from(message).subarray(0, MAX_LOG_LINE_BYTES).toString("utf8");
+        let tail = this.logTails.get(pluginId);
+        if (!tail) {
+            tail = { entries: [], bytes: 0, nextSequence: 1 };
+            this.logTails.set(pluginId, tail);
+        }
+        const entry = {
+            sequence: tail.nextSequence++,
+            timestamp: new Date().toISOString(),
+            stream,
+            message: boundedMessage,
+        };
+        tail.entries.push(entry);
+        tail.bytes += Buffer.byteLength(boundedMessage);
+        while (tail.entries.length > MAX_LOG_ENTRIES || tail.bytes > MAX_LOG_BYTES) {
+            const removed = tail.entries.shift();
+            if (!removed)
+                break;
+            tail.bytes -= Buffer.byteLength(removed.message);
+        }
+        this.logger.info({ pluginId, ...entry }, "Plugin output");
+    }
+    notify(pluginId, error) {
+        for (const listener of this.listeners)
+            listener(pluginId, error);
+    }
+}
+function readConnectionId(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const connectionId = Reflect.get(value, "connectionId");
+    return typeof connectionId === "string" ? connectionId : null;
+}
+//# sourceMappingURL=runtime.js.map