@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

package/node_modules/@mininglamp-oss/{octo-runtime-daemon → octo-runtime-host-sdk}/dist/extras.js

@@ -1,11 +1,13 @@
 import { noopRuntimeLog } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { abortForShutdown, shutdownDeadline, withinShutdown } from "./shutdown.js";
+import { snapshotExtraDependencies } from "./extra-dependencies.js";
 export function assertExtraName(name) {
     if (typeof name !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(name))
         throw new Error("EXTRA_NAME_INVALID");
 }
 /** 每个声明名最多一个实例；只加载宿主选定的插件，并统一管理取消、状态和清理。 */
 export class ExtraPlugins {
-    adapterHost;
+    kernel;
     logForExtra;
     #registrations = new Map();
     #instances = new Map();
@@ -29,8 +31,8 @@ export class ExtraPlugins {
             names.add(entry.name);
         }
     }
-    constructor(registrations, adapterHost, logForExtra = () => noopRuntimeLog) {
-        this.adapterHost = adapterHost;
+    constructor(registrations, kernel, logForExtra = () => noopRuntimeLog) {
+        this.kernel = kernel;
         this.logForExtra = logForExtra;
         ExtraPlugins.validate(registrations);
         for (const registration of registrations) {
@@ -83,7 +85,9 @@ export class ExtraPlugins {
     load(target, configOrRegistration, dependencies) {
         if (typeof target !== "string") {
             // 仅在同一 Node 进程闭包捕获函数；复用下方生命周期，不把函数写入声明或传过 IPC。
-            const functions = Object.freeze({ ...dependencies });
+            const functions = dependencies === undefined
+                ? Object.freeze({})
+                : snapshotExtraDependencies(dependencies);
             const registration = {
                 name: target.name,
                 config: configOrRegistration,
@@ -168,7 +172,7 @@ export class ExtraPlugins {
                 assertStatusObject(registration.config);
                 instance.controller.signal.throwIfAborted();
                 const initialize = plugin.default({
-                    adapterHost: this.adapterHost,
+                    kernel: this.kernel,
                     log: (level, event, data) => {
                         try {
                             this.logForExtra(name)(level, event, data);
@@ -204,7 +208,7 @@ export class ExtraPlugins {
                 this.#statuses.set(name, { phase: "loaded" });
             }
             catch (error) {
-                instance.controller.abort();
+                abortForShutdown(instance.controller);
                 let cleanupFailed = false;
                 await withDisposalDeadline(this.#dispose(instance)).catch((cleanupError) => {
                     cleanupFailed = true;
@@ -236,7 +240,9 @@ export class ExtraPlugins {
             return Promise.resolve();
         // 递增代次也能撤销尚未创建 AbortController 的排队 load，防止卸载后又启动旧声明。
         this.#loadEpochs.set(name, (this.#loadEpochs.get(name) ?? 0) + 1);
-        this.#instances.get(name)?.controller.abort();
+        const stopping = this.#instances.get(name);
+        if (stopping)
+            abortForShutdown(stopping.controller);
         const instance = this.#instances.get(name);
         // abort 不能排在初始化 Promise 后面；外部初始化可能正等待这个取消信号才会退出。
         const task = instance ? this.#unload(name) : this.#serial(name, () => this.#unload(name));
@@ -257,14 +263,14 @@ export class ExtraPlugins {
             return Promise.resolve();
         if (instance.disposing)
             return instance.disposing;
-        instance.controller.abort();
+        abortForShutdown(instance.controller);
         this.#statuses.set(name, { phase: "disposing" });
         instance.disposing = (async () => {
             try {
-                await withDisposalDeadline((async () => {
+                await withinShutdown((async () => {
                     await instance.starting.catch(() => undefined);
                     await this.#dispose(instance);
-                })());
+                })(), shutdownDeadline(instance.controller.signal), "EXTRA_DISPOSE_FAILED");
                 this.#statuses.set(name, { phase: "disposed" });
             }
             catch (error) {
@@ -279,12 +285,17 @@ export class ExtraPlugins {
         })();
         return instance.disposing;
     }
+    stopAdmission() {
+        this.#closed = true;
+        for (const instance of this.#instances.values())
+            abortForShutdown(instance.controller);
+    }
     close() {
         if (this.#closing)
             return this.#closing;
         this.#closed = true;
         for (const instance of this.#instances.values())
-            instance.controller.abort();
+            abortForShutdown(instance.controller);
         this.#closing = (async () => {
             const results = await Promise.allSettled([...this.#instances.keys()].reverse().map((name) => this.unload(name)));
             const failures = results.filter((result) => result.status === "rejected");
@@ -308,11 +319,11 @@ export class ExtraPlugins {
         instance.cleanup = (async () => {
             const errors = [];
             // 逆序匹配资源的创建依赖；所有 disposer 共用宽限，单项失败仍继续尝试其余清理。
-            const deadline = Date.now() + 5_000;
+            const deadline = shutdownDeadline(instance.controller.signal);
             for (const dispose of instance.disposers.reverse()) {
                 try {
                     const operation = Promise.resolve().then(dispose);
-                    await withDisposalDeadline(operation, Math.max(1, deadline - Date.now()));
+                    await withinShutdown(operation, deadline, "EXTRA_DISPOSE_FAILED");
                 }
                 catch (error) {
                     errors.push(error);

package/node_modules/@mininglamp-oss/{octo-runtime-daemon/dist/runtime → octo-runtime-host-sdk/dist}/home.d.ts

@@ -2,47 +2,38 @@ export interface MachineIdentity {
     schema_version: 1;
     machine_id: string;
 }
-export interface DaemonHomePaths {
+export interface HostHomePaths {
     home: string;
     machineFile: string;
     run: string;
     socket: string;
     pidFile: string;
-    ownerLock: string;
-    sessionFile: string;
-    supervisorState: string;
-    shutdownFile: string;
 }
-export interface DaemonAccountPaths {
+export interface HostAccountPaths {
     accountKey: string;
     root: string;
     configFile: string;
     logs: string;
 }
-export interface DaemonProfilePaths {
+export interface HostProfilePaths {
     name: string;
     root: string;
     configFile: string;
     identityFile: string;
     credentialFile: string;
 }
-export interface OwnerLock {
-    nonce: string;
-    release(): void;
-}
-export declare function resolveDaemonHome(appId: string, options?: {
+export declare function resolveHostHome(appId: string, options?: {
     platform?: NodeJS.Platform;
     env?: NodeJS.ProcessEnv;
     userHome?: string;
 }): string;
-export declare function daemonHomePaths(homeInput: string, platform?: NodeJS.Platform): DaemonHomePaths;
+export declare function hostHomePaths(homeInput: string, platform?: NodeJS.Platform): HostHomePaths;
 export declare function accountKeyFor(subjectType: string, subjectId: string): string;
 export declare function profileNameFor(appId: string, tenantId: string): string;
-export declare function accountPaths(paths: DaemonHomePaths, accountKey: string): DaemonAccountPaths;
-export declare function profilePaths(account: DaemonAccountPaths, name: string): DaemonProfilePaths;
-export declare function ensureDaemonHome(paths: DaemonHomePaths): MachineIdentity;
-export declare function ensureAccount(account: DaemonAccountPaths, profiles: readonly string[]): void;
-export declare function acquireOwnerLock(paths: DaemonHomePaths): OwnerLock;
+export declare function accountPaths(paths: HostHomePaths, accountKey: string): HostAccountPaths;
+export declare function profilePaths(account: HostAccountPaths, name: string): HostProfilePaths;
+export declare function ensureHostHome(paths: HostHomePaths): MachineIdentity;
+export declare function ensureAccount(account: HostAccountPaths, profiles: readonly string[]): void;
 export declare function readJson<T>(path: string): T;
 export declare function readJsonOptional<T>(path: string): T | undefined;
 export declare function writeJsonAtomic(path: string, value: unknown, secret?: boolean): void;

package/node_modules/@mininglamp-oss/{octo-runtime-daemon/dist/runtime → octo-runtime-host-sdk/dist}/home.js

@@ -2,10 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, parse, resolve, win32 } from "node:path";
-import { DaemonRuntimeError } from "./errors.js";
+import { HostRuntimeError } from "./errors.js";
+import { componentEndpoint } from "./endpoint.js";
 const PROFILE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const MACHINE_PATTERN = /^machine_[0-9a-f-]{36}$/;
-export function resolveDaemonHome(appId, options = {}) {
+export function resolveHostHome(appId, options = {}) {
     const slug = appSlug(appId);
     const platform = options.platform ?? process.platform;
     const env = options.env ?? process.env;
@@ -13,7 +14,7 @@ export function resolveDaemonHome(appId, options = {}) {
     if (platform === "win32") {
         const localAppData = env.LOCALAPPDATA?.trim();
         if (!localAppData) {
-            throw new DaemonRuntimeError("HOME_UNAVAILABLE", "home", false, "LOCALAPPDATA is required on Windows");
+            throw new HostRuntimeError("HOME_UNAVAILABLE", "home", false, "LOCALAPPDATA is required on Windows");
         }
         return win32.join(localAppData, slug, "OctoRuntime");
     }
@@ -21,36 +22,30 @@ export function resolveDaemonHome(appId, options = {}) {
         return join(userHome, "Library", "Application Support", slug, "octo-runtime");
     return join(env.XDG_STATE_HOME?.trim() || join(userHome, ".local", "state"), slug, "octo-runtime");
 }
-export function daemonHomePaths(homeInput, platform = process.platform) {
+export function hostHomePaths(homeInput, platform = process.platform) {
     const home = validateHome(homeInput, platform);
     const run = join(home, "run");
-    const socket = platform === "win32"
-        ? `\\\\.\\pipe\\octo-runtime-embedded-${createHash("sha256").update(home.toLowerCase()).digest("hex").slice(0, 16)}`
-        : join(home, "sockets", "octo-runtime-daemon.sock");
+    const socket = componentEndpoint(home, "executor-kernel", platform);
     return {
         home,
         machineFile: join(home, "machine.json"),
         run,
         socket,
-        pidFile: join(home, "octo-daemon.pid"),
-        ownerLock: join(run, "embedded-owner.lock"),
-        sessionFile: join(run, "embedded-session.json"),
-        supervisorState: join(run, "embedded-supervisor.json"),
-        shutdownFile: join(run, "embedded-shutdown")
+        pidFile: join(home, "octo-runtime-executor-kernel.pid")
     };
 }
 export function accountKeyFor(subjectType, subjectId) {
     if (subjectType !== "user" || !subjectId.trim()) {
-        throw new DaemonRuntimeError("SUBJECT_INVALID", "home", false, "a stable user subject is required");
+        throw new HostRuntimeError("SUBJECT_INVALID", "home", false, "a stable user subject is required");
     }
     return base32Hash(`${subjectType}\0${subjectId.trim()}`, 20);
 }
 export function profileNameFor(appId, tenantId) {
     if (!tenantId.trim())
-        throw new DaemonRuntimeError("TENANT_INVALID", "home", false, "tenant id is required");
+        throw new HostRuntimeError("TENANT_INVALID", "home", false, "tenant id is required");
     const name = `${appSlug(appId)}-${base32Hash(tenantId.trim(), 20)}`;
     if (!PROFILE_PATTERN.test(name)) {
-        throw new DaemonRuntimeError("PROFILE_INVALID", "home", false, `generated profile is invalid: ${name}`);
+        throw new HostRuntimeError("PROFILE_INVALID", "home", false, `generated profile is invalid: ${name}`);
     }
     return name;
 }
@@ -65,7 +60,7 @@ export function accountPaths(paths, accountKey) {
 }
 export function profilePaths(account, name) {
     if (!PROFILE_PATTERN.test(name))
-        throw new DaemonRuntimeError("PROFILE_INVALID", "home", false, `invalid profile: ${name}`);
+        throw new HostRuntimeError("PROFILE_INVALID", "home", false, `invalid profile: ${name}`);
     const root = join(account.root, name);
     return {
         name,
@@ -75,7 +70,7 @@ export function profilePaths(account, name) {
         credentialFile: join(root, "credentials", "runtime-token.json")
     };
 }
-export function ensureDaemonHome(paths) {
+export function ensureHostHome(paths) {
     for (const directory of [paths.home, paths.run, join(paths.home, "accounts")])
         mkdirSync(directory, { recursive: true });
     if (process.platform !== "win32")
@@ -83,7 +78,7 @@ export function ensureDaemonHome(paths) {
     if (existsSync(paths.machineFile)) {
         const machine = readJson(paths.machineFile);
         if (machine.schema_version !== 1 || !MACHINE_PATTERN.test(machine.machine_id)) {
-            throw new DaemonRuntimeError("MACHINE_INVALID", "home", false, `invalid machine identity: ${paths.machineFile}`);
+            throw new HostRuntimeError("MACHINE_INVALID", "home", false, `invalid machine identity: ${paths.machineFile}`);
         }
         return machine;
     }
@@ -93,7 +88,7 @@ export function ensureDaemonHome(paths) {
 }
 export function ensureAccount(account, profiles) {
     if (profiles.length === 0)
-        throw new DaemonRuntimeError("TENANTS_EMPTY", "home", false, "at least one authorized tenant is required");
+        throw new HostRuntimeError("TENANTS_EMPTY", "home", false, "at least one authorized tenant is required");
     for (const profile of profiles) {
         const paths = profilePaths(account, profile);
         mkdirSync(dirname(paths.identityFile), { recursive: true });
@@ -111,48 +106,12 @@ export function ensureAccount(account, profiles) {
         channel: "stable"
     });
 }
-export function acquireOwnerLock(paths) {
-    mkdirSync(paths.run, { recursive: true });
-    const nonce = randomUUID();
-    const acquire = () => openSync(paths.ownerLock, "wx", 0o600);
-    let fd;
-    try {
-        fd = acquire();
-    }
-    catch (error) {
-        if (!isNodeError(error, "EEXIST") || lockOwnerAlive(paths.ownerLock)) {
-            throw new DaemonRuntimeError("HOME_LOCKED", "home", false, "Embedded Runtime Home is owned by another process", { cause: error });
-        }
-        rmSync(paths.ownerLock, { force: true });
-        fd = acquire();
-    }
-    writeFileSync(fd, `${JSON.stringify({ schema_version: 1, pid: process.pid, nonce, created_at: new Date().toISOString() })}\n`);
-    fsyncSync(fd);
-    let released = false;
-    return {
-        nonce,
-        release() {
-            if (released)
-                return;
-            released = true;
-            closeSync(fd);
-            try {
-                const current = readJson(paths.ownerLock);
-                if (current.nonce === nonce)
-                    rmSync(paths.ownerLock, { force: true });
-            }
-            catch {
-                // A missing lock is already released; a replaced lock belongs to another session.
-            }
-        }
-    };
-}
 export function readJson(path) {
     try {
         return JSON.parse(readFileSync(path, "utf8"));
     }
     catch (error) {
-        throw new DaemonRuntimeError("LOCAL_STATE_INVALID", "home", false, `cannot read ${path}`, {
+        throw new HostRuntimeError("LOCAL_STATE_INVALID", "home", false, `cannot read ${path}`, {
             cause: error
         });
     }
@@ -185,16 +144,16 @@ export function removeFile(path) {
 function validateHome(homeInput, platform) {
     const pathApi = platform === "win32" ? win32 : { isAbsolute, resolve, parse };
     if (!homeInput.trim() || !pathApi.isAbsolute(homeInput)) {
-        throw new DaemonRuntimeError("HOME_INVALID", "home", false, "Embedded Runtime Home must be an absolute path");
+        throw new HostRuntimeError("HOME_INVALID", "home", false, "Embedded Runtime Home must be an absolute path");
     }
     const home = pathApi.resolve(homeInput);
     const root = pathApi.parse(home).root;
     if (home === root)
-        throw new DaemonRuntimeError("HOME_INVALID", "home", false, "filesystem root cannot be used as Embedded Runtime Home");
+        throw new HostRuntimeError("HOME_INVALID", "home", false, "filesystem root cannot be used as Embedded Runtime Home");
     if (platform === "win32") {
         const input = homeInput.replaceAll("/", "\\");
         if (input.startsWith("\\\\") || input.startsWith("\\\\?\\") || /^[A-Za-z]:[^\\]/.test(input)) {
-            throw new DaemonRuntimeError("HOME_UNSUPPORTED", "home", false, "Windows Embedded Runtime Home must be a local absolute path");
+            throw new HostRuntimeError("HOME_UNSUPPORTED", "home", false, "Windows Embedded Runtime Home must be a local absolute path");
         }
     }
     return home;
@@ -207,7 +166,7 @@ function appSlug(appId) {
         .replace(/^-+|-+$/g, "")
         .slice(0, 48);
     if (!slug || !/^[a-z0-9]/.test(slug)) {
-        throw new DaemonRuntimeError("APP_ID_INVALID", "home", false, "appId must contain an ASCII letter or digit");
+        throw new HostRuntimeError("APP_ID_INVALID", "home", false, "appId must contain an ASCII letter or digit");
     }
     return slug;
 }
@@ -247,19 +206,9 @@ function renameWithRetry(source, target) {
         }
     }
     rmSync(source, { force: true });
-    throw new DaemonRuntimeError("WRITE_FAILED", "home", true, `cannot atomically replace ${target}`, { cause: lastError });
-}
-function lockOwnerAlive(path) {
-    try {
-        const lock = readJson(path);
-        if (!Number.isSafeInteger(lock.pid) || Number(lock.pid) <= 0)
-            return false;
-        process.kill(Number(lock.pid), 0);
-        return true;
-    }
-    catch (error) {
-        return isNodeError(error, "EPERM");
-    }
+    throw new HostRuntimeError("WRITE_FAILED", "home", true, `cannot atomically replace ${target}`, {
+        cause: lastError
+    });
 }
 function isNodeError(error, code) {
     return (error instanceof Error && "code" in error && error.code === code);

package/node_modules/@mininglamp-oss/{octo-runtime-daemon/dist/runtime → octo-runtime-host-sdk/dist}/identity.d.ts

@@ -1,4 +1,4 @@
-import { type DaemonProfilePaths } from "./home.js";
+import { type HostProfilePaths } from "./home.js";
 import type { AuthorizedTenant } from "./types.js";
 export interface LocalRuntimeIdentity {
     schema_version: 1;
@@ -8,4 +8,4 @@ export interface LocalRuntimeIdentity {
     credential_id?: string;
     enrolled_at?: string;
 }
-export declare function ensureLocalRuntime(profile: DaemonProfilePaths, tenant: AuthorizedTenant): LocalRuntimeIdentity;
+export declare function ensureLocalRuntime(profile: HostProfilePaths, tenant: AuthorizedTenant): LocalRuntimeIdentity;

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { RUNTIME_RUN_CONTRACT } from "@mininglamp-oss/octo-runtime-protocol";
+export type { RuntimeLoggingOptions, ExtraStatusRecord } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+export * from "./extras.js";
+export * from "./extra-config.js";
+export * from "./context-loader.js";
+export * from "./extra-service.js";
+export * from "./endpoint.js";
+export * from "./home.js";
+export * from "./identity.js";
+export * from "./native.js";
+export type { CleanupResult } from "./launch.js";
+export { ComponentStartError } from "./launch.js";

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/index.js

@@ -0,0 +1,10 @@
+export { RUNTIME_RUN_CONTRACT } from "@mininglamp-oss/octo-runtime-protocol";
+export * from "./extras.js";
+export * from "./extra-config.js";
+export * from "./context-loader.js";
+export * from "./extra-service.js";
+export * from "./endpoint.js";
+export * from "./home.js";
+export * from "./identity.js";
+export * from "./native.js";
+export { ComponentStartError } from "./launch.js";

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/launch.d.ts

@@ -0,0 +1,15 @@
+/** Cleanup contract for explicitly configured external native executables. */
+export interface CleanupResult {
+    complete: boolean;
+    processExited: boolean;
+    pendingResources: string[];
+    errors: {
+        code: string;
+        component: string;
+    }[];
+}
+export declare class ComponentStartError extends Error {
+    readonly cleanup: CleanupResult;
+    constructor(cause: unknown, cleanup: CleanupResult);
+}
+export declare function deadline<T>(operation: Promise<T>, timeoutMs: number, code: string): Promise<T>;

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/launch.js

@@ -0,0 +1,22 @@
+export class ComponentStartError extends Error {
+    cleanup;
+    constructor(cause, cleanup) {
+        super(cause instanceof Error ? cause.message : "COMPONENT_START_FAILED", { cause });
+        this.cleanup = cleanup;
+        this.name = "ComponentStartError";
+    }
+}
+export async function deadline(operation, timeoutMs, code) {
+    let timer;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(code)), timeoutMs);
+            })
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/native.d.ts

@@ -0,0 +1,16 @@
+import { type CleanupResult } from "./launch.js";
+export interface NativeComponentOptions {
+    executable: string;
+    argv: string[];
+    cwd: string;
+    configPath: string;
+    endpoint: string;
+    stop: "stdin-json" | "signal";
+    readiness: "ipc" | "process";
+}
+/** 原生组件拥有独立进程树，参数始终按 argv 传递，不经过 shell。 */
+export declare function startNativeComponent(options: NativeComponentOptions): Promise<{
+    ownership: "owned";
+    pid: number;
+    stop: () => Promise<CleanupResult>;
+}>;

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/native.js

@@ -0,0 +1,160 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { once } from "node:events";
+import net from "node:net";
+import { createProcessCleanup } from "@mininglamp-oss/octo-runtime-adapter-sdk/process-cleanup";
+import { readBoundedLines } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { ComponentStartError, deadline } from "./launch.js";
+/** 原生组件拥有独立进程树，参数始终按 argv 传递，不经过 shell。 */
+export async function startNativeComponent(options) {
+    for (const path of [options.executable, options.cwd, options.configPath])
+        if (!isAbsolute(path))
+            throw new Error("COMPONENT_PATH_INVALID");
+    if (options.argv.some((arg) => /^--(?:config|endpoint)(?:=|$)/.test(arg)))
+        throw new Error("COMPONENT_RESERVED_ARGUMENT");
+    const child = spawn(options.executable, [...options.argv, "--config", options.configPath, "--endpoint", options.endpoint], {
+        cwd: options.cwd,
+        shell: false,
+        stdio: ["pipe", "pipe", "ignore"],
+        detached: process.platform !== "win32"
+    });
+    const cleanup = createProcessCleanup(child, {
+        processGroup: process.platform !== "win32",
+        processTree: true
+    });
+    let ack;
+    child.stdin.on("error", () => ack?.reject(new Error("COMPONENT_INPUT_CLOSED")));
+    child.on("error", () => ack?.reject(new Error("COMPONENT_EXITED")));
+    child.once("exit", () => ack?.reject(new Error("COMPONENT_CLEANUP_UNCONFIRMED")));
+    const stopInput = readBoundedLines(child.stdout, 4096, {
+        onError: () => { },
+        onTooLarge: () => { },
+        onClose: () => { },
+        onLine(line) {
+            try {
+                const value = JSON.parse(line);
+                if (ack && value.type === "component.stopped" && value.request_id === ack.id) {
+                    if (value.complete === true)
+                        ack.resolve();
+                    else
+                        ack.reject(new Error("COMPONENT_CLEANUP_INCOMPLETE"));
+                }
+            }
+            catch {
+                /* 原生组件 stdout 不作诊断或业务数据来源。 */
+            }
+        }
+    });
+    let closing;
+    const stop = () => (closing ??= (async () => {
+        const errors = [];
+        if (child.exitCode === null && child.signalCode === null) {
+            try {
+                if (options.stop === "stdin-json") {
+                    const pending = new Promise((resolve, reject) => {
+                        ack = { id: randomUUID(), resolve, reject };
+                    });
+                    void pending.catch(() => undefined);
+                    child.stdin.write(`${JSON.stringify({ type: "component.stop", request_id: ack.id })}\n`);
+                    await deadline(pending, 5000, "COMPONENT_STOP_TIMEOUT");
+                }
+                else {
+                    child.kill("SIGTERM");
+                    await deadline(once(child, "exit"), 5000, "COMPONENT_STOP_TIMEOUT");
+                }
+            }
+            catch {
+                errors.push({ component: options.executable, code: "COMPONENT_CLEANUP_INCOMPLETE" });
+            }
+        }
+        else {
+            errors.push({ component: options.executable, code: "COMPONENT_CLEANUP_UNCONFIRMED" });
+        }
+        try {
+            await cleanup();
+        }
+        catch {
+            errors.push({ component: options.executable, code: "PROCESS_CLEANUP_INCOMPLETE" });
+        }
+        finally {
+            stopInput();
+        }
+        const processExited = child.exitCode !== null || child.signalCode !== null;
+        return {
+            complete: !errors.length && processExited,
+            processExited,
+            errors,
+            pendingResources: errors.length ? ["native"] : []
+        };
+    })());
+    try {
+        await deadline(once(child, "spawn"), 5000, "COMPONENT_START_TIMEOUT");
+        if (options.readiness === "ipc") {
+            const until = Date.now() + 30_000;
+            while (true) {
+                if (child.exitCode !== null || child.signalCode !== null)
+                    throw new Error("COMPONENT_EXITED");
+                try {
+                    await nativeStatus(options.endpoint, child.pid);
+                    break;
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message === "COMPONENT_IDENTITY_MISMATCH")
+                        throw error;
+                    if (Date.now() >= until)
+                        throw new Error("COMPONENT_START_TIMEOUT", { cause: error });
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                }
+            }
+        }
+    }
+    catch (error) {
+        throw new ComponentStartError(error, await stop());
+    }
+    return { ownership: "owned", pid: child.pid, stop };
+}
+async function nativeStatus(endpoint, pid) {
+    await new Promise((resolve, reject) => {
+        const socket = net.createConnection(endpoint);
+        const requestId = randomUUID();
+        let bytes = "";
+        socket.setTimeout(1000, () => {
+            socket.destroy();
+            reject(new Error("COMPONENT_UNAVAILABLE"));
+        });
+        socket.on("error", reject);
+        socket.on("connect", () => socket.write(`${JSON.stringify({ jsonrpc: "2.0", id: requestId, method: "status", params: {} })}\n`));
+        socket.on("data", (chunk) => {
+            bytes += chunk.toString();
+            if (bytes.length > 4096) {
+                socket.destroy();
+                reject(new Error("COMPONENT_STATUS_INVALID"));
+            }
+            if (bytes.includes("\n")) {
+                try {
+                    const reply = JSON.parse(bytes.slice(0, bytes.indexOf("\n")));
+                    if (reply.jsonrpc !== "2.0" || reply.id !== requestId || !reply.result)
+                        throw new Error();
+                    if (typeof reply.result !== "object" ||
+                        !("pid" in reply.result) ||
+                        reply.result.pid !== pid) {
+                        socket.destroy();
+                        reject(new Error("COMPONENT_IDENTITY_MISMATCH"));
+                        return;
+                    }
+                    resolve();
+                }
+                catch {
+                    reject(new Error("COMPONENT_STATUS_INVALID"));
+                }
+                socket.destroy();
+            }
+        });
+        socket.on("end", () => {
+            if (!bytes.includes("\n"))
+                reject(new Error("COMPONENT_UNAVAILABLE"));
+        });
+        socket.on("close", () => reject(new Error("COMPONENT_UNAVAILABLE")));
+    });
+}

package/node_modules/@mininglamp-oss/octo-runtime-host-sdk/dist/shutdown.d.ts

@@ -0,0 +1,7 @@
+/** 私有关闭预算；不增加 ExtraContext 的公开字段或插件 ABI。 */
+export declare function shutdownDeadline(signal?: AbortSignal): number;
+export declare function withShutdownDeadline<T>(until: number, operation: () => T): T;
+export declare function abortForShutdown(controller: AbortController): void;
+export declare function shutdownSignal(signals: AbortSignal[]): AbortSignal;
+/** 只限制等待时间，不强停 operation；owner 须在到期后撤销迟到操作的写入和投递权限。 */
+export declare function withinShutdown<T>(operation: Promise<T>, until: number, code: string): Promise<T>;