@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/server.js

@@ -1,808 +0,0 @@
-import { spawnAdapterHost } from "@mininglamp-oss/octo-runtime-adapter-host";
-import { DaemonModules } from "./modules.js";
-import { assertInteractionResponse, assertNativeInteractionResponse, createInputInvoke, contextItem } from "@mininglamp-oss/octo-runtime-protocol";
-import { randomUUID } from "node:crypto";
-import { chmod, lstat, mkdir, open, readFile, rm } from "node:fs/promises";
-import net from "node:net";
-import { dirname, join } from "node:path";
-import { readBoundedLines } from "@mininglamp-oss/octo-runtime-adapter-sdk";
-import { RuntimeLogging, assertRuntimeLogging } from "@mininglamp-oss/octo-runtime-adapter-sdk";
-import { INVOKE_REQUEST_MAX_BYTES } from "@mininglamp-oss/octo-runtime-protocol";
-import { HostRunService } from "@mininglamp-oss/octo-runtime-adapter-host";
-import { InvocationManifest } from "./invocation-manifest.js";
-import { ExtraPlugins } from "./extras.js";
-import { extraRegistration } from "./extra-config.js";
-const DEFAULT_DRAIN_TIMEOUT_MS = 30_000;
-const DEFAULT_ADAPTER_HOST_RESTART_DELAYS_MS = [1_000, 5_000, 10_000, 20_000];
-const ADAPTER_HOST_STABLE_RESET_MS = 5 * 60_000;
-/**
- * Bring up the daemon: spawn the adapter-host child,
- * construct the execution service, register optional modules, and listen on
- * the Unix control socket. Partial-startup failures unwind in reverse. Each socket
- * connection carries exactly one request line (see `handleRequestLine`).
- */
-export async function startDaemonServer({ homePath, modules: registrations = [], extras: extraRegistrations = [], account, localRuntimes = [], pidPath, stateDirectory, socketPath, manifestPath, hostEntrypoint, logging, consoleOutput = false, adapterHostRestartDelaysMs = DEFAULT_ADAPTER_HOST_RESTART_DELAYS_MS, adapterHostReadyTimeoutMs }) {
-    assertRuntimeLogging(logging);
-    DaemonModules.validate(registrations);
-    // Validate duplicate names before acquiring process resources.
-    ExtraPlugins.validate(extraRegistrations);
-    if (registrations.some((entry) => extraRegistrations.some((extra) => extra.name === entry.id)))
-        throw new Error("EXTRA_MODULE_NAME_CONFLICT");
-    if (adapterHostRestartDelaysMs.length === 0 ||
-        adapterHostRestartDelaysMs.some((delay) => !Number.isFinite(delay) || delay < 1)) {
-        throw new Error("adapterHostRestartDelaysMs must contain positive delays");
-    }
-    // 配置来源属于宿主：CLI 读取统一 Extra 声明，SDK 应用可动态登记，Daemon 只接收结果。
-    let releasePid = () => Promise.resolve();
-    let invocationManifest;
-    const invocationManifestPath = join(stateDirectory ?? join(homePath ?? dirname(socketPath), "run"), "invocations.json");
-    try {
-        if (pidPath)
-            releasePid = await acquirePidFile(pidPath);
-        if (process.platform !== "win32") {
-            await mkdir(dirname(socketPath), { recursive: true });
-            try {
-                const stat = await lstat(socketPath);
-                if (!stat.isSocket())
-                    throw new Error(`refusing to replace non-socket path: ${socketPath}`);
-                await rm(socketPath);
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    throw error;
-            }
-        }
-        const openedManifest = await InvocationManifest.open(invocationManifestPath);
-        invocationManifest = openedManifest.manifest;
-        if (openedManifest.reap.found) {
-            console.error(openedManifest.reap.reaped
-                ? "reaped orphaned adapter-host process group"
-                : "cleared stale invocation manifest", { pid: openedManifest.reap.pid, reason: openedManifest.reap.reason });
-        }
-    }
-    catch (error) {
-        await releasePid();
-        throw error;
-    }
-    const logs = new RuntimeLogging(logging);
-    const spawnHost = async (signal) => {
-        const spawned = await spawnAdapterHost({
-            entrypoint: hostEntrypoint,
-            manifest: manifestPath,
-            env: {
-                ...process.env,
-                OCTO_RUNTIME_HOME: homePath ?? dirname(socketPath),
-                OCTO_RUNTIME_LOGS_DIRECTORY: logging?.directory ?? ""
-            },
-            ...(signal ? { signal } : {}),
-            ...(adapterHostReadyTimeoutMs !== undefined
-                ? { readyTimeoutMs: adapterHostReadyTimeoutMs }
-                : {})
-        });
-        const diagnostics = spawned.stderr();
-        if (diagnostics)
-            process.stderr.write(diagnostics);
-        spawned.child.stderr.on("data", (chunk) => process.stderr.write(chunk));
-        await invocationManifest.setAdapterHost(spawned.child.pid, hostEntrypoint);
-        return spawned;
-    };
-    let hostProcess;
-    try {
-        hostProcess = await spawnHost();
-    }
-    catch (error) {
-        await logs.close();
-        await invocationManifest.close();
-        await releasePid();
-        throw error;
-    }
-    let adapters;
-    try {
-        adapters = hostProcess.adapters.map((adapter) => adapter.type);
-    }
-    catch (error) {
-        await logs.close();
-        await hostProcess.close();
-        await invocationManifest.close();
-        await releasePid();
-        throw error;
-    }
-    const runtime = {
-        homePath,
-        pidPath,
-        socketPath,
-        manifestPath,
-        adapterHost: {
-            pid: hostProcess.child.pid ?? null,
-            entrypoint: hostEntrypoint,
-            state: "ready",
-            restartAttempt: 0
-        },
-        adapters
-    };
-    let shuttingDown = false;
-    let hostRestartAttempt = 0;
-    let hostRestartAbort;
-    let hostRestartTask;
-    let hostStableReset;
-    const readyHost = () => {
-        if (runtime.adapterHost.state !== "ready") {
-            throw Object.assign(new Error("adapter-host is restarting"), {
-                code: "ADAPTER_HOST_RESTARTING"
-            });
-        }
-        return hostProcess;
-    };
-    const localConfigurations = (metadata) => {
-        const selected = metadata?.runtimeId || metadata?.profile
-            ? localRuntimes.find((item) => (!metadata.runtimeId || item.runtimeId === metadata.runtimeId) &&
-                (!metadata.profile || item.profile === metadata.profile))
-            : localRuntimes[0];
-        if ((metadata?.runtimeId || metadata?.profile) &&
-            !selected &&
-            !(localRuntimes.length === 0 && !metadata.runtimeId && metadata.profile === "default"))
-            throw new Error("RUNTIME_CONFIGURATION_NOT_FOUND");
-        return (selected?.adapterConfigurations ?? {
-            openclaw: {
-                providerOptions: {
-                    OPENCLAW_RUNTIME_ROOT: selected
-                        ? selected.root
-                        : join(homePath ?? dirname(socketPath), "default")
-                }
-            }
-        });
-    };
-    const withLocalConfiguration = (request) => {
-        const selectedAdapter = contextItem(request.contexts, "octo.execution", "adapter")?.payload
-            .type;
-        const adapterType = typeof selectedAdapter === "string" ? selectedAdapter : "codex";
-        const configuration = localConfigurations(request.runMetadata)?.[adapterType];
-        return configuration
-            ? {
-                ...request,
-                agentConfig: {
-                    ...request.agentConfig,
-                    providerOptions: {
-                        ...request.agentConfig?.providerOptions,
-                        ...configuration.providerOptions
-                    }
-                }
-            }
-            : request;
-    };
-    const transportHost = {
-        list: async (configurations) => readyHost().client.list(configurations ?? localConfigurations()),
-        probe: async (adapterType, options) => readyHost().client.probe(adapterType, options ?? localConfigurations()?.[adapterType]),
-        cancel: async (invocationId, reason) => readyHost().client.cancel(invocationId, reason),
-        respondInteraction: async (invocationId, response) => readyHost().client.respondInteraction(invocationId, response),
-        respondNative: async (invocationId, response) => readyHost().client.respondNative(invocationId, response),
-        invoke: createInputInvoke((input, environment) => transportHost.invokeFrames(input, environment)),
-        async *invokeFrames(input, environment) {
-            const invocationId = requiredString(input.invocationId, "invocationId");
-            const selectedAdapter = contextItem(input.contexts, "octo.execution", "adapter")?.payload
-                .type;
-            await invocationManifest.begin({
-                invocationId,
-                runId: requiredString(input.runId, "runId"),
-                adapterType: typeof selectedAdapter === "string" ? selectedAdapter : "codex"
-            });
-            try {
-                for await (const event of readyHost().client.invokeFrames(withLocalConfiguration(input), environment)) {
-                    yield event;
-                }
-            }
-            finally {
-                try {
-                    await invocationManifest.end(invocationId);
-                }
-                catch (error) {
-                    console.error("failed to remove completed invocation from the manifest", {
-                        error: errorMessage(error)
-                    });
-                }
-            }
-        }
-    };
-    const restartAdapterHost = async (signal) => {
-        while (!shuttingDown && !signal.aborted) {
-            const attempt = ++hostRestartAttempt;
-            const restartDelay = adapterHostRestartDelayMs(attempt, adapterHostRestartDelaysMs);
-            runtime.adapterHost.restartAttempt = attempt;
-            console.error("adapter-host restart scheduled", {
-                restart_attempt: attempt,
-                restart_delay_ms: restartDelay
-            });
-            try {
-                await abortableDelay(restartDelay, signal);
-                const replacement = await spawnHost(signal);
-                if (shuttingDown || signal.aborted) {
-                    await replacement.close();
-                    throw new Error("adapter-host restart cancelled");
-                }
-                const replacementAdapters = replacement.adapters.map((adapter) => adapter.type);
-                if (shuttingDown || signal.aborted) {
-                    await replacement.close();
-                    throw new Error("adapter-host restart cancelled");
-                }
-                hostProcess = replacement;
-                runtime.adapterHost.pid = replacement.child.pid ?? null;
-                runtime.adapterHost.state = "ready";
-                runtime.adapters = replacementAdapters;
-                monitorAdapterHost(replacement);
-                console.error("adapter-host restarted", {
-                    adapter_host_pid: replacement.child.pid ?? null,
-                    restart_attempt: attempt
-                });
-                hostStableReset = setTimeout(() => {
-                    if (hostProcess === replacement && runtime.adapterHost.state === "ready") {
-                        hostRestartAttempt = 0;
-                        runtime.adapterHost.restartAttempt = 0;
-                    }
-                }, ADAPTER_HOST_STABLE_RESET_MS);
-                hostStableReset.unref();
-                return replacement;
-            }
-            catch (error) {
-                if (shuttingDown || signal.aborted)
-                    throw error;
-                console.error("adapter-host restart attempt failed", {
-                    restart_attempt: attempt,
-                    error: errorMessage(error)
-                });
-            }
-        }
-        throw new Error("adapter-host restart cancelled");
-    };
-    const handleAdapterHostExit = (exited, code, signal) => {
-        if (shuttingDown || exited !== hostProcess)
-            return;
-        if (hostStableReset)
-            clearTimeout(hostStableReset);
-        hostStableReset = undefined;
-        const error = new Error(`adapter-host exited unexpectedly (${code ?? signal ?? "unknown"})`);
-        exited.client.close(error);
-        runtime.adapterHost.pid = null;
-        runtime.adapterHost.state = "restarting";
-        void invocationManifest.setAdapterHost(undefined, hostEntrypoint).catch(() => undefined);
-        console.error("adapter-host exited unexpectedly; restarting inside daemon", {
-            exit_code: code,
-            signal
-        });
-        const controller = new AbortController();
-        hostRestartAbort = controller;
-        const restart = restartAdapterHost(controller.signal);
-        hostRestartTask = restart;
-        void restart.catch(() => undefined);
-    };
-    function monitorAdapterHost(process) {
-        process.child.once("exit", (code, signal) => handleAdapterHostExit(process, code, signal));
-    }
-    monitorAdapterHost(hostProcess);
-    const host = new HostRunService(transportHost);
-    const modules = new DaemonModules(registrations, {
-        host,
-        homePath: homePath ?? dirname(socketPath),
-        account
-    }, (name) => logs.extra(name));
-    const extras = new ExtraPlugins(extraRegistrations, host, (name) => logs.extra(name));
-    const connections = new Set();
-    const server = net.createServer((socket) => {
-        connections.add(socket);
-        // A connection id scopes transport evidence only. AgentRun, AgentSession and
-        // invocation ids retain their domain meanings and may span other transports.
-        const connectionId = `conn_${randomUUID()}`;
-        // A client may disconnect before an RPC finishes; close only its transport.
-        socket.on("error", () => socket.destroy());
-        socket.once("close", () => {
-            connections.delete(socket);
-            stopInput();
-        });
-        const stopInput = readBoundedLines(socket, INVOKE_REQUEST_MAX_BYTES, {
-            onError: () => socket.destroy(),
-            onClose: () => { },
-            onTooLarge: () => socket.end(`${JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32000, message: "INVOKE_REQUEST_TOO_LARGE" } })}\n`),
-            onLine: (line) => {
-                stopInput();
-                void handleRequestLine({
-                    line,
-                    socket,
-                    host,
-                    runtime,
-                    modules,
-                    extras,
-                    resolveConfigurations: localConfigurations,
-                    connectionId
-                });
-            }
-        });
-    });
-    try {
-        await new Promise((resolve, reject) => {
-            server.once("error", reject);
-            server.listen(socketPath, () => resolve());
-        });
-        // The Unix socket is the only local access boundary for the control plane;
-        // 0600 restricts it to the current host account (there is no RBAC above it).
-        if (process.platform !== "win32")
-            await chmod(socketPath, 0o600);
-        modules.startConfigured();
-        await Promise.allSettled(extraRegistrations
-            .filter((entry) => entry.enabled !== false)
-            .map(async (entry) => {
-            if (consoleOutput)
-                console.error("extra loading", { name: entry.name });
-            try {
-                await extras.load(entry.name);
-                if (consoleOutput) {
-                    try {
-                        console.error("extra internal status", JSON.stringify({ name: entry.name, status: await extras.inspect(entry.name) }));
-                    }
-                    catch {
-                        console.error("extra internal status", {
-                            name: entry.name,
-                            error: "EXTRA_STATUS_FAILED"
-                        });
-                    }
-                }
-            }
-            finally {
-                if (consoleOutput)
-                    console.error("extra startup result", {
-                        name: entry.name,
-                        ...extras.status[entry.name]
-                    });
-            }
-        }));
-        if (consoleOutput) {
-            for (const entry of extraRegistrations.filter((entry) => entry.enabled === false))
-                console.error("extra startup result", { name: entry.name, phase: "disabled" });
-        }
-        if (consoleOutput)
-            console.error("daemon ready", {
-                pid: process.pid,
-                home_path: homePath,
-                socket_path: socketPath,
-                adapter_host_pid: hostProcess.child.pid ?? null,
-                adapters
-            });
-    }
-    catch (error) {
-        shuttingDown = true;
-        hostRestartAbort?.abort();
-        if (hostStableReset)
-            clearTimeout(hostStableReset);
-        await extras.close().catch(() => undefined);
-        await modules.close();
-        await host.close();
-        await hostRestartTask?.catch(() => undefined);
-        await hostProcess.close();
-        await invocationManifest.close();
-        if (process.platform !== "win32")
-            await rm(socketPath, { force: true });
-        await releasePid();
-        await logs.close();
-        throw error;
-    }
-    return {
-        server,
-        host,
-        get hostProcess() {
-            return hostProcess;
-        },
-        runtime,
-        modules,
-        extras,
-        async close() {
-            shuttingDown = true;
-            hostRestartAbort?.abort();
-            if (hostStableReset)
-                clearTimeout(hostStableReset);
-            if (consoleOutput)
-                console.error("daemon stopping");
-            let extraError;
-            await extras.close().catch((error) => {
-                extraError = error;
-            });
-            await modules.close();
-            await host.close();
-            for (const connection of connections)
-                connection.destroy();
-            await new Promise((resolve) => server.close(() => resolve()));
-            await hostRestartTask?.catch(() => undefined);
-            await hostProcess.close();
-            await invocationManifest.close();
-            if (process.platform !== "win32")
-                await rm(socketPath, { force: true });
-            await releasePid();
-            await logs.close();
-            if (consoleOutput)
-                console.error("daemon stopped");
-            if (extraError)
-                throw extraError instanceof Error
-                    ? extraError
-                    : new Error("EXTRA_DISPOSE_FAILED", { cause: extraError });
-        }
-    };
-}
-/** Handle one control request; invocation subscriptions stream until completion. */
-async function handleRequestLine({ line, socket, host, runtime, modules, extras, resolveConfigurations, connectionId }) {
-    let request;
-    try {
-        request = parseRequest(line);
-        if (request.method === "agent_run.invoke" || request.method === "agent_run.subscribe") {
-            if (JSON.parse(line).jsonrpc !== "2.0")
-                throw new Error("JSON-RPC 2.0 required");
-            if (request.method === "agent_run.invoke") {
-                // .octospec/tasks/sdk-host-extra-contexts/flows.md：回执前尚无可供 cancel 查询的 Run。
-                // 仅在接纳期间将断连映射为停止；已接纳源流仍按原合同支持断线续订。
-                const pending = new AbortController();
-                const disconnect = () => pending.abort();
-                socket.once("close", disconnect);
-                if (socket.destroyed)
-                    pending.abort();
-                try {
-                    const receipt = await host.submit(request.params?.input, {
-                        signal: pending.signal,
-                        executionEnvOverrides: request.params
-                            ?.executionEnvOverrides
-                    });
-                    request.params = { run_id: receipt.run_id };
-                }
-                finally {
-                    socket.off("close", disconnect);
-                }
-            }
-            await streamAgentRun(request, socket, host);
-            return;
-        }
-        const result = await dispatch({
-            request,
-            host,
-            runtime,
-            modules,
-            extras,
-            resolveConfigurations
-        });
-        if (!socket.destroyed && socket.writable)
-            socket.end(`${JSON.stringify({ jsonrpc: "2.0", id: request.id, result })}\n`);
-    }
-    catch (error) {
-        console.error("daemon control request failed", {
-            connection_id: connectionId,
-            method: request?.method ?? "unknown",
-            error: errorMessage(error),
-            code: error.code
-        });
-        const rpcError = error;
-        if (!socket.destroyed && socket.writable)
-            socket.end(`${JSON.stringify({
-                jsonrpc: "2.0",
-                id: request?.id,
-                error: { message: errorMessage(error), code: rpcError.code }
-            })}\n`);
-    }
-}
-/**
- * Emit the currently retained in-memory event snapshot and optionally follow it.
- * No SQLite query is involved; a disconnected client owns no queued payloads.
- */
-async function streamAgentRun(request, socket, host) {
-    if (request.params &&
-        (Object.hasOwn(request.params, "options") || Object.hasOwn(request.params, "protocol_mode")))
-        throw new Error("EXECUTION_PROTOCOL_MISMATCH: subscription inherits the accepted mode");
-    const runId = requiredString(request.params?.run_id, "run_id");
-    let streamId = optionalString(request.params?.stream_id);
-    const cursor = request.params?.after_seq ?? 0;
-    if (typeof cursor !== "number")
-        throw new Error("STREAM_CURSOR_INVALID");
-    let after = cursor;
-    const release = host.acquireSubscription();
-    const subscriptionId = `sub_${randomUUID()}`;
-    let started = false;
-    socket.setTimeout(0); // Model silence is not a stalled socket write.
-    try {
-        while (!socket.destroyed) {
-            const page = host.read(runId, streamId, after);
-            streamId = page.stream_id;
-            if (!started) {
-                await writeSocketLine(socket, {
-                    jsonrpc: "2.0",
-                    id: request.id,
-                    result: { subscription_id: subscriptionId, ...page, events: undefined }
-                });
-                started = true;
-            }
-            for (const value of page.events) {
-                await writeSocketLine(socket, {
-                    jsonrpc: "2.0",
-                    method: "agent_run.event",
-                    params: {
-                        subscription_id: subscriptionId,
-                        run_id: runId,
-                        stream_id: streamId,
-                        seq: value.seq,
-                        event: value.event
-                    }
-                });
-                after = value.seq;
-            }
-            if ((page.terminal || request.params?.follow === false) && after >= page.latest_seq) {
-                socket.end();
-                return;
-            }
-            if (!page.events.length)
-                await new Promise((resolve) => {
-                    const done = () => {
-                        clearTimeout(timer);
-                        socket.off("close", done);
-                        resolve();
-                    };
-                    const timer = setTimeout(done, 100);
-                    socket.once("close", done);
-                });
-        }
-    }
-    catch (error) {
-        if (!socket.destroyed)
-            socket.end(`${JSON.stringify({
-                jsonrpc: "2.0",
-                ...(started
-                    ? {
-                        method: "agent_run.stream_error",
-                        params: {
-                            subscription_id: subscriptionId,
-                            run_id: runId,
-                            stream_id: streamId,
-                            code: errorMessage(error),
-                            ...(error.data ?? {})
-                        }
-                    }
-                    : {
-                        id: request.id,
-                        error: {
-                            code: -32001,
-                            message: errorMessage(error),
-                            data: error.data
-                        }
-                    })
-            })}\n`);
-    }
-    finally {
-        release();
-    }
-}
-async function writeSocketLine(socket, value) {
-    if (socket.destroyed)
-        return;
-    const encoded = Buffer.from(`${JSON.stringify(value)}\n`);
-    for (let offset = 0; offset < encoded.byteLength; offset += 16 * 1024) {
-        if (socket.destroyed)
-            return;
-        const chunk = encoded.subarray(offset, Math.min(offset + 16 * 1024, encoded.byteLength));
-        const writable = socket.write(chunk);
-        if (!writable)
-            await waitForDrain(socket, 5_000);
-    }
-}
-function waitForDrain(socket, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            clearTimeout(timer);
-            socket.off("drain", onDrain);
-            socket.off("error", onError);
-            socket.off("close", onClose);
-        };
-        const onDrain = () => {
-            cleanup();
-            resolve();
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const onClose = () => {
-            cleanup();
-            reject(new Error("daemon event client disconnected"));
-        };
-        const timer = setTimeout(() => {
-            cleanup();
-            socket.destroy();
-            reject(Object.assign(new Error("daemon event client drain timed out"), {
-                code: "EVENT_DRAIN_TIMEOUT"
-            }));
-        }, timeoutMs);
-        timer.unref();
-        socket.once("drain", onDrain);
-        socket.once("error", onError);
-        socket.once("close", onClose);
-    });
-}
-function abortableDelay(ms, signal) {
-    if (signal.aborted)
-        return Promise.reject(new Error("adapter-host restart cancelled"));
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(new Error("adapter-host restart cancelled"));
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
-}
-/** Capped staircase for repeated adapter-host crashes. The last delay repeats
- * indefinitely so a local crash loop never exhausts the service-manager burst. */
-export function adapterHostRestartDelayMs(attempt, delays = DEFAULT_ADAPTER_HOST_RESTART_DELAYS_MS) {
-    if (delays.length === 0 || delays.some((delay) => !Number.isFinite(delay) || delay < 1)) {
-        throw new Error("adapter-host restart delays must contain positive values");
-    }
-    const index = Math.max(0, Math.min(delays.length - 1, Math.trunc(attempt) - 1));
-    return delays[index] ?? delays[delays.length - 1];
-}
-/** Route execution and module control to their process-local owners. */
-async function dispatch({ request, host, runtime, modules, extras, resolveConfigurations }) {
-    const params = request.params ?? {};
-    switch (request.method) {
-        case "extra.load": {
-            const descriptor = params.descriptor;
-            const registration = extraRegistration(descriptor);
-            if (registration.name in modules.status)
-                throw new Error("EXTRA_MODULE_NAME_CONFLICT");
-            await extras.load(registration.name, registration);
-            return extras.status;
-        }
-        case "extra.unload":
-            await extras.unload(requiredString(params.name, "name"));
-            return extras.status;
-        case "extra.status":
-            return params.name === undefined
-                ? extras.status
-                : extras.inspect(requiredString(params.name, "name"));
-        case "module.start":
-            return modules.start(requiredString(params.id, "id"), params.config);
-        case "module.stop":
-            await modules.stop(requiredString(params.id, "id"));
-            return { stopped: true };
-        case "module.status":
-            return modules.status;
-        case "module.request":
-            return modules.request(requiredString(params.id, "id"), {
-                method: requiredString(params.method, "method"),
-                params: params.params
-            });
-        case "status":
-            return {
-                ready: runtime.adapterHost.state === "ready",
-                pid: process.pid,
-                ...runtime,
-                modules: modules.status,
-                extras: extras.status,
-                lifecycle: host.status
-            };
-        case "lifecycle.drain": {
-            const timeoutMs = positiveInteger(params.timeoutMs, "timeoutMs", DEFAULT_DRAIN_TIMEOUT_MS);
-            host.beginDrain();
-            await extras.close();
-            await Promise.all([host.drain(timeoutMs), modules.drain(timeoutMs)]);
-            return {
-                drained: true,
-                local: host.status,
-                modules: modules.status
-            };
-        }
-        case "adapter.list":
-            return host.list(resolveConfigurations(params));
-        case "adapter.probe":
-            return host.probe(requiredString(params.adapterType, "adapterType"), resolveConfigurations(params)?.[requiredString(params.adapterType, "adapterType")]);
-        case "agent_run.submit":
-            return host.submit(params.input, {
-                executionEnvOverrides: params.executionEnvOverrides
-            });
-        case "agent_run.native.respond":
-            assertNativeInteractionResponse(params.response);
-            await host.respondNativeRun(requiredString(params.run_id, "run_id"), params.response);
-            return { accepted: true };
-        case "agent_run.respond":
-            assertInteractionResponse(params.response);
-            await host.respond(requiredString(params.run_id, "run_id"), params.response);
-            return { accepted: true };
-        case "agent_run.get":
-            return host.get(requiredString(params.run_id, "run_id"));
-        case "agent_run.cancel":
-            return host.cancelRun(requiredString(params.run_id, "run_id"), optionalString(params.reason));
-        default:
-            throw Object.assign(new Error(`unknown daemon method: ${request.method}`), {
-                code: "method_not_found"
-            });
-    }
-}
-function parseRequest(line) {
-    const value = JSON.parse(line);
-    if (!isRecord(value) || typeof value.method !== "string")
-        throw new TypeError("daemon request requires method");
-    return value;
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function requiredString(value, name) {
-    if (typeof value !== "string" || value.length === 0)
-        throw new TypeError(`${name} must be a non-empty string`);
-    return value;
-}
-function optionalString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-function positiveInteger(value, name, fallback) {
-    if (value === undefined)
-        return fallback;
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
-        throw new TypeError(`${name} must be a positive integer`);
-    }
-    return value;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-async function acquirePidFile(path) {
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-            const file = await open(path, "wx", 0o600);
-            try {
-                await file.writeFile(`${process.pid}\n`, "utf8");
-                await file.sync();
-            }
-            finally {
-                await file.close();
-            }
-            if (process.platform !== "win32")
-                await chmod(path, 0o600);
-            return async () => {
-                try {
-                    const owner = Number((await readFile(path, "utf8")).trim());
-                    if (owner === process.pid)
-                        await rm(path, { force: true });
-                }
-                catch (error) {
-                    if (error.code !== "ENOENT")
-                        throw error;
-                }
-            };
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            const owner = await readPid(path);
-            if (owner !== undefined && processAlive(owner)) {
-                throw new Error(`Octo Runtime daemon is already running with pid ${owner}`, {
-                    cause: error
-                });
-            }
-            await rm(path, { force: true });
-        }
-    }
-    throw new Error(`could not acquire daemon pid file: ${path}`);
-}
-async function readPid(path) {
-    try {
-        const value = Number((await readFile(path, "utf8")).trim());
-        return Number.isSafeInteger(value) && value > 0 ? value : undefined;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-}
-function processAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === "EPERM";
-    }
-}