@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,206 @@
+import { createConnection } from "node:net";
+import { randomUUID } from "node:crypto";
+import { assertHostFrameIdentity, assertHostRunReceipt, isHostTerminal, identifyInvokeInput, assertJsonByteLimit, INVOKE_REQUEST_MAX_BYTES } from "@mininglamp-oss/octo-runtime-protocol";
+import { callDaemon } from "./runtime-contract.js";
+/** Local source notifications have no per-event ACK and allocate no durable consumer queue. */
+export async function* subscribeDaemonRun(socketPath, input) {
+    if (input.signal?.aborted)
+        return;
+    const wireRequest = {
+        jsonrpc: "2.0",
+        id: randomUUID(),
+        method: input.invocation ? "agent_run.invoke" : "agent_run.subscribe",
+        params: input.invocation
+            ? { ...input.invocation }
+            : {
+                run_id: input.runId,
+                ...(input.streamId ? { stream_id: input.streamId } : {}),
+                after_seq: input.afterSeq ?? 0
+            }
+    };
+    assertJsonByteLimit(wireRequest, INVOKE_REQUEST_MAX_BYTES, "INVOKE_REQUEST_TOO_LARGE");
+    const socket = createConnection(socketPath);
+    const abort = () => {
+        socket.destroy();
+    };
+    input.signal?.addEventListener("abort", abort, { once: true });
+    socket.setEncoding("utf8");
+    socket.setTimeout(5000, () => socket.destroy(new Error("HOST_STREAM_HANDSHAKE_TIMEOUT")));
+    socket.write(`${JSON.stringify(wireRequest)}\n`);
+    let pending = "", started = false;
+    try {
+        for await (const chunk of socket) {
+            pending += String(chunk);
+            let boundary = pending.indexOf("\n");
+            while (boundary >= 0) {
+                const line = pending.slice(0, boundary);
+                pending = pending.slice(boundary + 1);
+                if (line.length > 512 * 1024)
+                    throw new Error("HOST_STREAM_FRAME_TOO_LARGE");
+                const frame = JSON.parse(line);
+                if (frame.jsonrpc !== "2.0")
+                    throw new Error("HOST_STREAM_PROTOCOL_INVALID");
+                if (frame.error) {
+                    const error = frame.error;
+                    throw new Error(error.message ?? "HOST_STREAM_FAILED");
+                }
+                if (!started) {
+                    started = true;
+                    socket.setTimeout(0);
+                }
+                yield frame;
+                if (input.signal?.aborted)
+                    return;
+                boundary = pending.indexOf("\n");
+            }
+            if (pending.length > 512 * 1024)
+                throw new Error("HOST_STREAM_FRAME_TOO_LARGE");
+        }
+        if (!input.signal?.aborted && (!started || pending.trim()))
+            throw new Error("HOST_STREAM_DISCONNECTED");
+    }
+    finally {
+        input.signal?.removeEventListener("abort", abort);
+        socket.destroy();
+    }
+}
+/** A single local invoke RPC returns its canonical notifications; replay only repairs IPC loss. */
+export async function* invokeDaemonRun(socketPath, input, environment = {}) {
+    const request = identifyInvokeInput(input);
+    const { signal, executionEnvOverrides } = environment;
+    if (signal?.aborted)
+        throw signal.reason instanceof Error ? signal.reason : new Error("caller_aborted");
+    let receipt;
+    let streamId, after = 0, terminal = false, attempts = 0;
+    let cancellation;
+    const cancel = () => {
+        if (cancellation)
+            return;
+        // ACK 在途时先核对真实身份，不能取消恰好使用同一 runId 的另一调用。
+        // 未接纳的请求由服务端接纳期 signal 取消，不重复 invoke 或无限重试。
+        cancellation = (async () => {
+            const accepted = receipt ??
+                receiptFrom(await callDaemon(socketPath, {
+                    method: "agent_run.get",
+                    params: { run_id: request.runId }
+                }));
+            if (accepted.run_id !== request.runId ||
+                accepted.invocation_id !== request.invocationId ||
+                accepted.agent_session_id !== request.sessionId ||
+                accepted.session_generation !== (request.sessionGeneration ?? 0) ||
+                accepted.protocol_mode !== (request.protocol_mode ?? "native"))
+                return;
+            await callDaemon(socketPath, {
+                method: "agent_run.cancel",
+                params: { run_id: request.runId }
+            });
+        })().catch(() => undefined);
+    };
+    signal?.addEventListener("abort", cancel, { once: true });
+    try {
+        while (!terminal && !signal?.aborted) {
+            try {
+                for await (const frame of subscribeDaemonRun(socketPath, {
+                    runId: request.runId,
+                    streamId,
+                    afterSeq: after,
+                    signal,
+                    ...(!streamId
+                        ? {
+                            invocation: {
+                                input: request,
+                                ...(executionEnvOverrides ? { executionEnvOverrides } : {})
+                            }
+                        }
+                        : {})
+                })) {
+                    if (frame.result) {
+                        const metadata = receiptFrom(frame.result);
+                        if (metadata.run_id !== request.runId ||
+                            metadata.invocation_id !== request.invocationId ||
+                            metadata.agent_session_id !== request.sessionId ||
+                            metadata.session_generation !== (request.sessionGeneration ?? 0) ||
+                            metadata.protocol_mode !== (request.protocol_mode ?? "native") ||
+                            !metadata.stream_id ||
+                            (streamId && streamId !== metadata.stream_id))
+                            throw new Error("STREAM_EXPIRED");
+                        streamId = metadata.stream_id;
+                        receipt = metadata;
+                        continue;
+                    }
+                    const params = frame.params;
+                    if (params?.run_id !== request.runId || params.stream_id !== streamId)
+                        throw new Error("HOST_STREAM_IDENTITY_INVALID");
+                    if (frame.method === "agent_run.stream_error")
+                        throw new Error(params.code ?? "STREAM_GAP");
+                    if (frame.method !== "agent_run.event" ||
+                        !params.event ||
+                        !Number.isSafeInteger(params.seq))
+                        throw new Error("HOST_STREAM_PROTOCOL_INVALID");
+                    if (params.seq <= after)
+                        continue;
+                    if (params.seq !== after + 1)
+                        throw new Error("STREAM_GAP");
+                    if (!receipt)
+                        throw new Error("HOST_STREAM_IDENTITY_INVALID");
+                    assertHostFrameIdentity(params.event, receipt);
+                    if (params.event.seq !== params.seq)
+                        throw new Error("STREAM_GAP");
+                    after = params.seq;
+                    terminal = isHostTerminal(params.event);
+                    yield params.event;
+                    if (terminal)
+                        return;
+                }
+                if (!terminal && !signal?.aborted)
+                    throw new Error("HOST_STREAM_DISCONNECTED");
+            }
+            catch (error) {
+                if (signal?.aborted)
+                    return;
+                const code = error instanceof Error ? error.message : String(error);
+                if (![
+                    "HOST_STREAM_DISCONNECTED",
+                    "read ECONNRESET",
+                    "HOST_STREAM_HANDSHAKE_TIMEOUT"
+                ].includes(code) ||
+                    ++attempts > 3)
+                    throw error;
+                if (!streamId) {
+                    const info = receiptFrom(await callDaemon(socketPath, {
+                        method: "agent_run.get",
+                        params: { run_id: request.runId }
+                    }));
+                    if (info.invocation_id !== request.invocationId ||
+                        info.protocol_mode !== (request.protocol_mode ?? "native") ||
+                        info.agent_session_id !== request.sessionId ||
+                        info.session_generation !== (request.sessionGeneration ?? 0))
+                        throw new Error("EXECUTION_IDENTITY_CONFLICT", { cause: error });
+                    receipt = info;
+                    streamId = info.stream_id;
+                }
+            }
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", cancel);
+        if (!terminal)
+            cancel();
+        await cancellation;
+    }
+}
+function receiptFrom(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("HOST_RECEIPT_INVALID");
+    const receipt = Object.fromEntries([
+        "run_id",
+        "invocation_id",
+        "stream_id",
+        "agent_session_id",
+        "session_generation",
+        "protocol_mode",
+        "protocol"
+    ].map((key) => [key, Reflect.get(value, key)]));
+    assertHostRunReceipt(receipt);
+    return receipt;
+}

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/runner.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+import { readAdapterConfigurations } from "@mininglamp-oss/octo-runtime-adapter-host";
+import { startDaemonServer } from "../server.js";
+import { extraRegistration } from "../extra-config.js";
+import { readJson, writeJsonAtomic } from "./home.js";
+const sessionIndex = process.argv.indexOf("--session");
+const sessionPath = sessionIndex >= 0 ? process.argv[sessionIndex + 1] : undefined;
+if (!sessionPath)
+    throw new Error("usage: octo-runtime-daemon-runner --session <path>");
+const session = readJson(sessionPath);
+if (session.schema_version !== 1 || !session.nonce || !Number.isSafeInteger(session.parent_pid)) {
+    throw new Error("embedded runner session is invalid");
+}
+// SDK 默认执行自己的 import/注册入口，不再继承 CLI JSON。
+// 已有显式 manifest 覆盖仍使用通用 JSON runner，避免路径迁移破坏调用方。
+const manifestPath = session.manifest_path;
+const hostEntrypoint = session.adapter_host_entrypoint ??
+    (manifestPath
+        ? fileURLToPath(import.meta.resolve("@mininglamp-oss/octo-runtime-adapter-host/runner"))
+        : fileURLToPath(new URL("./adapter-host.js", import.meta.url)));
+const profiles = session.profiles.map((profile) => {
+    const root = join(session.account_root, profile);
+    const identity = readJson(join(root, "identity", "runtime.json"));
+    const config = readJson(join(root, "config.json"));
+    return {
+        tenantId: identity.octo_space_id,
+        profile,
+        root,
+        runtimeId: identity.runtime_id,
+        adapterConfigurations: readAdapterConfigurations(root, config.adapters)
+    };
+});
+let stopping = false;
+const stop = () => {
+    if (stopping)
+        return;
+    stopping = true;
+    clearInterval(controlTimer);
+    void (async () => {
+        await application.close();
+    })().then(() => process.exit(0), (error) => {
+        console.error(error instanceof Error ? (error.stack ?? error.message) : String(error));
+        process.exit(1);
+    });
+};
+const application = await startDaemonServer({
+    homePath: session.account_root,
+    socketPath: session.socket_path,
+    manifestPath,
+    hostEntrypoint,
+    ...(session.log_directory ? { logging: { directory: session.log_directory } } : {}),
+    localRuntimes: profiles,
+    extras: (session.extras ?? []).map(extraRegistration),
+    account: {
+        subject: session.subject,
+        profiles,
+        machineId: readJson(join(session.home, "machine.json")).machine_id
+    },
+    modules: session.modules.map((descriptor) => ({
+        id: descriptor.id,
+        create: async (context, config) => {
+            const loaded = (await import(descriptor.module));
+            const create = loaded[descriptor.exportName];
+            if (typeof create !== "function")
+                throw new Error("DAEMON_MODULE_FACTORY_MISSING");
+            return create(context, config);
+        }
+    }))
+});
+writeJsonAtomic(session.supervisor_state, {
+    schema_version: 1,
+    nonce: session.nonce,
+    parent_pid: session.parent_pid,
+    runner_pid: process.pid,
+    host_pid: process.pid,
+    adapter_host_pid: application.hostProcess.child.pid ?? null,
+    started_at: new Date().toISOString()
+});
+const controlTimer = setInterval(() => {
+    if (existsSync(session.shutdown_file)) {
+        try {
+            const shutdown = readJson(session.shutdown_file);
+            if (shutdown.nonce === session.nonce)
+                stop();
+        }
+        catch {
+            // A partial or foreign shutdown file is not authority for this session.
+        }
+        return;
+    }
+    try {
+        process.kill(session.parent_pid, 0);
+    }
+    catch {
+        stop();
+    }
+}, 500);
+controlTimer.unref();
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
+    process.on(signal, stop);

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/runtime-contract.d.ts

@@ -0,0 +1,36 @@
+import type { DaemonModuleDescriptor, AccountSubject } from "./types.js";
+import type { ExtraDescriptor } from "../extra-config.js";
+import type { ExtraStatus } from "../extras.js";
+export interface DaemonRunnerSession {
+    schema_version: 1;
+    nonce: string;
+    parent_pid: number;
+    home: string;
+    account_root: string;
+    profiles: string[];
+    subject: AccountSubject;
+    modules: readonly DaemonModuleDescriptor[];
+    extras?: readonly ExtraDescriptor[];
+    socket_path: string;
+    pid_path: string;
+    log_directory?: string;
+    shutdown_file: string;
+    supervisor_state: string;
+    manifest_path?: string;
+    adapter_host_entrypoint?: string;
+}
+export interface DaemonStatus {
+    ready?: boolean;
+    pid?: number;
+    adapterHost?: {
+        pid?: number | null;
+        state?: string;
+    };
+    modules?: Record<string, unknown>;
+    extras?: Record<string, ExtraStatus>;
+}
+export declare function callDaemon<T = unknown>(socketPath: string, request: {
+    method: string;
+    params?: Record<string, unknown>;
+}, timeoutMs?: number): Promise<T>;
+export declare function probeDaemon(socketPath: string, timeoutMs?: number): Promise<DaemonStatus | undefined>;

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

@@ -0,0 +1,57 @@
+import { createConnection } from "node:net";
+export async function callDaemon(socketPath, request, timeoutMs = 5_000) {
+    const socket = createConnection(socketPath);
+    const id = `embedded-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("daemon connection timed out")), timeoutMs);
+            socket.once("connect", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            socket.once("error", (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+        });
+        socket.write(`${JSON.stringify({ jsonrpc: "2.0", id, ...request })}\n`);
+        return await new Promise((resolve, reject) => {
+            let buffered = "";
+            const timer = setTimeout(() => reject(new Error("daemon response timed out")), timeoutMs);
+            socket.setEncoding("utf8");
+            socket.on("data", (chunk) => {
+                buffered += chunk;
+                const newline = buffered.indexOf("\n");
+                if (newline < 0)
+                    return;
+                clearTimeout(timer);
+                try {
+                    const response = JSON.parse(buffered.slice(0, newline));
+                    if (response.error)
+                        throw new Error(response.error.message ?? "daemon request failed");
+                    resolve(response.result);
+                }
+                catch (error) {
+                    reject(error instanceof Error
+                        ? error
+                        : new Error("daemon response handling failed", { cause: error }));
+                }
+            });
+            socket.once("end", () => {
+                clearTimeout(timer);
+                reject(new Error("daemon closed before responding"));
+            });
+        });
+    }
+    finally {
+        socket.destroy();
+    }
+}
+export async function probeDaemon(socketPath, timeoutMs = 2_000) {
+    try {
+        return await callDaemon(socketPath, { method: "status" }, timeoutMs);
+    }
+    catch {
+        return undefined;
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/supervisor.d.ts

@@ -0,0 +1,23 @@
+import { type ChildProcess } from "node:child_process";
+import { type DaemonAccountPaths, type DaemonHomePaths } from "./home.js";
+import { type DaemonStatus } from "./runtime-contract.js";
+import type { AccountSubject, DaemonRuntimeOptions } from "./types.js";
+export interface SupervisedRuntime {
+    child: ChildProcess;
+    nonce: string;
+    paths: DaemonHomePaths;
+}
+export declare function startManagedDaemon(options: {
+    sdk: DaemonRuntimeOptions;
+    paths: DaemonHomePaths;
+    account: DaemonAccountPaths;
+    profiles: readonly string[];
+    subject: AccountSubject;
+    nonce: string;
+}): Promise<{
+    supervised: SupervisedRuntime;
+    status: DaemonStatus;
+}>;
+export declare function stopManagedDaemon(supervised: SupervisedRuntime): Promise<void>;
+export declare function runtimeStatus(supervised: SupervisedRuntime): Promise<DaemonStatus | undefined>;
+export declare function childEnvironment(paths: DaemonHomePaths): NodeJS.ProcessEnv;

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

@@ -0,0 +1,245 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DaemonRuntimeError } from "./errors.js";
+import { removeFile, writeJsonAtomic } from "./home.js";
+import { callDaemon, probeDaemon } from "./runtime-contract.js";
+const closedChildren = new WeakSet();
+export async function startManagedDaemon(options) {
+    const nodePath = resolveNode(options.sdk);
+    const runnerPath = options.sdk.distribution?.runnerPath ?? fileURLToPath(new URL("./runner.js", import.meta.url));
+    if (!existsSync(runnerPath)) {
+        throw new DaemonRuntimeError("DISTRIBUTION_MISSING", "distribution", false, `embedded runner is missing: ${runnerPath}`);
+    }
+    removeFile(options.paths.shutdownFile);
+    const session = {
+        schema_version: 1,
+        nonce: options.nonce,
+        parent_pid: process.pid,
+        home: options.paths.home,
+        account_root: options.account.root,
+        profiles: [...options.profiles],
+        subject: options.subject,
+        modules: options.sdk.modules ?? [],
+        extras: options.sdk.extras ?? [],
+        socket_path: options.paths.socket,
+        pid_path: options.paths.pidFile,
+        ...(options.sdk.logging ? { log_directory: options.sdk.logging.directory } : {}),
+        shutdown_file: options.paths.shutdownFile,
+        supervisor_state: options.paths.supervisorState,
+        ...(options.sdk.distribution?.manifestPath
+            ? { manifest_path: options.sdk.distribution.manifestPath }
+            : {}),
+        ...(options.sdk.distribution?.adapterHostEntrypoint
+            ? { adapter_host_entrypoint: options.sdk.distribution.adapterHostEntrypoint }
+            : {})
+    };
+    writeJsonAtomic(options.paths.sessionFile, session, true);
+    const child = spawn(nodePath, [runnerPath, "--session", options.paths.sessionFile], {
+        argv0: "octo-runtime-daemon",
+        cwd: dirname(runnerPath),
+        detached: false,
+        shell: false,
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "inherit"],
+        env: childEnvironment(options.paths)
+    });
+    child.once("close", () => {
+        closedChildren.add(child);
+    });
+    const supervised = { child, nonce: options.nonce, paths: options.paths };
+    const startupTimeout = options.sdk.startupTimeoutMs ?? 30_000;
+    const deadline = Date.now() + startupTimeout;
+    for (;;) {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            throw new DaemonRuntimeError("DAEMON_EXITED", "daemon", true, `embedded runner exited before readiness (code=${child.exitCode ?? "none"}, signal=${child.signalCode ?? "none"})`);
+        }
+        const status = await probeDaemon(options.paths.socket);
+        if (status?.ready)
+            return { supervised, status };
+        if (Date.now() >= deadline) {
+            await stopManagedDaemon(supervised).catch(() => undefined);
+            throw new DaemonRuntimeError("DAEMON_START_TIMEOUT", "daemon", true, `embedded runtime was not ready within ${startupTimeout}ms`);
+        }
+        await delay(250);
+    }
+}
+export async function stopManagedDaemon(supervised) {
+    let cleanupFailed = false;
+    try {
+        await callDaemon(supervised.paths.socket, { method: "lifecycle.drain", params: { timeoutMs: 5_000 } }, 7_000);
+    }
+    catch (error) {
+        cleanupFailed = error instanceof Error && error.message === "EXTRA_DISPOSE_FAILED";
+        // Shutdown must continue even if cleanup fails or the endpoint is unavailable.
+    }
+    writeJsonAtomic(supervised.paths.shutdownFile, {
+        nonce: supervised.nonce,
+        requested_at: new Date().toISOString()
+    });
+    if (await waitForExit(supervised.child, 5_000)) {
+        cleanup(supervised.paths);
+        if (cleanupFailed)
+            throw new DaemonRuntimeError("EXTRA_DISPOSE_FAILED", "shutdown", false, "Extra cleanup failed before process exit");
+        return;
+    }
+    await terminateOwnedChild(supervised.child);
+    if (!(await waitForExit(supervised.child, 5_000))) {
+        throw new DaemonRuntimeError("SHUTDOWN_INCOMPLETE", "shutdown", false, "embedded runtime process tree did not exit");
+    }
+    if (await probeDaemon(supervised.paths.socket, 500)) {
+        throw new DaemonRuntimeError("SHUTDOWN_INCOMPLETE", "shutdown", false, "embedded daemon IPC is still reachable after shutdown");
+    }
+    cleanup(supervised.paths);
+    if (cleanupFailed)
+        throw new DaemonRuntimeError("EXTRA_DISPOSE_FAILED", "shutdown", false, "Extra cleanup failed before process exit");
+}
+export async function runtimeStatus(supervised) {
+    if (supervised.child.exitCode !== null || supervised.child.signalCode !== null)
+        return undefined;
+    return probeDaemon(supervised.paths.socket);
+}
+function resolveNode(options) {
+    const explicit = options.distribution?.nodePath;
+    if (explicit)
+        return assertNode24(explicit);
+    const resourcesPath = process.resourcesPath;
+    if (resourcesPath) {
+        const executable = process.platform === "win32" ? "node.exe" : "node";
+        for (const candidate of [
+            join(resourcesPath, "runtime", "node", "bin", executable),
+            join(resourcesPath, "embedded-runtime", "node", "bin", executable)
+        ]) {
+            if (existsSync(candidate))
+                return assertNode24(candidate);
+        }
+        if (!options.development) {
+            throw new DaemonRuntimeError("NODE_RUNTIME_MISSING", "distribution", false, "packaged embedded runtime is missing its pinned Node.js 24 executable");
+        }
+    }
+    if (!process.versions.electron && Number(process.versions.node.split(".")[0]) >= 24)
+        return process.execPath;
+    if (options.development) {
+        const pathNode = findOnPath(process.platform === "win32" ? "node.exe" : "node");
+        if (pathNode)
+            return assertNode24(pathNode);
+    }
+    throw new DaemonRuntimeError("NODE_RUNTIME_MISSING", "distribution", false, "Embedded Runtime requires a pinned Node.js 24 runtime");
+}
+function assertNode24(path) {
+    if (!existsSync(path))
+        throw new DaemonRuntimeError("NODE_RUNTIME_MISSING", "distribution", false, `Node executable is missing: ${path}`);
+    const result = spawnSync(path, ["--version"], {
+        encoding: "utf8",
+        windowsHide: true,
+        shell: false
+    });
+    const version = String(result.stdout || result.stderr).trim();
+    if (result.status !== 0 || Number(/^v?(\d+)/.exec(version)?.[1] ?? 0) < 24) {
+        throw new DaemonRuntimeError("NODE_RUNTIME_INVALID", "distribution", false, `Embedded Runtime requires Node.js 24+: ${path} (${version || "unavailable"})`);
+    }
+    return path;
+}
+function findOnPath(executable) {
+    for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+        const candidate = directory ? join(directory, executable) : undefined;
+        if (candidate && existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+export function childEnvironment(paths) {
+    const env = {
+        PATH: process.env.PATH ?? "",
+        HOME: process.env.HOME ?? process.env.USERPROFILE ?? "",
+        LANG: process.env.LANG ?? "en_US.UTF-8",
+        OCTO_RUNTIME_HOME: paths.home,
+        ...(process.env.OCTO_RUNTIME_DEBUG === "1" ? { OCTO_RUNTIME_DEBUG: "1" } : {})
+    };
+    // Preserve the host's explicit network routing, including loopback bypasses.
+    // Do not inherit arbitrary application credentials into the runtime process.
+    for (const key of [
+        "HTTP_PROXY",
+        "HTTPS_PROXY",
+        "ALL_PROXY",
+        "NO_PROXY",
+        "http_proxy",
+        "https_proxy",
+        "all_proxy",
+        "no_proxy"
+    ]) {
+        if (process.env[key] !== undefined)
+            env[key] = process.env[key];
+    }
+    if (process.platform === "win32") {
+        for (const key of [
+            "SystemRoot",
+            "SystemDrive",
+            "COMSPEC",
+            "PATHEXT",
+            "TEMP",
+            "TMP",
+            "USERPROFILE",
+            "APPDATA",
+            "LOCALAPPDATA",
+            "NUMBER_OF_PROCESSORS",
+            "PROCESSOR_ARCHITECTURE"
+        ]) {
+            const value = environmentValue(key);
+            if (value)
+                env[key] = value;
+        }
+    }
+    return env;
+}
+function environmentValue(name) {
+    const key = Object.keys(process.env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+    return key ? process.env[key] : undefined;
+}
+async function terminateOwnedChild(child) {
+    if (!child.pid || child.exitCode !== null || child.signalCode !== null)
+        return;
+    if (process.platform === "win32") {
+        await new Promise((resolve, reject) => {
+            const killer = spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+                windowsHide: true,
+                shell: false,
+                stdio: "ignore"
+            });
+            killer.once("error", reject);
+            killer.once("exit", (code) => code === 0 || code === 128 ? resolve() : reject(new Error(`taskkill exited with ${code}`)));
+        });
+    }
+    else {
+        child.kill("SIGTERM");
+        if (!(await waitForExit(child, 2_000)))
+            child.kill("SIGKILL");
+    }
+}
+function waitForExit(child, timeoutMs) {
+    if (closedChildren.has(child))
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            cleanupListener();
+            resolve(false);
+        }, timeoutMs);
+        const onExit = () => {
+            clearTimeout(timer);
+            cleanupListener();
+            resolve(true);
+        };
+        const cleanupListener = () => {
+            child.off("close", onExit);
+        };
+        child.once("close", onExit);
+    });
+}
+function cleanup(paths) {
+    for (const path of [paths.shutdownFile, paths.sessionFile, paths.supervisorState])
+        removeFile(path);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}