@mininglamp-oss/octo-runtime 1.0.1 → 1.1.0

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/dist/rpc.d.ts

@@ -1,12 +1,12 @@
 import type { Readable, Writable } from "node:stream";
 import { type RuntimeLog, type AdapterProbeOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
 import { type InputFrames, type InvokeInput, type InvokeEnvironment, type InputInvoke, type HostFrame, type NativeInteractionResponse, type InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
-import type { AdapterHost, HostedAdapterMetadata } from "./index.js";
+import type { AgentExecutor, HostedAdapterMetadata } from "@mininglamp-oss/octo-runtime-executor-core";
 type JsonRecord = Record<string, unknown>;
 export type RpcTraceDirection = "send" | "receive";
 export type RpcTrace = (direction: RpcTraceDirection, frame: string) => void;
-/** Stable client contract used by daemon-owned host lifecycle wrappers. */
-export interface AdapterHostRpc {
+/** Kernel 到 worker 的内部执行合同；取消回执 cancelled 由外层 RPC 映射为 accepted，均不表示终态。 */
+export interface WorkerRpc {
     list(configurations?: Record<string, AdapterProbeOptions>): Promise<HostedAdapterMetadata[]>;
     probe(adapterType: string, options?: AdapterProbeOptions): Promise<unknown>;
     cancel(invocationId: string, reason?: string): Promise<{
@@ -18,14 +18,13 @@ export interface AdapterHostRpc {
     invokeFrames: InputFrames;
 }
 /**
- * Expose an AdapterHost as a line-delimited JSON-RPC 2.0 service.
- * Ordinary methods use request/response; a long-running invoke uses an ACK plus
- * a notification event stream.
+ * 在 worker 中将唯一 AgentExecutor 暴露为 stdio NDJSON JSON-RPC 服务。
+ * 普通方法是一问一答；invoke 先返回接纳凭据，再发送通知流，不与 Kernel 对外 socket 协议混用。
  */
-export declare class AdapterHostRpcServer {
+export declare class WorkerRpcServer {
     #private;
     constructor({ host, output, trace, log }: {
-        host: AdapterHost;
+        host: AgentExecutor;
         output: Writable;
         trace?: RpcTrace;
         log?: RuntimeLog;
@@ -33,8 +32,11 @@ export declare class AdapterHostRpcServer {
     /** Start consuming the input stream; each line must be one complete JSON-RPC object. */
     listen(input: Readable): void;
 }
-/** The async client for AdapterHostRpcServer; it also reassembles invoke notifications back into an AsyncGenerator. */
-export declare class AdapterHostRpcClient implements AdapterHostRpc {
+/**
+ * Kernel 持有的 worker RPC 客户端，将按身份校验的通知还原为有界异步流。
+ * 这里只管理逻辑请求与流；进程存活、心跳和回收由 WorkerSupervisor/WorkerProcess 负责。
+ */
+export declare class WorkerRpcClient implements WorkerRpc {
     #private;
     readonly invoke: InputInvoke;
     constructor({ input, output, trace, maximumInputBytes }: {
@@ -45,7 +47,7 @@ export declare class AdapterHostRpcClient implements AdapterHostRpc {
     });
     /** Send an ordinary JSON-RPC request and await the matching response by random ID. */
     request<T = unknown>(method: string, params?: JsonRecord, signal?: AbortSignal): Promise<T>;
-    /** Close the logical connection and end every pending request/invocation with the same error. */
+    /** 用同一故障结束所有逻辑请求/流；不终止进程，owner 仍须调用 WorkerProcess.close。 */
     close(error?: Error): void;
     list(configurations?: Record<string, AdapterProbeOptions>): Promise<HostedAdapterMetadata[]>;
     probe(adapterType: string, options?: AdapterProbeOptions): Promise<unknown>;

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/dist/rpc.js

@@ -95,11 +95,10 @@ function writer(output, trace, onError) {
     };
 }
 /**
- * Expose an AdapterHost as a line-delimited JSON-RPC 2.0 service.
- * Ordinary methods use request/response; a long-running invoke uses an ACK plus
- * a notification event stream.
+ * 在 worker 中将唯一 AgentExecutor 暴露为 stdio NDJSON JSON-RPC 服务。
+ * 普通方法是一问一答；invoke 先返回接纳凭据，再发送通知流，不与 Kernel 对外 socket 协议混用。
  */
-export class AdapterHostRpcServer {
+export class WorkerRpcServer {
     #log;
     #controllers = new Map();
     #host;
@@ -329,7 +328,16 @@ export class AdapterHostRpcServer {
         for (const controller of this.#controllers.values())
             controller.abort(error);
         this.#controllers.clear();
-        void this.#host.shutdown(error.message).catch(() => undefined);
+        void this.#host
+            .shutdown(error.message)
+            .then((result) => {
+            if (result.cleanup === "incomplete")
+                this.#log("error", "rpc.cleanup_incomplete", {
+                    code: "EXECUTOR_CLEANUP_INCOMPLETE",
+                    unresolved_count: result.unresolvedInvocationIds.length
+                });
+        })
+            .catch(() => undefined);
     }
     #waitForDrain() {
         return new Promise((resolve, reject) => {
@@ -355,8 +363,11 @@ export class AdapterHostRpcServer {
         });
     }
 }
-/** The async client for AdapterHostRpcServer; it also reassembles invoke notifications back into an AsyncGenerator. */
-export class AdapterHostRpcClient {
+/**
+ * Kernel 持有的 worker RPC 客户端，将按身份校验的通知还原为有界异步流。
+ * 这里只管理逻辑请求与流；进程存活、心跳和回收由 WorkerSupervisor/WorkerProcess 负责。
+ */
+export class WorkerRpcClient {
     invoke = createInputInvoke((input, environment) => this.invokeFrames(input, environment));
     #send;
     #pending = new Map();
@@ -470,7 +481,7 @@ export class AdapterHostRpcClient {
         this.#send(message);
         return promise;
     }
-    /** Close the logical connection and end every pending request/invocation with the same error. */
+    /** 用同一故障结束所有逻辑请求/流；不终止进程，owner 仍须调用 WorkerProcess.close。 */
     close(error = new Error("adapter-host client closed")) {
         if (this.#closedError)
             return;

package/node_modules/@mininglamp-oss/{octo-runtime-adapter-host → octo-runtime-executor-kernel}/dist/runner.js

@@ -1,23 +1,19 @@
 #!/usr/bin/env node
-// Standalone adapter-host process: load the adapters listed in a JSON manifest,
-// register them into an AdapterHost, then serve invocations over NDJSON JSON-RPC
-// on stdio (the daemon-to-host transport). Kept separate from the daemon so
-// provider processes are isolated behind a process boundary.
+// CLI 使用的独立 worker 入口：只加载显式 manifest 中的 Adapter，注册到唯一 AgentExecutor。
+// 通过 stdio NDJSON 为父 Kernel 提供执行；SDK 可用自有代码入口调用 serveWorker，毋须采用此 manifest。
 import { readFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { serveAdapterHost } from "./index.js";
+import { resolve } from "node:path";
+import { resolveAdapterModuleSpecifier } from "./module-specifier.js";
+import { serveWorker } from "./index.js";
 const index = process.argv.indexOf("--manifest");
 if (index < 0 || !process.argv[index + 1])
-    throw new Error("usage: octo-runtime-adapter-host --manifest <file>");
+    throw new Error("usage: octo-runtime-executor-kernel --manifest <file>");
 const manifestPath = resolve(process.argv[index + 1]);
 const rawManifest = JSON.parse(await readFile(manifestPath, "utf8"));
 const manifest = parseManifest(rawManifest);
 const adapters = [];
 for (const entry of manifest.adapters) {
-    const specifier = entry.module.startsWith(".") || entry.module.startsWith("/")
-        ? pathToFileURL(resolve(dirname(manifestPath), entry.module)).href
-        : entry.module;
+    const specifier = resolveAdapterModuleSpecifier(entry.module, manifestPath);
     const loaded = await import(specifier);
     const moduleExports = asRecord(loaded, `adapter module ${entry.module}`);
     const exported = moduleExports[entry.exportName];
@@ -36,7 +32,7 @@ for (const entry of manifest.adapters) {
     adapters.push(instance);
 }
 // JSON 是 CLI 的装配来源；注册、RPC 和退出清理与 SDK 的代码入口共用。
-serveAdapterHost(adapters);
+serveWorker(adapters);
 /** Parse and validate the on-disk manifest. Only version 1 is supported; each
  * entry names a module, an export, whether that export is a factory, and options. */
 function parseManifest(value) {

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/serve.d.ts

@@ -0,0 +1,10 @@
+import { type HostedAdapter } from "@mininglamp-oss/octo-runtime-executor-core";
+import { type RuntimeLoggingOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/**
+ * 在当前独立 worker 子进程中提供 Core 执行服务。调用方已经决定加载集合：
+ * CLI 可从自己的 JSON 动态加载，SDK 可直接 import；这里不扫描或补齐任何 Adapter。
+ * 该函数只在 worker 入口调用；宿主 App 和 Kernel 监督进程通过客户端接入，不直接调用。
+ */
+export declare function serveWorker(adapters: readonly HostedAdapter[], options?: {
+    logging?: RuntimeLoggingOptions;
+}): void;

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/serve.js

@@ -0,0 +1,65 @@
+import { AgentExecutor } from "@mininglamp-oss/octo-runtime-executor-core";
+import { WorkerRpcServer } from "./rpc.js";
+import { RuntimeLogging } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/**
+ * 在当前独立 worker 子进程中提供 Core 执行服务。调用方已经决定加载集合：
+ * CLI 可从自己的 JSON 动态加载，SDK 可直接 import；这里不扫描或补齐任何 Adapter。
+ * 该函数只在 worker 入口调用；宿主 App 和 Kernel 监督进程通过客户端接入，不直接调用。
+ */
+export function serveWorker(adapters, options = {}) {
+    const logging = new RuntimeLogging(options.logging ??
+        (process.env.OCTO_RUNTIME_LOGS_DIRECTORY
+            ? { directory: process.env.OCTO_RUNTIME_LOGS_DIRECTORY }
+            : undefined));
+    process.on("uncaughtExceptionMonitor", () => logging.kernel("error", "host.uncaught", { code: "HOST_UNCAUGHT_EXCEPTION" }));
+    const host = new AgentExecutor({ log: logging.kernel });
+    for (const adapter of adapters) {
+        // 注册阶段保留协议校验和重复类型检查，失败时不建立就绪的 RPC 服务。
+        host.register(adapter);
+        logging.kernel("info", "adapter.registered", { adapter_type: adapter.metadata.type });
+    }
+    // 仅服务已注册集合；Kernel 监督器通过首次 list 握手确认 worker 就绪。
+    // 注册不代表 Provider 已安装或认证，实际可用性由 probe 和调用结果说明。
+    new WorkerRpcServer({
+        host,
+        output: process.stdout,
+        log: logging.kernel
+    }).listen(process.stdin);
+    logging.kernel("info", "host.ready");
+    // 父 Kernel 断开或停止时等待 Core 取消和清理；需要替换时由 Kernel 监督器重启相同入口。
+    let stopping = false;
+    const stop = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        void host.shutdown().then(async (result) => {
+            if (result.cleanup === "incomplete") {
+                logging.kernel("error", "host.cleanup_incomplete", {
+                    code: "EXECUTOR_CLEANUP_INCOMPLETE",
+                    unresolved_count: result.unresolvedInvocationIds.length
+                });
+            }
+            await logging.close();
+            process.exit(result.cleanup === "complete" ? 0 : 1);
+        }, async () => {
+            await logging.close();
+            process.exit(1);
+        });
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    process.once("SIGHUP", stop);
+    process.stdin.once("end", stop);
+    process.stdin.once("close", stop);
+    // 心跳必须由执行进程主事件循环处理；独立线程应答会掩盖执行线程阻塞。
+    process.on("message", (message) => {
+        if (message &&
+            typeof message === "object" &&
+            "type" in message &&
+            message.type === "kernel.ping" &&
+            process.connected) {
+            process.send?.({ type: "worker.pong" });
+        }
+    });
+    process.once("disconnect", stop);
+}

package/node_modules/@mininglamp-oss/octo-runtime-executor-kernel/dist/server.d.ts

@@ -0,0 +1,19 @@
+import { type AdapterProbeOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { type KernelStatus } from "./types.js";
+export interface KernelServerOptions {
+    endpoint: string;
+    workerEntrypoint: string;
+    manifest?: string;
+    env?: NodeJS.ProcessEnv;
+    adapterConfigurations?: Record<string, AdapterProbeOptions>;
+    stateDirectory?: string;
+    configurations?: (runtimeId?: string) => Record<string, AdapterProbeOptions>;
+}
+/**
+ * 创建独立 Kernel 的本地 RPC 端点，独占端点租约、Run 事件源与 worker 监督器。
+ * 启动失败也执行回收；close 失败会保留所有权证据，客户端断开不等同于 owner 关闭。
+ */
+export declare function startKernelServer(options: KernelServerOptions, signal?: AbortSignal): Promise<{
+    status: () => KernelStatus;
+    close(): Promise<void>;
+}>;