@mininglamp-oss/octo-runtime 1.1.0 → 1.1.1

package/node_modules/@mininglamp-oss/octo-runtime-adapter-sdk/dist/runtime-log.js

@@ -1,6 +1,7 @@
-/** 宿主可选的结构化日志；只接受执行元数据，磁盘写入隔离在有界 Worker。 */
+/** Optional metadata logging; bounded queues isolate filesystem writes in a dedicated worker. */
 import { isAbsolute } from "node:path";
 import { Worker } from "node:worker_threads";
+import { extraStatusRecord } from "./service-status.js";
 export const noopRuntimeLog = () => { };
 const strings = new Set([
     "run_id",
@@ -30,11 +31,15 @@ export function assertRuntimeLogging(options) {
     if (options !== undefined &&
         (!options || typeof options.directory !== "string" || !isAbsolute(options.directory)))
         throw new TypeError("LOG_DIRECTORY_MUST_BE_ABSOLUTE");
+    if (options?.statusOutput !== undefined && typeof options.statusOutput !== "function")
+        throw new TypeError("LOG_STATUS_OUTPUT_INVALID");
 }
 /** F31：.octospec/tasks/gateway-august-feature-assessment/assessment.md */
 export class RuntimeLogging {
     #worker;
     #pending = 0;
+    #statusPending = 0;
+    #statusOutput;
     #closed = false;
     #closing;
     #done;
@@ -42,27 +47,31 @@ export class RuntimeLogging {
         assertRuntimeLogging(options);
         if (!options)
             return;
+        this.#statusOutput = options.statusOutput;
         try {
             this.#worker = new Worker(new URL("./runtime-log-worker.js", import.meta.url), {
-                workerData: options
+                workerData: { directory: options.directory }
             });
         }
         catch {
-            this.#closed = true;
             return;
         }
         this.#worker.on("message", (message) => {
-            if (message === "written")
-                this.#pending = Math.max(0, this.#pending - 1);
+            if (typeof message === "object") {
+                if (message.written)
+                    this.#statusPending = Math.max(0, this.#statusPending - 1);
+                else
+                    this.#pending = Math.max(0, this.#pending - 1);
+            }
             if (message === "closed")
                 this.#done?.();
         });
         this.#worker.on("error", () => {
-            this.#closed = true;
+            this.#worker = undefined;
             this.#done?.();
         });
         this.#worker.on("exit", () => {
-            this.#closed = true;
+            this.#worker = undefined;
             this.#done?.();
         });
         this.#worker.unref();
@@ -74,13 +83,39 @@ export class RuntimeLogging {
         return (level, event, data) => this.#write("extra", name, level, event, data);
     }
     #write(source, extra, level, event, data) {
-        if (!this.#worker || this.#closed || this.#pending >= 128)
+        if (this.#closed)
+            return;
+        if (extra) {
+            try {
+                const status = extraStatusRecord(extra, level, event, data);
+                if (status) {
+                    // Sink and mirror fail independently; neither failure may affect service recovery.
+                    try {
+                        const result = this.#statusOutput?.(status);
+                        // TypeScript permits async functions in void sinks; observe rejection without waiting.
+                        if (result && typeof result.then === "function")
+                            void Promise.resolve(result).catch(() => undefined);
+                    }
+                    catch {
+                        /* A host sink failure must not suppress the independent file mirror. */
+                    }
+                    if (this.#worker && this.#statusPending < 128) {
+                        this.#worker.postMessage({ extra, status: true, line: `${JSON.stringify(status)}\n` });
+                        this.#statusPending++;
+                    }
+                }
+            }
+            catch {
+                /* Untrusted diagnostic getters must not escape into service execution. */
+            }
+        }
+        if (!this.#worker || this.#pending >= 128)
             return;
         try {
             if (!["info", "warn", "error"].includes(level) || !/^[a-z][a-z0-9_.-]{0,63}$/.test(event))
                 return;
             const safe = {};
-            // 不做任意对象脱敏或正文截断：白名单之外的字段直接不读取、不序列化。
+            // Ignore unknown fields entirely instead of serializing or truncating arbitrary bodies.
             for (const key of strings) {
                 const value = data?.[key];
                 if (typeof value === "string" &&
@@ -105,7 +140,7 @@ export class RuntimeLogging {
             this.#pending++;
         }
         catch {
-            /* 日志不能中断执行，包括恶意 getter 或已退出的 Worker。 */
+            /* Diagnostics cannot interrupt execution, including getter errors or an exited worker. */
         }
     }
     close() {

package/node_modules/@mininglamp-oss/octo-runtime-adapter-sdk/dist/service-status.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeLogLevel } from "./runtime-log.js";
+export interface ExtraStatusRecord {
+    time: string;
+    level: RuntimeLogLevel;
+    source: "extra";
+    extra_type: string;
+    event: string;
+    data: Record<string, string | number>;
+}
+/** Rebuild status records from a separate allowlist, including when reading persisted files. */
+export declare function extraStatusRecord(extra: string, level: RuntimeLogLevel, event: string, data?: Readonly<Record<string, unknown>>, time?: string): ExtraStatusRecord | undefined;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-sdk/dist/service-status.js

@@ -0,0 +1,70 @@
+const events = new Set([
+    "service.initializing",
+    "service.ready",
+    "service.closing",
+    "service.closed",
+    "service.failed",
+    "service.cleanup_incomplete",
+    "service.output_dropped",
+    "kernel.available",
+    "kernel.unavailable",
+    "channel.connecting",
+    "channel.connected",
+    "channel.disconnected",
+    "channel.connection_failed",
+    "channel.retry_started",
+    "channel.retry_scheduled",
+    "channel.stopped",
+    "channel.diagnostic"
+]);
+const states = new Set([
+    "created",
+    "initializing",
+    "ready",
+    "closing",
+    "closed",
+    "failed",
+    "connecting",
+    "online",
+    "retrying",
+    "stopped",
+    "available",
+    "unavailable"
+]);
+/** Rebuild status records from a separate allowlist, including when reading persisted files. */
+export function extraStatusRecord(extra, level, event, data, time = new Date().toISOString()) {
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(extra) ||
+        !["info", "warn", "error"].includes(level) ||
+        !events.has(event))
+        return;
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(time) ||
+        !Number.isFinite(Date.parse(time)))
+        return;
+    if (event === "channel.diagnostic" && data?.code !== "IM_DISPOSE_FAILED")
+        return;
+    const safe = {};
+    for (const key of ["state", "code", "endpoint_id"]) {
+        const value = data?.[key];
+        if (typeof value !== "string")
+            continue;
+        if (key === "state"
+            ? states.has(value)
+            : key === "endpoint_id"
+                ? /^[a-f0-9]{64}$/.test(value)
+                : /^[A-Z][A-Z0-9_]{0,95}$/.test(value))
+            safe[key] = value;
+    }
+    for (const key of ["attempt", "delay_ms", "dropped_count"]) {
+        const value = data?.[key];
+        if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+            safe[key] = value;
+    }
+    return Object.freeze({
+        time,
+        level,
+        source: "extra",
+        extra_type: extra,
+        event,
+        data: Object.freeze(safe)
+    });
+}

package/node_modules/@mininglamp-oss/octo-runtime-adapter-sdk/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-sdk",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "private": true,
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
-    "./process-cleanup": "./dist/process-cleanup.js"
+    "./process-cleanup": "./dist/process-cleanup.js",
+    "./module-manifest": "./dist/module-manifest.js"
   },
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-protocol": "1.1.0"
+    "@mininglamp-oss/octo-runtime-protocol": "1.1.1",
+    "import-meta-resolve": "4.2.0"
   },
   "types": "./dist/index.d.ts",
   "files": [

package/node_modules/@mininglamp-oss/octo-runtime-adapter-zcode-gui/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-zcode-gui",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-protocol": "1.1.0",
-    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.1.0"
+    "@mininglamp-oss/octo-runtime-protocol": "1.1.1",
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.1.1"
   },
   "types": "./dist/index.d.ts",
   "files": [

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

@@ -1,5 +1,5 @@
 {
-  "commit": "d064cfe78f6818d3c451ecf803a280245f4b0496",
+  "commit": "20c377136288a55356300bd3d4a755d0f19a23ee",
   "dirty": false,
-  "buildTime": "2026-10-21T06:46:27.212Z"
+  "buildTime": "2026-10-22T07:38:35.134Z"
 }

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

@@ -1,6 +1,8 @@
-import { type ExtraDescriptor, type StoredExtra } from "@mininglamp-oss/octo-runtime-host-sdk";
+import { type ExtraRegistration, type StoredExtra } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { type RuntimePaths } from "./state.js";
+import { type ModuleManifest } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
 /** Generic full replacement: no platform-specific CLI fields or validation. */
 export declare function setExtra(paths: RuntimePaths, name: string, input: NodeJS.ReadableStream): Promise<unknown>;
-export declare function readExtra(paths: RuntimePaths, name: string): Promise<ExtraDescriptor>;
+/** CLI 将模块目录与业务配置装配；仅 load 时解析/import，禁用项及未启动项不执行模块。 */
+export declare function readExtra(paths: RuntimePaths, name: string, manifest: ModuleManifest): Promise<ExtraRegistration>;
 export declare function getExtra(paths: RuntimePaths, name: string): Promise<StoredExtra>;

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

@@ -1,6 +1,7 @@
 import { join } from "node:path";
-import { assertExtraName, assertStoredExtra, readExtraDirectory } from "@mininglamp-oss/octo-runtime-host-sdk";
+import { assertExtraName, assertStoredExtra, readStoredExtra } from "@mininglamp-oss/octo-runtime-host-sdk";
 import { withSetupLock, writeJsonAtomic } from "./state.js";
+import { resolveModuleSpecifier } from "@mininglamp-oss/octo-runtime-adapter-sdk/module-manifest";
 /** Generic full replacement: no platform-specific CLI fields or validation. */
 export async function setExtra(paths, name, input) {
     assertExtraName(name);
@@ -29,33 +30,31 @@ export async function setExtra(paths, name, input) {
         return { saved: true, name, file, reload_required: true };
     });
 }
-export async function readExtra(paths, name) {
+/** CLI 将模块目录与业务配置装配；仅 load 时解析/import，禁用项及未启动项不执行模块。 */
+export async function readExtra(paths, name, manifest) {
     assertExtraName(name);
-    const entries = await readExtraDirectory(join(paths.home, "extras"));
-    const entry = entries.find((item) => item.name === name);
+    const stored = await getExtra(paths, name);
+    const entry = manifest.extras.find((item) => item.name === name);
     if (!entry)
-        throw new Error("EXTRA_NOT_REGISTERED");
-    // Invalid stored declarations carry a controlled read error through their loader.
-    if (!entry.module)
-        await entry.load();
+        throw new Error("EXTRA_MANIFEST_DECLARATION_REQUIRED");
+    if (stored.module !== undefined && stored.module !== entry.module)
+        throw new Error("EXTRA_MODULE_MIGRATION_REQUIRED");
     return {
         name,
         module: entry.module,
-        config: entry.config,
-        ...(entry.enabled === undefined ? {} : { enabled: entry.enabled })
+        config: stored.config,
+        enabled: stored.enabled,
+        load: () => import(resolveModuleSpecifier(entry.module, entry.sourceManifest))
     };
 }
 export async function getExtra(paths, name) {
     assertExtraName(name);
-    const entries = await readExtraDirectory(join(paths.home, "extras"));
-    const entry = entries.find((item) => item.name === name);
-    if (!entry)
-        throw new Error("EXTRA_NOT_REGISTERED");
-    if (!entry.module)
-        await entry.load();
-    return {
-        module: entry.module,
-        ...(entry.enabled === undefined ? {} : { enabled: entry.enabled }),
-        config: entry.config
-    };
+    try {
+        return await readStoredExtra(join(paths.home, "extras"), name);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            throw new Error("EXTRA_NOT_REGISTERED", { cause: error });
+        throw error;
+    }
 }

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>;