@mininglamp-oss/octo-runtime 1.0.1 → 1.1.1

package/{apps/cli/dist/default_adapters.json → node_modules/@mininglamp-oss/octo-runtime-cli/dist/manifest.json}

@@ -61,5 +61,10 @@
       "module": "@mininglamp-oss/octo-runtime-adapter-antigravity",
       "export": "antigravityAdapter"
     }
+  ],
+  "extras": [
+    { "name": "channel-gateway", "module": "@mininglamp-oss/octo-runtime-extra-channel-gateway" },
+    { "name": "channel-wecom", "module": "@mininglamp-oss/octo-runtime-extra-channel-wecom" },
+    { "name": "webui", "module": "@mininglamp-oss/octo-runtime-extra-webui" }
   ]
 }

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/module-manifest.d.ts

@@ -0,0 +1,3 @@
+import { type ModuleManifest } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
+/** CLI 独占默认目录与 Home 扩展策略；SDK 原生装配不读取这两份文件。 */
+export declare function loadCliManifest(home: string, override?: string, report?: (message: string) => void): Promise<ModuleManifest>;

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/module-manifest.js

@@ -0,0 +1,11 @@
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mergeModuleManifests, readModuleManifest } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
+/** CLI 独占默认目录与 Home 扩展策略；SDK 原生装配不读取这两份文件。 */
+export async function loadCliManifest(home, override, report = (message) => console.error(message)) {
+    if (override)
+        return readModuleManifest(resolve(override), { legacy: true });
+    const builtin = await readModuleManifest(fileURLToPath(new URL("./manifest.json", import.meta.url)));
+    const extension = await readModuleManifest(join(home, "manifest.json"), { optional: true });
+    return mergeModuleManifests(builtin, extension, report);
+}

package/node_modules/@mininglamp-oss/{octo-runtime-daemon-app → octo-runtime-cli}/dist/openclaw.d.ts

@@ -1,4 +1,4 @@
-import type { ExtraRegistration } from "@mininglamp-oss/octo-runtime-daemon";
+import type { ExtraRegistration } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { type OpenClawConnectionInput } from "@mininglamp-oss/octo-runtime-adapter-openclaw";
 export interface CliOpenClawInput extends OpenClawConnectionInput {
     openclawHome?: string;

package/node_modules/@mininglamp-oss/{octo-runtime-daemon-app → octo-runtime-cli}/dist/openclaw.js

@@ -1,7 +1,6 @@
 import { readFile, mkdir, writeFile, rename, lstat, chmod, rm } from "node:fs/promises";
 import { parseEnv, promisify } from "node:util";
 import { execFile } from "node:child_process";
-import { configuredCredential, validateImBots, octoCliEnvironment } from "@mininglamp-oss/octo-runtime-extra-channel-gateway";
 import { randomUUID } from "node:crypto";
 import { isIP } from "node:net";
 import { homedir, networkInterfaces } from "node:os";
@@ -103,15 +102,40 @@ export async function syncCliOpenClawToolEnvironment(runtimeRoot, extras) {
     if (!channel || channel.config.bots === undefined)
         return { written: false, restartRequired: false };
     const bots = channel.config.bots;
-    validateImBots(bots);
+    if (!Array.isArray(bots) || bots.length > 64)
+        throw new Error("IM_CONFIG_LIST_REQUIRED");
     let values;
-    for (const bot of bots) {
-        if (bot.enabled === false || bot.adapter.adapter_type !== "openclaw")
+    for (const value of bots) {
+        const bot = record(value);
+        if (!bot)
+            throw new Error("IM_CONFIG_INVALID");
+        if (bot.enabled === false || record(bot.adapter)?.adapter_type !== "openclaw")
             continue;
-        const token = configuredCredential(bot);
+        const token = typeof bot.bf_token === "string" ? bot.bf_token.trim() : undefined;
         if (!token)
             throw new Error("IM_CREDENTIALS_REQUIRED");
-        values = Object.fromEntries(octoCliEnvironment(bot.api_url, token).env_variables.map(({ key, value }) => [key, value]));
+        // CLI 仅校验自己要写入的工具身份；完整 Bot 配置由启动后的 Extra 校验。
+        // 不为 Kernel 的 dotenv 同步导入整个业务 Extra，否则未启动 Extra 缺包也会阻塞 Kernel。
+        if (!/^bf_[A-Za-z0-9_-]+$/.test(token))
+            throw new Error("IM_BOT_TOKEN_INVALID");
+        let url;
+        try {
+            if (typeof bot.api_url !== "string")
+                throw new Error();
+            url = new URL(bot.api_url);
+        }
+        catch {
+            throw new Error("IM_API_URL_INVALID");
+        }
+        if (url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            (url.protocol !== "https:" &&
+                !(url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))))
+            throw new Error("IM_API_URL_INVALID");
+        url.pathname = url.pathname.replace(/\/+$/, "").replace(/\/api$/, "");
+        values = { OCTO_BOT_TOKEN: token, OCTO_API_BASE_URL: url.href.replace(/\/+$/, "") };
     }
     if (!values)
         return { written: false, restartRequired: false };

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/output.d.ts

@@ -0,0 +1,20 @@
+import type { ServiceStatus } from "@mininglamp-oss/octo-runtime-cross-service";
+export interface ComponentSnapshot {
+    service: ServiceStatus;
+    runtime: unknown;
+}
+/** 展示公开状态的摘要，不为输出克隆完整 session/delivery 集合。JSON 模式保留原结果。 */
+export declare function formatStatus(name: string, snapshot: ComponentSnapshot): string;
+/** 只保留受控错误码和管理器元信息；异常正文及任意 stderr 可能含凭据，不能直出。 */
+export declare function describeError(error: unknown, fallback?: string): {
+    backend?: import("@mininglamp-oss/octo-runtime-cross-service").ServiceBackendKind | undefined;
+    command?: string | undefined;
+    exit_code?: number | undefined;
+    cause_code?: string | undefined;
+    code: string;
+    message: string;
+};
+/** 前台启动失败沿既有白名单和小时轮转落盘；不捕获任意进程 stdout/stderr。 */
+export declare function recordStartupFailure(directory: string, component: string, error: unknown): Promise<void>;
+/** 只读本次 start 后的白名单失败事件；每个轮转文件最多读取末尾 64 KiB。 */
+export declare function readStartupFailure(directory: string, component: string, since: number): Promise<Error | undefined>;

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/output.js

@@ -0,0 +1,190 @@
+import { ServiceError } from "@mininglamp-oss/octo-runtime-cross-service";
+import { RuntimeLogging } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { open, readdir } from "node:fs/promises";
+import { join } from "node:path";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : {};
+const text = (value) => String(value)
+    .replace(/\p{Cc}/gu, " ")
+    .slice(0, 200);
+/** 展示公开状态的摘要，不为输出克隆完整 session/delivery 集合。JSON 模式保留原结果。 */
+export function formatStatus(name, snapshot) {
+    const service = snapshot.service;
+    const runtime = record(snapshot.runtime);
+    const business = record(runtime.status);
+    const ipc = runtime.available === false ? "unavailable" : "ready";
+    const lines = [
+        `${name}  service: ${service.state}  autostart: ${service.enabled ? "on" : "off"}  IPC: ${ipc}`,
+        `  Manager: ${service.manager}${service.pid ? `  PID: ${service.pid}` : runtime.pid ? `  PID: ${text(runtime.pid)}` : ""}`
+    ];
+    if (runtime.execution_ready !== undefined)
+        lines.push(`  Worker: ${runtime.execution_ready ? "ready" : "unavailable"}`);
+    if (runtime.available === false)
+        lines.push(`  Reason: ${text(record(runtime.error).code ?? "COMPONENT_UNAVAILABLE")}`);
+    if (service.lastExitCode !== undefined && service.lastExitCode !== 0)
+        lines.push(`  Last exit: ${service.lastExitCode}`);
+    if (service.definitionPath)
+        lines.push(`  Definition: ${service.definitionPath}`);
+    if (service.state === "unknown" && service.detail && /^[A-Z][A-Z0-9_]+$/.test(service.detail))
+        lines.push(`  Manager status: ${service.detail}`);
+    const summarize = (value, depth = 0) => {
+        if (Array.isArray(value))
+            return `${value.length} entries`;
+        if (value !== null && typeof value === "object") {
+            if (depth >= 2)
+                return "...";
+            return Object.entries(value)
+                .slice(0, 8)
+                .map(([key, item]) => `${text(key)}=${summarize(item, depth + 1)}`)
+                .join(", ");
+        }
+        return text(value);
+    };
+    const fields = (value) => {
+        const parts = Object.entries(value)
+            .filter(([key]) => ![
+            "bots",
+            "pid",
+            "name",
+            "kernel_available",
+            "connection_key",
+            "botId",
+            "bot_id",
+            "bot_name"
+        ].includes(key))
+            .slice(0, 24)
+            .map(([key, value]) => `${text(key)}: ${summarize(value)}`);
+        const rows = [];
+        for (const part of parts) {
+            const last = rows.length - 1;
+            if (last >= 0 && rows[last].length + part.length < 90)
+                rows[last] += `  ${part}`;
+            else
+                rows.push(part);
+        }
+        return rows;
+    };
+    if (business.kernel_available !== undefined)
+        lines.push(`  Kernel: ${business.kernel_available ? "ready" : "unavailable (service stays running)"}`);
+    const summary = fields(business);
+    lines.push(...summary.map((row) => `  ${row}`));
+    if (Array.isArray(business.bots)) {
+        lines.push(`  Bots: ${business.bots.length}`);
+        for (const bot of business.bots.slice(0, 20)) {
+            const value = record(bot);
+            lines.push(`    ${text(value.bot_name ?? value.name ?? value.type ?? "bot")}`);
+            lines.push(...fields(value).map((row) => `      ${row}`));
+        }
+        if (business.bots.length > 20)
+            lines.push("    ...");
+    }
+    if (service.drift.length)
+        lines.push(`  Drift: ${service.drift.map(text).join(", ")}`);
+    return lines.join("\n");
+}
+/** 只保留受控错误码和管理器元信息；异常正文及任意 stderr 可能含凭据，不能直出。 */
+export function describeError(error, fallback = "COMMAND_FAILED") {
+    const stableCode = (value) => typeof value === "string" && /^[A-Z][A-Z0-9_]{1,100}$/.test(value) ? value : undefined;
+    const value = record(error);
+    const code = stableCode(value.code) ??
+        (error instanceof Error ? stableCode(error.message) : undefined) ??
+        fallback;
+    const cause = record(value.cause);
+    const causeCode = stableCode(cause.code) ?? stableCode(cause.message);
+    const hints = {
+        COMMAND_FAILED: "The command failed. Check the native manager, configuration and service logs.",
+        ENOENT: "The component endpoint or required file does not exist. Check installation and service status.",
+        ECONNREFUSED: "The component is not accepting IPC connections. Check its process and logs.",
+        KERNEL_UNAVAILABLE: "Kernel is unavailable. Check executor-kernel status; Extras can remain running.",
+        INVALID_ARGUMENTS: "Use --help to see the available commands and flags.",
+        SETUP_IN_PROGRESS: "Another component lifecycle operation is in progress. Wait for it to finish, then retry.",
+        SERVICE_NOT_INSTALLED: "Run this component's install command, then start it.",
+        NOT_INSTALLED: "Run this component's install command, then start it.",
+        EXTRA_NOT_REGISTERED: "Save this Extra's declaration with extraset before starting it.",
+        EXTRA_MANIFEST_DECLARATION_REQUIRED: "Add this Extra's name and module to the selected Home manifest.json (extras array), then retry.",
+        EXTRA_MODULE_MIGRATION_REQUIRED: "The saved module differs from manifest.json. Review both declarations, then save matching module text or omit module from the Extra configuration.",
+        MANIFEST_INVALID: "Check manifest.json: version must be 1 and adapters/extras must be valid arrays without duplicate keys.",
+        MANAGER_UNAVAILABLE: "Run doctor and check the current user's native service manager.",
+        COMPONENT_UNAVAILABLE: "Check component status and the service logs; the IPC or worker is not ready.",
+        SERVICE_PROCESS_EXITED: "The service exited unexpectedly. Check its logs and configuration.",
+        SERVICE_INITIALIZATION_FAILED: "Check the component configuration, manifest and service logs.",
+        SERVICE_DISABLED: "Enable this component with install --autostart=true, then start it."
+    };
+    return {
+        code,
+        message: hints[code] ?? "Check --help, component status and service logs for this operation.",
+        ...(causeCode ? { cause_code: causeCode } : {}),
+        ...(error instanceof ServiceError
+            ? { backend: error.backend, command: error.command, exit_code: error.exitCode }
+            : {})
+    };
+}
+/** 前台启动失败沿既有白名单和小时轮转落盘；不捕获任意进程 stdout/stderr。 */
+export async function recordStartupFailure(directory, component, error) {
+    const logging = new RuntimeLogging({ directory });
+    try {
+        const log = component === "executor-kernel" ? logging.kernel : logging.extra(component);
+        const failure = describeError(error, "SERVICE_INITIALIZATION_FAILED");
+        if (failure.cause_code)
+            log("error", "cli.initialization_cause", { code: failure.cause_code });
+        log("error", "cli.initialization_failed", { code: failure.code });
+    }
+    finally {
+        await logging.close();
+    }
+}
+/** 只读本次 start 后的白名单失败事件；每个轮转文件最多读取末尾 64 KiB。 */
+export async function readStartupFailure(directory, component, since) {
+    const root = component === "executor-kernel" ? directory : join(directory, "extras");
+    const prefix = component === "executor-kernel" ? "kernel-" : `${component}-`;
+    try {
+        const names = (await readdir(root))
+            .filter((name) => name.startsWith(prefix) && /^.+-\d{8}T\d{2}\.log$/.test(name))
+            .sort()
+            .reverse()
+            .slice(0, 3);
+        for (const name of names) {
+            const file = await open(join(root, name), "r");
+            let content;
+            try {
+                const size = (await file.stat()).size;
+                const bytes = Buffer.alloc(Math.min(size, 65536));
+                await file.read(bytes, 0, bytes.length, Math.max(0, size - bytes.length));
+                content = bytes.toString("utf8");
+            }
+            finally {
+                await file.close();
+            }
+            let cause;
+            for (const line of content.split("\n")) {
+                let row;
+                try {
+                    row = record(JSON.parse(line));
+                }
+                catch {
+                    continue;
+                }
+                if (typeof row.time !== "string" ||
+                    !Number.isFinite(Date.parse(row.time)) ||
+                    Date.parse(row.time) < since)
+                    continue;
+                if (component === "executor-kernel"
+                    ? row.source !== "kernel"
+                    : row.source !== "extra" || row.extra_type !== component)
+                    continue;
+                const code = record(row.data).code;
+                if (typeof code !== "string" || !/^[A-Z][A-Z0-9_]{1,100}$/.test(code))
+                    continue;
+                if (row.event === "cli.initialization_cause")
+                    cause = code;
+                if (row.event === "cli.initialization_failed")
+                    return new Error(code, cause ? { cause: new Error(cause) } : undefined);
+            }
+        }
+    }
+    catch {
+        /* 日志是尽力诊断；缺失或损坏时仍按真实 IPC/管理器状态等待。 */
+    }
+    return undefined;
+}

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/playboard.js

@@ -1,9 +1,13 @@
-import { defaultRuntimeHome, runtimePaths } from "./state.js";
-import { resolve } from "node:path";
+import { defaultRuntimeHome, runtimePaths, readJsonFile } from "./state.js";
+import { loadCliManifest } from "./module-manifest.js";
+import { resolveAdapterModules } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
+import { readAdapterConfigurations, createKernelService } from "@mininglamp-oss/octo-runtime-executor-kernel";
 import { fileURLToPath } from "node:url";
-import { startTemporaryDaemon } from "./temporary-daemon.js";
-import { invokeDaemonRun } from "@mininglamp-oss/octo-runtime-daemon/runtime/run-stream";
-import { identifyInvokeInput, createInputInvoke, isHostTerminal, isTerminal } from "@mininglamp-oss/octo-runtime-protocol";
+import { componentEndpoint } from "@mininglamp-oss/octo-runtime-host-sdk";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { identifyInvokeInput, isHostTerminal, isTerminal } from "@mininglamp-oss/octo-runtime-protocol";
 import { INVOKE_REQUEST_MAX_BYTES } from "@mininglamp-oss/octo-runtime-protocol";
 export async function runPlayboard(options) {
     if (options.input.isTTY) {
@@ -59,21 +63,26 @@ export async function runPlayboard(options) {
         process.stdout.on("error", onOutputError);
     process.once("SIGINT", onInterrupt);
     process.once("SIGTERM", onTerminate);
-    let daemon;
+    let kernel;
+    const temporary = await mkdtemp(join(tmpdir(), "octo-playboard-"));
     try {
-        daemon = await startTemporaryDaemon({
-            home,
-            profile,
-            manifest: options.manifest
-                ? resolve(options.manifest)
-                : fileURLToPath(new URL("./default_adapters.json", import.meta.url)),
-            env: options.env ?? process.env,
-            signal: controller.signal
+        const paths = runtimePaths(home, profile);
+        const manifest = await loadCliManifest(home, options.manifest);
+        const configuration = await readJsonFile(paths.profileConfig);
+        kernel = createKernelService({
+            endpoint: process.platform === "win32" ? componentEndpoint(temporary) : join(temporary, "k.sock"),
+            workerEntrypoint: fileURLToPath(new URL("./worker.js", import.meta.url)),
+            adapterModules: resolveAdapterModules(manifest),
+            env: {
+                ...(options.env ?? process.env),
+                OCTO_RUNTIME_CLI_PROFILE_ROOT: paths.profileRoot,
+                OCTO_RUNTIME_CLI_SYNC_OPENCLAW_TOOLS: "0"
+            },
+            adapterConfigurations: readAdapterConfigurations(paths.profileRoot, configuration?.adapters)
         });
-        const socket = daemon.socket;
-        const invoke = createInputInvoke((input, environment) => invokeDaemonRun(socket, input, environment));
+        await kernel.initialize({ signal: controller.signal });
         let exitCode = 1;
-        for await (const frame of invoke(input, { signal: controller.signal })) {
+        for await (const frame of kernel.client.invoke(input, { signal: controller.signal })) {
             await output(JSON.stringify(frame));
             if (("kind" in frame &&
                 frame.kind === "control" &&
@@ -101,7 +110,8 @@ export async function runPlayboard(options) {
     }
     finally {
         try {
-            await daemon?.close();
+            await closeKernel(kernel);
+            await rm(temporary, { recursive: true, force: true });
         }
         finally {
             if (!options.output)
@@ -116,3 +126,8 @@ function writeLine(line) {
         process.stdout.write(`${line}\n`, (error) => (error ? reject(error) : resolve()));
     });
 }
+async function closeKernel(kernel) {
+    const result = await kernel?.close();
+    if (result && !result.complete)
+        throw new Error("COMPONENT_CLEANUP_INCOMPLETE");
+}

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/service-control.d.ts

@@ -1,16 +1,13 @@
 import { type ServiceBackend, type ServiceSpec } from "@mininglamp-oss/octo-runtime-cross-service";
-import type { RuntimePaths } from "./state.js";
-export declare const RUNTIME_SERVICE_ID = "cn.mininglamp.octo-runtime.daemon";
 export interface ServiceControlOptions {
     backend?: ServiceBackend;
-    daemonEntrypoint?: string;
     nodeExecutable?: string;
     systemHome?: string;
     platform?: NodeJS.Platform;
     environment?: NodeJS.ProcessEnv;
+    cliEntrypoint?: string;
 }
 export declare function resolveServiceControl(options?: ServiceControlOptions): {
     backend: ServiceBackend;
-    spec(paths: RuntimePaths, enabled?: boolean, daemonArgs?: string[]): ServiceSpec;
+    spec(home: string, component: string, enabled?: boolean, args?: string[]): ServiceSpec;
 };
-export declare function verifyServiceProgram(spec: ServiceSpec): Promise<void>;

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/service-control.js

@@ -1,49 +1,44 @@
-import { access, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, resolve } from "node:path";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { componentServiceId } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { createServiceBackend } from "@mininglamp-oss/octo-runtime-cross-service";
-export const RUNTIME_SERVICE_ID = "cn.mininglamp.octo-runtime.daemon";
 export function resolveServiceControl(options = {}) {
-    const platform = options.platform ?? process.platform;
-    const environment = options.environment ?? process.env;
-    const daemonEntrypoint = resolve(options.daemonEntrypoint ??
-        fileURLToPath(new URL("../../daemon/dist/launcher.js", import.meta.url)));
-    const nodeExecutable = resolve(options.nodeExecutable ?? process.execPath);
     const backend = options.backend ??
         createServiceBackend({
-            platform,
+            platform: options.platform,
+            environment: options.environment,
             homeDirectory: options.systemHome ?? homedir()
         });
     return {
         backend,
-        spec(paths, enabled = true, daemonArgs = []) {
+        spec(home, component, enabled = false, args = []) {
+            const id = componentServiceId(home, component, options.platform);
             return {
-                id: RUNTIME_SERVICE_ID,
-                description: "Octo Runtime daemon",
-                command: nodeExecutable,
-                args: [daemonEntrypoint, "--home", paths.home, ...daemonArgs],
-                workingDirectory: paths.home,
-                environment: {
-                    ...(environment.PATH || environment.Path
-                        ? { PATH: environment.PATH ?? environment.Path ?? "" }
-                        : {})
-                },
+                id,
+                description: `Octo Runtime ${component}`,
+                command: resolve(options.nodeExecutable ?? process.execPath),
+                args: [
+                    resolve(options.cliEntrypoint ?? fileURLToPath(new URL("./index.js", import.meta.url))),
+                    component,
+                    "run",
+                    "--home",
+                    resolve(home),
+                    ...args
+                ],
+                workingDirectory: resolve(home),
+                ...((options.platform ?? process.platform) !== "win32"
+                    ? {
+                        environment: {
+                            PATH: (options.environment ?? process.env).PATH ?? "/usr/local/bin:/usr/bin:/bin"
+                        }
+                    }
+                    : {}),
                 enabled,
-                restart: { policy: "on-failure", delaySeconds: 5, maxBurst: 5 },
-                timeoutStopSeconds: 45,
-                names: {
-                    launchdLabel: RUNTIME_SERVICE_ID,
-                    systemdUnit: `${RUNTIME_SERVICE_ID}.service`,
-                    windowsTaskName: "\\OctoRuntime.daemon"
-                }
+                restart: { policy: "on-failure", delaySeconds: 5, maxBurst: 3 },
+                timeoutStopSeconds: 10,
+                names: { launchdLabel: id, systemdUnit: `${id}.service`, windowsTaskName: `\\${id}` }
             };
         }
     };
 }
-export async function verifyServiceProgram(spec) {
-    await Promise.all([access(spec.command), access(spec.args?.[0] ?? "")]);
-    await mkdir(spec.workingDirectory, { recursive: true, mode: 0o700 });
-    if (spec.stdoutPath)
-        await mkdir(dirname(spec.stdoutPath), { recursive: true, mode: 0o700 });
-}

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/state.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { access, chmod, mkdir, open, readFile, rename, rm, rmdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
-import { runtimeControlEndpoint } from "@mininglamp-oss/octo-runtime-daemon/runtime-endpoint";
+import { componentEndpoint } from "@mininglamp-oss/octo-runtime-host-sdk";
 const PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const RESERVED_PROFILE_NAMES = new Set([
     "config.json",
@@ -42,8 +42,8 @@ export function runtimePaths(home, profile, platform = process.platform) {
         credential: join(profileRoot, "credentials", "runtime-token.json"),
         openclawRoot: join(profileRoot, "adapters", "openclaw"),
         setupLock: join(absoluteHome, "run", "setup.lock"),
-        pid: join(absoluteHome, "octo-daemon.pid"),
-        socket: runtimeControlEndpoint(absoluteHome, platform),
+        pid: join(absoluteHome, "run", "executor-kernel.pid"),
+        socket: componentEndpoint(absoluteHome, "executor-kernel", platform),
         logs: join(absoluteHome, "logs")
     };
 }
@@ -252,7 +252,7 @@ async function acquireProcessLock(path) {
                 throw error;
             const owner = await readLockOwner(path);
             if (owner !== undefined && processAlive(owner)) {
-                throw new Error(`another setup process is active (pid ${owner})`, { cause: error });
+                throw new Error("SETUP_IN_PROGRESS", { cause: error });
             }
             await rm(path, { force: true });
         }

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/status-output.d.ts

@@ -0,0 +1,10 @@
+import type { Writable } from "node:stream";
+import { type ExtraStatusRecord } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/** Bound stdout buffering without blocking Extras; report dropped records when the pipe drains. */
+export declare class StatusOutput {
+    #private;
+    private readonly output;
+    constructor(output: Writable);
+    readonly write: (record: ExtraStatusRecord) => void;
+    readonly close: () => void;
+}

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/status-output.js

@@ -0,0 +1,65 @@
+import { extraStatusRecord } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/** Bound stdout buffering without blocking Extras; report dropped records when the pipe drains. */
+export class StatusOutput {
+    output;
+    #queue = [];
+    #bytes = 0;
+    #blocked = false;
+    #closed = false;
+    #dropped = 0;
+    #extra = "extra";
+    constructor(output) {
+        this.output = output;
+        output.on("error", this.close);
+    }
+    write = (record) => {
+        if (this.#closed)
+            return;
+        this.#extra = record.extra_type;
+        const line = `${JSON.stringify(record)}\n`;
+        if (this.#queue.length >= 128 || this.#bytes + Buffer.byteLength(line) > 1024 * 1024) {
+            this.#dropped = Math.min(Number.MAX_SAFE_INTEGER, this.#dropped + 1);
+            return;
+        }
+        this.#queue.push(line);
+        this.#bytes += Buffer.byteLength(line);
+        this.#flush();
+    };
+    #drain = () => {
+        this.#blocked = false;
+        this.#flush();
+    };
+    #flush() {
+        if (this.#closed || this.#blocked)
+            return;
+        while (this.#queue.length) {
+            const line = this.#queue.shift();
+            this.#bytes -= Buffer.byteLength(line);
+            try {
+                if (!this.output.write(line)) {
+                    this.#blocked = true;
+                    this.output.once("drain", this.#drain);
+                    return;
+                }
+            }
+            catch {
+                this.close();
+                return;
+            }
+        }
+        if (this.#dropped) {
+            const record = extraStatusRecord(this.#extra, "warn", "service.output_dropped", {
+                dropped_count: this.#dropped
+            });
+            this.#dropped = 0;
+            this.write(record);
+        }
+    }
+    close = () => {
+        this.#closed = true;
+        this.#queue = [];
+        this.#bytes = 0;
+        this.output.off("drain", this.#drain);
+        this.output.off("error", this.close);
+    };
+}

package/node_modules/@mininglamp-oss/octo-runtime-cli/dist/worker.js

@@ -0,0 +1,18 @@
+// CLI 自有执行 worker。顶层 Kernel 仍由 CLI 调用进程创建；SDK 原生入口不使用此装配。
+import { loadManifestAdapters } from "@mininglamp-oss/octo-runtime-executor-kernel/manifest-adapters";
+import { serveWorker } from "@mininglamp-oss/octo-runtime-executor-kernel";
+import { readExtraDirectory } from "@mininglamp-oss/octo-runtime-host-sdk";
+import { dirname, join } from "node:path";
+const adapters = await loadManifestAdapters();
+// 旧显式清单允许省略 type；以所选实例真实类型判断，不猜包名，也不在父进程重复实例化。
+if (adapters.some((adapter) => adapter.metadata.type === "openclaw")) {
+    const profileRoot = process.env.OCTO_RUNTIME_CLI_PROFILE_ROOT;
+    if (!profileRoot)
+        throw new Error("CLI_PROFILE_ROOT_REQUIRED");
+    const { initializeCliOpenClaw, syncCliOpenClawToolEnvironment } = await import("./openclaw.js");
+    await initializeCliOpenClaw(profileRoot);
+    if (process.env.OCTO_RUNTIME_CLI_SYNC_OPENCLAW_TOOLS === "1")
+        await syncCliOpenClawToolEnvironment(profileRoot, await readExtraDirectory(join(dirname(profileRoot), "extras")));
+}
+// 产品连接准备完成后才建立既有 list/probe 握手；所有实例仅交给唯一 Core 注册一次。
+serveWorker(adapters);

package/node_modules/@mininglamp-oss/octo-runtime-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-cli",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "private": true,
   "type": "module",
   "bin": {
@@ -8,12 +8,27 @@
   },
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-daemon": "1.0.1",
-    "@mininglamp-oss/octo-runtime-adapter-openclaw": "1.0.1",
-    "@mininglamp-oss/octo-runtime-cross-service": "1.0.1",
-    "@mininglamp-oss/octo-runtime-daemon-app": "1.0.1",
-    "@mininglamp-oss/octo-runtime-protocol": "1.0.1",
-    "@mininglamp-oss/octo-runtime-adapter-host": "1.0.1",
-    "@mininglamp-oss/octo-runtime-core": "1.0.1"
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.1.1",
+    "json5": "2.2.3",
+    "@mininglamp-oss/octo-runtime-extra-channel-gateway": "1.1.1",
+    "@mininglamp-oss/octo-runtime-host-sdk": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-openclaw": "1.1.1",
+    "@mininglamp-oss/octo-runtime-cross-service": "1.1.1",
+    "@mininglamp-oss/octo-runtime-protocol": "1.1.1",
+    "@mininglamp-oss/octo-runtime-executor-kernel": "1.1.1",
+    "@mininglamp-oss/octo-runtime-executor-core": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-antigravity": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-claude-code": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-codebuddy": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-codex": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-hermes": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-kimi-code": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-mcode": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-opencode": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-qodercli": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-qoderclicn": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-zcode-gui": "1.1.1",
+    "@mininglamp-oss/octo-runtime-extra-channel-wecom": "1.1.1",
+    "@mininglamp-oss/octo-runtime-extra-webui": "1.1.1"
   }
 }