@mininglamp-oss/octo-runtime 1.1.0 → 1.1.2

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

@@ -63,9 +63,11 @@ Commands:
   stop          Stop this service, preserving its autostart setting
   status        Show native service, IPC and component status
   run           Run this component in the foreground
+${component === "executor-kernel" ? "" : "  logs          Tail service status logs (no conversation content)\n"}
 
 Flags: --home <path> --profile <name> --manifest <path> --json --help
 Install: --autostart=true|false
+${component === "executor-kernel" ? "" : "Logs: --lines <1..10000> (default 200) --follow --json (NDJSON)\n"}
 Kernel and Extras have independent services and autostart settings.
 An Extra may start before Kernel and connect when Kernel becomes available.`;
     return `Octo Runtime CLI (${cliVersion})
@@ -75,6 +77,7 @@ Manage the local Agent runtime and independent services.
 Usage:
 octo-runtime executor-kernel uninstall|install|start|restart|stop|status|run
 octo-runtime <extra-name> uninstall|install|start|restart|stop|status|run
+octo-runtime <extra-name> logs [--lines 200] [--follow] [--json]
 octo-runtime status [--json]
 octo-runtime adapter list
 octo-runtime adapter probe <type>

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

@@ -0,0 +1,10 @@
+export declare function showExtraLogs(options: {
+    home: string;
+    extra: string;
+    lines: number;
+    follow: boolean;
+    json: boolean;
+    output: (line: string, signal?: AbortSignal) => void | Promise<void>;
+    errorOutput: (line: string) => void;
+    signal?: AbortSignal;
+}): Promise<void>;

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

@@ -0,0 +1,186 @@
+import { constants } from "node:fs";
+import { lstat, open, opendir } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { extraStatusRecord } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+const MAX_READ = 4 * 1024 * 1024;
+const MAX_LINE = 4096;
+function record(line, extra) {
+    if (Buffer.byteLength(line) > MAX_LINE)
+        return;
+    try {
+        const value = JSON.parse(line);
+        if (value.source !== "extra" || value.extra_type !== extra || typeof value.time !== "string")
+            return;
+        return extraStatusRecord(extra, value.level, value.event, value.data, value.time);
+    }
+    catch {
+        return;
+    }
+}
+async function files(home, extra) {
+    const directory = join(home, "logs", "extras");
+    for (const path of [join(home, "logs"), directory]) {
+        try {
+            const stat = await lstat(path);
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                throw new Error("LOG_DIRECTORY_NOT_REGULAR");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+    }
+    const pattern = new RegExp(`^${extra}-status-\\d{8}T\\d{2}\\.log$`);
+    // Keep only three candidates while scanning, without loading an unbounded directory listing.
+    const selected = [];
+    let count = 0;
+    for await (const entry of await opendir(directory)) {
+        if (++count > 10000)
+            throw new Error("LOG_SCAN_LIMIT");
+        if (!pattern.test(entry.name) || !entry.isFile() || entry.isSymbolicLink())
+            continue;
+        selected.push(join(directory, entry.name));
+        selected.sort();
+        if (selected.length > 3)
+            selected.shift();
+    }
+    return selected;
+}
+async function read(path, start, maximum) {
+    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.nlink !== 1)
+            throw new Error("LOG_NOT_REGULAR_FILE");
+        const offset = start === undefined ? Math.max(0, stat.size - maximum) : Math.min(start, stat.size);
+        const buffer = Buffer.alloc(Math.min(maximum, stat.size - offset));
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
+        return {
+            text: buffer.subarray(0, bytesRead).toString("utf8"),
+            offset,
+            end: offset + bytesRead,
+            identity: `${stat.dev}:${stat.ino}`,
+            size: stat.size
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function showExtraLogs(options) {
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(options.extra) ||
+        !Number.isInteger(options.lines) ||
+        options.lines < 1 ||
+        options.lines > 10000)
+        throw new Error("INVALID_ARGUMENTS");
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    if (options.follow) {
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+        options.signal?.addEventListener("abort", stop, { once: true });
+        if (options.signal?.aborted)
+            stop();
+    }
+    const cursors = new Map();
+    const emit = async (value) => {
+        const text = options.json
+            ? JSON.stringify(value)
+            : `${value.time} ${value.level.toUpperCase()} ${value.extra_type} ${value.event}${Object.keys(value.data).length ? ` ${JSON.stringify(value.data)}` : ""}`;
+        await options.output(text, controller.signal);
+    };
+    try {
+        const selected = await files(options.home, options.extra);
+        let remaining = MAX_READ;
+        const chunks = [];
+        // Spend the shared byte budget newest-first, then emit complete records in file order.
+        for (const path of [...selected].reverse()) {
+            try {
+                const value = await read(path, undefined, remaining);
+                remaining -= Buffer.byteLength(value.text);
+                const lines = value.text.split("\n");
+                if (value.offset > 0)
+                    lines.shift();
+                const pending = lines.pop() ?? "";
+                cursors.set(path, {
+                    offset: value.end,
+                    identity: value.identity,
+                    pending: pending.length <= MAX_LINE ? pending : "",
+                    skipping: pending.length > MAX_LINE
+                });
+                chunks.unshift(lines
+                    .map((line) => record(line, options.extra))
+                    .filter((value) => !!value));
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+        const tail = chunks.flat().slice(-options.lines);
+        for (const value of tail)
+            await emit(value);
+        if (!tail.length)
+            options.errorOutput(`${options.extra}: no service status logs`);
+        if (!options.follow)
+            return;
+        while (!controller.signal.aborted) {
+            await delay(500, undefined, { signal: controller.signal });
+            const current = await files(options.home, options.extra);
+            for (const path of cursors.keys())
+                if (!current.includes(path))
+                    cursors.delete(path);
+            let budget = MAX_READ;
+            for (const path of current) {
+                if (controller.signal.aborted || budget <= 0)
+                    break;
+                try {
+                    // Inode/size changes reset the cursor; preserve partial records across appends.
+                    let cursor = cursors.get(path);
+                    let value = await read(path, cursor?.offset ?? 0, budget);
+                    if (!cursor || cursor.identity !== value.identity || cursor.offset > value.size) {
+                        cursor = { offset: 0, identity: value.identity, pending: "", skipping: false };
+                        if (value.offset !== 0)
+                            value = await read(path, 0, budget);
+                    }
+                    budget -= Buffer.byteLength(value.text);
+                    const lines = (cursor.pending + value.text).split("\n");
+                    if (cursor.skipping) {
+                        if (lines.length === 1) {
+                            cursors.set(path, { ...cursor, offset: value.end });
+                            continue;
+                        }
+                        lines.shift();
+                    }
+                    const pending = lines.pop() ?? "";
+                    for (const line of lines) {
+                        const value = record(line, options.extra);
+                        if (value)
+                            await emit(value);
+                    }
+                    cursors.set(path, {
+                        offset: value.end,
+                        identity: value.identity,
+                        pending: pending.length <= MAX_LINE ? pending : "",
+                        skipping: pending.length > MAX_LINE
+                    });
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (!controller.signal.aborted)
+            throw error;
+    }
+    finally {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        options.signal?.removeEventListener("abort", stop);
+    }
+}

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

@@ -7,5 +7,6 @@ export interface CliDependencies extends ServiceControlOptions {
     sleep?: (ms: number) => Promise<void>;
     /** CLI 入口选择前台组件的退出策略；仅确认命令类型，不表示服务 ready。 */
     onComponentRun?: () => void;
+    logsSignal?: AbortSignal;
 }
 export declare function runCli(args: string[], dependencies?: CliDependencies): Promise<number>;

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

@@ -1,16 +1,20 @@
 import net from "node:net";
 import { randomUUID } from "node:crypto";
-import { access, mkdir } from "node:fs/promises";
+import { once } from "node:events";
+import { lstat, mkdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { attachKernel, createKernelService, readAdapterConfigurations } from "@mininglamp-oss/octo-runtime-executor-kernel";
-import { componentEndpoint, createExtraService, extraRegistration } from "@mininglamp-oss/octo-runtime-host-sdk";
+import { componentEndpoint, createExtraService } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { getExtra, readExtra, setExtra } from "./extras.js";
 import { cliVersionInfo, helpText } from "./help.js";
 import { runForegroundService } from "./foreground.js";
+import { showExtraLogs } from "./logs.js";
+import { StatusOutput } from "./status-output.js";
 import { defaultRuntimeHome, runtimePaths, withSetupLock, readJsonFile } from "./state.js";
 import { resolveServiceControl } from "./service-control.js";
-import { initializeCliOpenClaw, syncCliOpenClawToolEnvironment } from "./openclaw.js";
+import { loadCliManifest } from "./module-manifest.js";
+import { resolveAdapterModules } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
 import { readExtraDirectory } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { describeError, formatStatus, recordStartupFailure, readStartupFailure } from "./output.js";
 const components = ["executor-kernel", "channel-gateway"];
@@ -20,8 +24,11 @@ export async function runCli(args, dependencies = {}) {
     let json = args.includes("--json");
     let context = {};
     let runningComponent;
+    let statusOutput;
     try {
         const { flags, positional } = parse(args);
+        if ((flags.lines !== undefined || flags.follow !== undefined) && positional[1] !== "logs")
+            throw new Error("INVALID_ARGUMENTS");
         json = Boolean(flags.json);
         if (flags.version || positional[0] === "version") {
             output(cliVersionInfo);
@@ -37,16 +44,65 @@ export async function runCli(args, dependencies = {}) {
             return 0;
         }
         const home = resolve(flags.home ?? defaultRuntimeHome(dependencies.env, dependencies.platform));
+        // Route logs before config/module/manager access so offline failures remain diagnosable.
+        if (positional[1] === "logs") {
+            const extra = positional[0];
+            context = { component: extra, action: "logs", logs: join(home, "logs", "extras") };
+            if (positional.length !== 2 ||
+                extra === "executor-kernel" ||
+                !/^[a-z][a-z0-9-]{0,63}$/.test(extra) ||
+                flags.autostart !== undefined)
+                throw new Error("INVALID_ARGUMENTS");
+            if (!builtinComponents.includes(extra)) {
+                const registration = await lstat(join(home, "extras", extra, "config.json")).catch((error) => {
+                    if (error.code === "ENOENT")
+                        return undefined;
+                    throw error;
+                });
+                if (!registration?.isFile() || registration.isSymbolicLink())
+                    throw new Error("EXTRA_NOT_FOUND");
+            }
+            if (flags.lines !== undefined && !/^[1-9][0-9]{0,4}$/.test(flags.lines))
+                throw new Error("INVALID_ARGUMENTS");
+            await showExtraLogs({
+                home,
+                extra,
+                lines: Number(flags.lines ?? 200),
+                follow: Boolean(flags.follow),
+                json,
+                output: dependencies.output ??
+                    (async (line, signal) => {
+                        if (!process.stdout.write(`${line}\n`))
+                            await once(process.stdout, "drain", { signal });
+                    }),
+                errorOutput: dependencies.errorOutput ??
+                    ((line) => {
+                        process.stderr.write(`${line}\n`);
+                    }),
+                signal: dependencies.logsSignal
+            });
+            return 0;
+        }
         const root = await readJsonFile(runtimePaths(home, "default").rootConfig);
         const profile = flags.profile ?? root?.default_profile ?? "default";
         const paths = runtimePaths(home, profile, dependencies.platform);
         const endpoint = componentEndpoint(home, "executor-kernel", dependencies.platform);
         context = { component: positional[0], action: positional[1], logs: join(home, "logs") };
         const registrations = await readExtraDirectory(join(home, "extras"));
+        // 部署、停止及配置修复命令不启动模块，也不因尚未可读的启动清单而无法操作。
+        const needsManifest = positional[1] === "run" ||
+            (!builtinComponents.includes(positional[0]) &&
+                !registrations.some((entry) => entry.name === positional[0]) &&
+                ["install", "start", "restart", "stop", "uninstall", "status"].includes(positional[1]));
+        const manifest = needsManifest
+            ? await loadCliManifest(home, flags.manifest, dependencies.errorOutput ?? ((message) => process.stderr.write(`${message}\n`)))
+            : undefined;
         const componentNames = [
             ...new Set([...components, ...registrations.map((entry) => entry.name)])
         ];
-        const isComponent = (name) => builtinComponents.includes(name) || registrations.some((entry) => entry.name === name);
+        const isComponent = (name) => builtinComponents.includes(name) ||
+            registrations.some((entry) => entry.name === name) ||
+            manifest?.extras.some((entry) => entry.name === name) === true;
         if (positional.length === 1 && isComponent(positional[0])) {
             output(helpText(positional[0]));
             return 0;
@@ -159,41 +215,45 @@ export async function runCli(args, dependencies = {}) {
             return 0;
         }
         if (action === "run") {
+            if (!manifest)
+                throw new Error("MANIFEST_INVALID");
             runningComponent = component;
             dependencies.onComponentRun?.();
             await mkdir(home, { recursive: true, mode: 0o700 });
             let handle;
             if (component === "executor-kernel") {
-                // 显式清单不存在时在宿主边界保留 ENOENT，而非等待 worker 断开后丢失原因。
-                if (flags.manifest)
-                    await access(resolve(flags.manifest));
-                await initializeCliOpenClaw(paths.profileRoot, dependencies.env ?? process.env);
-                await syncCliOpenClawToolEnvironment(paths.profileRoot, await readExtraDirectory(join(home, "extras")));
                 const config = await readJsonFile(paths.profileConfig);
                 handle = createKernelService({
                     endpoint,
                     stateDirectory: join(home, "run"),
-                    workerEntrypoint: fileURLToPath(import.meta.resolve("@mininglamp-oss/octo-runtime-executor-kernel/runner")),
-                    manifest: flags.manifest
-                        ? resolve(flags.manifest)
-                        : fileURLToPath(new URL("./default_adapters.json", import.meta.url)),
+                    workerEntrypoint: fileURLToPath(new URL("./worker.js", import.meta.url)),
+                    adapterModules: resolveAdapterModules(manifest),
                     adapterConfigurations: readAdapterConfigurations(paths.profileRoot, config?.adapters),
                     env: {
                         ...(dependencies.env ?? process.env),
                         OCTO_RUNTIME_HOME: home,
+                        OCTO_RUNTIME_CLI_PROFILE_ROOT: paths.profileRoot,
+                        OCTO_RUNTIME_CLI_SYNC_OPENCLAW_TOOLS: "1",
                         OCTO_RUNTIME_LOGS_DIRECTORY: join(home, "logs")
                     }
                 });
             }
             else {
-                const registration = extraRegistration(await readExtra(paths, component));
+                const registration = await readExtra(paths, component, manifest);
                 const module = registration.enabled === false
                     ? { name: registration.name, default: () => () => { } }
                     : await registration.load();
                 if (module.name !== registration.name)
                     throw new Error("EXTRA_NAME_MISMATCH");
+                if (!dependencies.output)
+                    statusOutput = new StatusOutput(process.stdout);
                 handle = createExtraService({
-                    logging: { directory: join(home, "logs") },
+                    logging: {
+                        directory: join(home, "logs"),
+                        statusOutput: dependencies.output
+                            ? (record) => output(JSON.stringify(record))
+                            : statusOutput.write
+                    },
                     module,
                     config: registration.config,
                     dependencies: {},
@@ -202,7 +262,7 @@ export async function runCli(args, dependencies = {}) {
                     controlEndpoint: componentEndpoint(home, component, dependencies.platform)
                 });
             }
-            return runForegroundService(handle, () => publish({ component, state: "ready" }, `${component}: ready`), async (error) => {
+            return await runForegroundService(handle, () => publish({ component, state: "ready" }, `${component}: ready`), async (error) => {
                 try {
                     await recordStartupFailure(join(home, "logs"), component, error);
                 }
@@ -292,7 +352,7 @@ export async function runCli(args, dependencies = {}) {
         const failure = { ...describeError(error), ...context };
         const code = failure.code;
         if (json)
-            output(JSON.stringify({ error: failure }, null, 2));
+            output(JSON.stringify({ error: failure }, null, context.action === "logs" ? undefined : 2));
         else
             (dependencies.errorOutput ?? ((line) => process.stderr.write(`${line}\n`)))(`${[context.component, context.action].filter(Boolean).join(" ") || "octo-runtime"}: ${code}${failure.cause_code ? ` (${failure.cause_code})` : ""}\n${failure.message}${context.logs ? `\nLogs: ${context.logs}` : ""}`);
         return ["SERVICE_NOT_INSTALLED", "NOT_INSTALLED"].includes(code)
@@ -305,6 +365,9 @@ export async function runCli(args, dependencies = {}) {
                         ? 4
                         : 1;
     }
+    finally {
+        statusOutput?.close();
+    }
 }
 async function componentStatus(home, component, platform, requireReady = false) {
     const endpoint = componentEndpoint(home, component, platform);
@@ -372,11 +435,23 @@ function parse(args) {
         }
         const match = /^--([a-z-]+)(?:=(.*))?$/.exec(arg);
         if (!match ||
-            !["home", "profile", "manifest", "json", "help", "version", "autostart"].includes(match[1]) ||
+            ![
+                "home",
+                "profile",
+                "manifest",
+                "json",
+                "help",
+                "version",
+                "autostart",
+                "lines",
+                "follow"
+            ].includes(match[1]) ||
             Object.hasOwn(flags, match[1]))
             throw new Error("INVALID_ARGUMENTS");
         const key = match[1];
-        flags[key] = ["json", "help", "version"].includes(key) ? "true" : (match[2] ?? args[++i]);
+        flags[key] = ["json", "help", "version", "follow"].includes(key)
+            ? "true"
+            : (match[2] ?? args[++i]);
         if (!flags[key] ||
             flags[key].startsWith("--") ||
             (key === "autostart" && !["true", "false"].includes(flags[key])))

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

@@ -16,6 +16,11 @@
       "module": "@mininglamp-oss/octo-runtime-adapter-codebuddy",
       "export": "codebuddyAdapter"
     },
+    {
+      "type": "grok-build",
+      "module": "@mininglamp-oss/octo-runtime-adapter-grok-build",
+      "export": "grokBuildAdapter"
+    },
     {
       "type": "hermes",
       "module": "@mininglamp-oss/octo-runtime-adapter-hermes",
@@ -61,5 +66,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-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.js

@@ -102,6 +102,9 @@ export function describeError(error, fallback = "COMMAND_FAILED") {
         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.",

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

@@ -1,7 +1,7 @@
 import { defaultRuntimeHome, runtimePaths, readJsonFile } from "./state.js";
-import { initializeCliOpenClaw } from "./openclaw.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 { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { componentEndpoint } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { mkdtemp, rm } from "node:fs/promises";
@@ -67,15 +67,17 @@ export async function runPlayboard(options) {
     const temporary = await mkdtemp(join(tmpdir(), "octo-playboard-"));
     try {
         const paths = runtimePaths(home, profile);
-        await initializeCliOpenClaw(paths.profileRoot, options.env ?? process.env);
+        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(import.meta.resolve("@mininglamp-oss/octo-runtime-executor-kernel/runner")),
-            manifest: options.manifest
-                ? resolve(options.manifest)
-                : fileURLToPath(new URL("./default_adapters.json", import.meta.url)),
-            env: options.env ?? process.env,
+            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)
         });
         await kernel.initialize({ signal: controller.signal });

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.d.ts

@@ -0,0 +1 @@
+export {};