@mininglamp-oss/octo-runtime 1.0.1 → 1.1.0

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

@@ -1,133 +0,0 @@
-import { createInputInvoke, identifyInvokeInput } from "@mininglamp-oss/octo-runtime-protocol";
-import { RuntimeLogging } from "@mininglamp-oss/octo-runtime-adapter-sdk";
-import { ExtraPlugins } from "../extras.js";
-import { invokeDaemonRun } from "./run-stream.js";
-import { callDaemon } from "./runtime-contract.js";
-/** .octospec/tasks/sdk-host-extra-contexts/flows.md：SDK 持有装配与执行桥，宿主只传业务依赖。 */
-export class LocalExtras {
-    socket;
-    isActive;
-    plugins;
-    #logs;
-    #invocations = new Map();
-    #runs = new Set();
-    #closing;
-    constructor(socket, isActive, logging) {
-        this.socket = socket;
-        this.isActive = isActive;
-        this.#logs = new RuntimeLogging(logging);
-        // 容器的基础端口不交给业务；每个实例再绑定自己的停止信号与调用所有权。
-        const unavailable = () => {
-            throw new Error("EXTRA_EXECUTION_NOT_BOUND");
-        };
-        this.plugins = new ExtraPlugins([], {
-            invoke: createInputInvoke(unavailable),
-            cancel: unavailable,
-            respondInteraction: unavailable
-        }, (name) => this.#logs.extra(name));
-    }
-    load(module, config, dependencies) {
-        return this.plugins.load({
-            name: module.name,
-            default: (context, snapshot) => {
-                const port = this.#createPort(context);
-                return module.default({ ...context, adapterHost: port }, snapshot);
-            }
-        }, config, dependencies);
-    }
-    #release(invocation) {
-        if (this.#invocations.get(invocation.invocationId) === invocation) {
-            this.#invocations.delete(invocation.invocationId);
-            this.#runs.delete(invocation.runId);
-        }
-    }
-    #createPort(context) {
-        const owned = new Set();
-        const assertActive = () => {
-            context.signal.throwIfAborted();
-            if (!this.isActive())
-                throw new Error("EXTRA_ACCOUNT_CHANGED");
-        };
-        const port = {
-            list: async () => {
-                assertActive();
-                return callDaemon(this.socket, { method: "adapter.list" });
-            },
-            invoke: createInputInvoke(async function* (input, environment = {}) {
-                assertActive();
-                environment.signal?.throwIfAborted();
-                const request = identifyInvokeInput(input);
-                if (this.#invocations.has(request.invocationId) || this.#runs.has(request.runId))
-                    throw new Error("EXECUTION_IDENTITY_CONFLICT");
-                const controller = new AbortController();
-                const signal = AbortSignal.any([
-                    context.signal,
-                    controller.signal,
-                    ...(environment.signal ? [environment.signal] : [])
-                ]);
-                const source = invokeDaemonRun(this.socket, request, { ...environment, signal });
-                const invocation = {
-                    invocationId: request.invocationId,
-                    runId: request.runId,
-                    controller,
-                    source,
-                    accepted: false
-                };
-                this.#invocations.set(request.invocationId, invocation);
-                this.#runs.add(request.runId);
-                owned.add(invocation);
-                try {
-                    for await (const frame of source) {
-                        invocation.accepted = true;
-                        yield frame;
-                    }
-                    signal.throwIfAborted();
-                }
-                finally {
-                    this.#release(invocation);
-                    owned.delete(invocation);
-                }
-            }.bind(this)),
-            cancel: async (invocationId) => {
-                assertActive();
-                const invocation = this.#invocations.get(invocationId);
-                if (!invocation || !owned.has(invocation))
-                    return { cancelled: false };
-                invocation.controller.abort(new Error("caller_aborted"));
-                // invokeDaemonRun 与服务端覆盖接纳前取消；不把 invocationId 错当作 runId。
-                await invocation.source.return(undefined);
-                this.#release(invocation);
-                owned.delete(invocation);
-                return { cancelled: true };
-            },
-            respondInteraction: async (invocationId, response) => {
-                assertActive();
-                const invocation = this.#invocations.get(invocationId);
-                if (!invocation ||
-                    !owned.has(invocation) ||
-                    !invocation.accepted ||
-                    invocation.controller.signal.aborted)
-                    throw new Error("EXTRA_INVOCATION_NOT_ACTIVE");
-                await callDaemon(this.socket, {
-                    method: "agent_run.respond",
-                    params: { run_id: invocation.runId, response }
-                });
-            }
-        };
-        context.onDispose(async () => {
-            const results = await Promise.allSettled([...owned].map(async (invocation) => {
-                invocation.controller.abort();
-                await invocation.source.return(undefined);
-                this.#release(invocation);
-                owned.delete(invocation);
-            }));
-            if (results.some((result) => result.status === "rejected"))
-                throw new Error("EXTRA_DISPOSE_FAILED");
-        });
-        return port;
-    }
-    close() {
-        this.#closing ??= this.plugins.close().finally(() => this.#logs.close());
-        return this.#closing;
-    }
-}

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/run-stream.d.ts

@@ -1,14 +0,0 @@
-import { type HostFrame, type InvokeInput, type InvokeEnvironment } from "@mininglamp-oss/octo-runtime-protocol";
-/** Local source notifications have no per-event ACK and allocate no durable consumer queue. */
-export declare function subscribeDaemonRun(socketPath: string, input: {
-    runId: string;
-    streamId?: string;
-    afterSeq?: number;
-    signal?: AbortSignal;
-    invocation?: {
-        input: InvokeInput;
-        executionEnvOverrides?: InvokeEnvironment["executionEnvOverrides"];
-    };
-}): AsyncIterable<Record<string, unknown>>;
-/** A single local invoke RPC returns its canonical notifications; replay only repairs IPC loss. */
-export declare function invokeDaemonRun(socketPath: string, input: InvokeInput, environment?: InvokeEnvironment): AsyncGenerator<HostFrame>;

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/run-stream.js

@@ -1,223 +0,0 @@
-import { createConnection } from "node:net";
-import { randomUUID } from "node:crypto";
-import { assertHostFrameIdentity, assertHostRunReceipt, isHostTerminal, identifyInvokeInput, assertJsonByteLimit, INVOKE_REQUEST_MAX_BYTES, HOST_RPC_MAX_LINE_BYTES, streamCapacityError } from "@mininglamp-oss/octo-runtime-protocol";
-import { callDaemon } from "./runtime-contract.js";
-/** Local source notifications have no per-event ACK and allocate no durable consumer queue. */
-export async function* subscribeDaemonRun(socketPath, input) {
-    if (input.signal?.aborted)
-        return;
-    const wireRequest = {
-        jsonrpc: "2.0",
-        id: randomUUID(),
-        method: input.invocation ? "agent_run.invoke" : "agent_run.subscribe",
-        params: input.invocation
-            ? { ...input.invocation }
-            : {
-                run_id: input.runId,
-                ...(input.streamId ? { stream_id: input.streamId } : {}),
-                after_seq: input.afterSeq ?? 0
-            }
-    };
-    assertJsonByteLimit(wireRequest, INVOKE_REQUEST_MAX_BYTES, "INVOKE_REQUEST_TOO_LARGE");
-    const socket = createConnection(socketPath);
-    const abort = () => {
-        socket.destroy();
-    };
-    input.signal?.addEventListener("abort", abort, { once: true });
-    socket.setEncoding("utf8");
-    socket.setTimeout(5000, () => socket.destroy(new Error("HOST_STREAM_HANDSHAKE_TIMEOUT")));
-    socket.write(`${JSON.stringify(wireRequest)}\n`);
-    let pending = [];
-    let pendingBytes = 0, started = false;
-    const assertLineBytes = (measuredBytes) => {
-        if (measuredBytes > HOST_RPC_MAX_LINE_BYTES)
-            throw streamCapacityError("HOST_FRAME_TOO_LARGE", {
-                boundary: "daemon.stream_transport",
-                measuredBytes,
-                limitBytes: HOST_RPC_MAX_LINE_BYTES
-            });
-    };
-    try {
-        for await (const chunk of socket) {
-            const text = String(chunk);
-            let start = 0;
-            let boundary = text.indexOf("\n");
-            while (boundary >= 0) {
-                const segment = text.slice(start, boundary);
-                pending.push(segment);
-                pendingBytes += Buffer.byteLength(segment, "utf8");
-                assertLineBytes(pendingBytes);
-                const line = pending.join("");
-                pending = [];
-                pendingBytes = 0;
-                const frame = JSON.parse(line);
-                if (frame.jsonrpc !== "2.0")
-                    throw new Error("HOST_STREAM_PROTOCOL_INVALID");
-                if (frame.error) {
-                    const error = frame.error;
-                    throw new Error(error.message ?? "HOST_STREAM_FAILED");
-                }
-                if (!started) {
-                    started = true;
-                    socket.setTimeout(0);
-                }
-                yield frame;
-                if (input.signal?.aborted)
-                    return;
-                start = boundary + 1;
-                boundary = text.indexOf("\n", start);
-            }
-            const remainder = text.slice(start);
-            if (remainder)
-                pending.push(remainder);
-            pendingBytes += Buffer.byteLength(remainder, "utf8");
-            assertLineBytes(pendingBytes);
-        }
-        if (!input.signal?.aborted && (!started || pending.some((segment) => segment.trim())))
-            throw new Error("HOST_STREAM_DISCONNECTED");
-    }
-    finally {
-        input.signal?.removeEventListener("abort", abort);
-        socket.destroy();
-    }
-}
-/** A single local invoke RPC returns its canonical notifications; replay only repairs IPC loss. */
-export async function* invokeDaemonRun(socketPath, input, environment = {}) {
-    const request = identifyInvokeInput(input);
-    const { signal, executionEnvOverrides } = environment;
-    if (signal?.aborted)
-        throw signal.reason instanceof Error ? signal.reason : new Error("caller_aborted");
-    let receipt;
-    let streamId, after = 0, terminal = false, attempts = 0;
-    let cancellation;
-    const cancel = () => {
-        if (cancellation)
-            return;
-        // ACK 在途时先核对真实身份，不能取消恰好使用同一 runId 的另一调用。
-        // 未接纳的请求由服务端接纳期 signal 取消，不重复 invoke 或无限重试。
-        cancellation = (async () => {
-            const accepted = receipt ??
-                receiptFrom(await callDaemon(socketPath, {
-                    method: "agent_run.get",
-                    params: { run_id: request.runId }
-                }));
-            if (accepted.run_id !== request.runId ||
-                accepted.invocation_id !== request.invocationId ||
-                accepted.agent_session_id !== request.sessionId ||
-                accepted.session_generation !== (request.sessionGeneration ?? 0) ||
-                accepted.protocol_mode !== (request.protocol_mode ?? "native"))
-                return;
-            await callDaemon(socketPath, {
-                method: "agent_run.cancel",
-                params: { run_id: request.runId }
-            });
-        })().catch(() => undefined);
-    };
-    signal?.addEventListener("abort", cancel, { once: true });
-    try {
-        while (!terminal && !signal?.aborted) {
-            try {
-                for await (const frame of subscribeDaemonRun(socketPath, {
-                    runId: request.runId,
-                    streamId,
-                    afterSeq: after,
-                    signal,
-                    ...(!streamId
-                        ? {
-                            invocation: {
-                                input: request,
-                                ...(executionEnvOverrides ? { executionEnvOverrides } : {})
-                            }
-                        }
-                        : {})
-                })) {
-                    if (frame.result) {
-                        const metadata = receiptFrom(frame.result);
-                        if (metadata.run_id !== request.runId ||
-                            metadata.invocation_id !== request.invocationId ||
-                            metadata.agent_session_id !== request.sessionId ||
-                            metadata.session_generation !== (request.sessionGeneration ?? 0) ||
-                            metadata.protocol_mode !== (request.protocol_mode ?? "native") ||
-                            !metadata.stream_id ||
-                            (streamId && streamId !== metadata.stream_id))
-                            throw new Error("STREAM_EXPIRED");
-                        streamId = metadata.stream_id;
-                        receipt = metadata;
-                        continue;
-                    }
-                    const params = frame.params;
-                    if (params?.run_id !== request.runId || params.stream_id !== streamId)
-                        throw new Error("HOST_STREAM_IDENTITY_INVALID");
-                    if (frame.method === "agent_run.stream_error")
-                        throw new Error(params.code ?? "STREAM_GAP");
-                    if (frame.method !== "agent_run.event" ||
-                        !params.event ||
-                        !Number.isSafeInteger(params.seq))
-                        throw new Error("HOST_STREAM_PROTOCOL_INVALID");
-                    if (params.seq <= after)
-                        continue;
-                    if (params.seq !== after + 1)
-                        throw new Error("STREAM_GAP");
-                    if (!receipt)
-                        throw new Error("HOST_STREAM_IDENTITY_INVALID");
-                    assertHostFrameIdentity(params.event, receipt);
-                    if (params.event.seq !== params.seq)
-                        throw new Error("STREAM_GAP");
-                    after = params.seq;
-                    terminal = isHostTerminal(params.event);
-                    yield params.event;
-                    if (terminal)
-                        return;
-                }
-                if (!terminal && !signal?.aborted)
-                    throw new Error("HOST_STREAM_DISCONNECTED");
-            }
-            catch (error) {
-                if (signal?.aborted)
-                    return;
-                const code = error instanceof Error ? error.message : String(error);
-                if (![
-                    "HOST_STREAM_DISCONNECTED",
-                    "read ECONNRESET",
-                    "HOST_STREAM_HANDSHAKE_TIMEOUT"
-                ].includes(code) ||
-                    ++attempts > 3)
-                    throw error;
-                if (!streamId) {
-                    const info = receiptFrom(await callDaemon(socketPath, {
-                        method: "agent_run.get",
-                        params: { run_id: request.runId }
-                    }));
-                    if (info.invocation_id !== request.invocationId ||
-                        info.protocol_mode !== (request.protocol_mode ?? "native") ||
-                        info.agent_session_id !== request.sessionId ||
-                        info.session_generation !== (request.sessionGeneration ?? 0))
-                        throw new Error("EXECUTION_IDENTITY_CONFLICT", { cause: error });
-                    receipt = info;
-                    streamId = info.stream_id;
-                }
-            }
-        }
-    }
-    finally {
-        signal?.removeEventListener("abort", cancel);
-        if (!terminal)
-            cancel();
-        await cancellation;
-    }
-}
-function receiptFrom(value) {
-    if (!value || typeof value !== "object")
-        throw new Error("HOST_RECEIPT_INVALID");
-    const receipt = Object.fromEntries([
-        "run_id",
-        "invocation_id",
-        "stream_id",
-        "agent_session_id",
-        "session_generation",
-        "protocol_mode",
-        "protocol"
-    ].map((key) => [key, Reflect.get(value, key)]));
-    assertHostRunReceipt(receipt);
-    return receipt;
-}

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/runner.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/runner.js

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { join } from "node:path";
-import { readAdapterConfigurations } from "@mininglamp-oss/octo-runtime-adapter-host";
-import { startDaemonServer } from "../server.js";
-import { extraRegistration } from "../extra-config.js";
-import { readJson, writeJsonAtomic } from "./home.js";
-const sessionIndex = process.argv.indexOf("--session");
-const sessionPath = sessionIndex >= 0 ? process.argv[sessionIndex + 1] : undefined;
-if (!sessionPath)
-    throw new Error("usage: octo-runtime-daemon-runner --session <path>");
-const session = readJson(sessionPath);
-if (session.schema_version !== 1 || !session.nonce || !Number.isSafeInteger(session.parent_pid)) {
-    throw new Error("embedded runner session is invalid");
-}
-// SDK 默认执行自己的 import/注册入口，不再继承 CLI JSON。
-// 已有显式 manifest 覆盖仍使用通用 JSON runner，避免路径迁移破坏调用方。
-const manifestPath = session.manifest_path;
-const hostEntrypoint = session.adapter_host_entrypoint ??
-    (manifestPath
-        ? fileURLToPath(import.meta.resolve("@mininglamp-oss/octo-runtime-adapter-host/runner"))
-        : fileURLToPath(new URL("./adapter-host.js", import.meta.url)));
-const profiles = session.profiles.map((profile) => {
-    const root = join(session.account_root, profile);
-    const identity = readJson(join(root, "identity", "runtime.json"));
-    const config = readJson(join(root, "config.json"));
-    return {
-        tenantId: identity.octo_space_id,
-        profile,
-        root,
-        runtimeId: identity.runtime_id,
-        adapterConfigurations: readAdapterConfigurations(root, config.adapters)
-    };
-});
-let stopping = false;
-const stop = () => {
-    if (stopping)
-        return;
-    stopping = true;
-    clearInterval(controlTimer);
-    void (async () => {
-        await application.close();
-    })().then(() => process.exit(0), (error) => {
-        console.error(error instanceof Error ? (error.stack ?? error.message) : String(error));
-        process.exit(1);
-    });
-};
-const application = await startDaemonServer({
-    homePath: session.account_root,
-    socketPath: session.socket_path,
-    manifestPath,
-    hostEntrypoint,
-    ...(session.log_directory ? { logging: { directory: session.log_directory } } : {}),
-    localRuntimes: profiles,
-    extras: (session.extras ?? []).map(extraRegistration),
-    account: {
-        subject: session.subject,
-        profiles,
-        machineId: readJson(join(session.home, "machine.json")).machine_id
-    },
-    modules: session.modules.map((descriptor) => ({
-        id: descriptor.id,
-        create: async (context, config) => {
-            const loaded = (await import(descriptor.module));
-            const create = loaded[descriptor.exportName];
-            if (typeof create !== "function")
-                throw new Error("DAEMON_MODULE_FACTORY_MISSING");
-            return create(context, config);
-        }
-    }))
-});
-writeJsonAtomic(session.supervisor_state, {
-    schema_version: 1,
-    nonce: session.nonce,
-    parent_pid: session.parent_pid,
-    runner_pid: process.pid,
-    host_pid: process.pid,
-    adapter_host_pid: application.hostProcess.child.pid ?? null,
-    started_at: new Date().toISOString()
-});
-const controlTimer = setInterval(() => {
-    if (existsSync(session.shutdown_file)) {
-        try {
-            const shutdown = readJson(session.shutdown_file);
-            if (shutdown.nonce === session.nonce)
-                stop();
-        }
-        catch {
-            // A partial or foreign shutdown file is not authority for this session.
-        }
-        return;
-    }
-    try {
-        process.kill(session.parent_pid, 0);
-    }
-    catch {
-        stop();
-    }
-}, 500);
-controlTimer.unref();
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"])
-    process.on(signal, stop);

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/runtime-contract.d.ts

@@ -1,36 +0,0 @@
-import type { DaemonModuleDescriptor, AccountSubject } from "./types.js";
-import type { ExtraDescriptor } from "../extra-config.js";
-import type { ExtraStatus } from "../extras.js";
-export interface DaemonRunnerSession {
-    schema_version: 1;
-    nonce: string;
-    parent_pid: number;
-    home: string;
-    account_root: string;
-    profiles: string[];
-    subject: AccountSubject;
-    modules: readonly DaemonModuleDescriptor[];
-    extras?: readonly ExtraDescriptor[];
-    socket_path: string;
-    pid_path: string;
-    log_directory?: string;
-    shutdown_file: string;
-    supervisor_state: string;
-    manifest_path?: string;
-    adapter_host_entrypoint?: string;
-}
-export interface DaemonStatus {
-    ready?: boolean;
-    pid?: number;
-    adapterHost?: {
-        pid?: number | null;
-        state?: string;
-    };
-    modules?: Record<string, unknown>;
-    extras?: Record<string, ExtraStatus>;
-}
-export declare function callDaemon<T = unknown>(socketPath: string, request: {
-    method: string;
-    params?: Record<string, unknown>;
-}, timeoutMs?: number): Promise<T>;
-export declare function probeDaemon(socketPath: string, timeoutMs?: number): Promise<DaemonStatus | undefined>;

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/runtime-contract.js

@@ -1,57 +0,0 @@
-import { createConnection } from "node:net";
-export async function callDaemon(socketPath, request, timeoutMs = 5_000) {
-    const socket = createConnection(socketPath);
-    const id = `embedded-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    try {
-        await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new Error("daemon connection timed out")), timeoutMs);
-            socket.once("connect", () => {
-                clearTimeout(timer);
-                resolve();
-            });
-            socket.once("error", (error) => {
-                clearTimeout(timer);
-                reject(error);
-            });
-        });
-        socket.write(`${JSON.stringify({ jsonrpc: "2.0", id, ...request })}\n`);
-        return await new Promise((resolve, reject) => {
-            let buffered = "";
-            const timer = setTimeout(() => reject(new Error("daemon response timed out")), timeoutMs);
-            socket.setEncoding("utf8");
-            socket.on("data", (chunk) => {
-                buffered += chunk;
-                const newline = buffered.indexOf("\n");
-                if (newline < 0)
-                    return;
-                clearTimeout(timer);
-                try {
-                    const response = JSON.parse(buffered.slice(0, newline));
-                    if (response.error)
-                        throw new Error(response.error.message ?? "daemon request failed");
-                    resolve(response.result);
-                }
-                catch (error) {
-                    reject(error instanceof Error
-                        ? error
-                        : new Error("daemon response handling failed", { cause: error }));
-                }
-            });
-            socket.once("end", () => {
-                clearTimeout(timer);
-                reject(new Error("daemon closed before responding"));
-            });
-        });
-    }
-    finally {
-        socket.destroy();
-    }
-}
-export async function probeDaemon(socketPath, timeoutMs = 2_000) {
-    try {
-        return await callDaemon(socketPath, { method: "status" }, timeoutMs);
-    }
-    catch {
-        return undefined;
-    }
-}

package/node_modules/@mininglamp-oss/octo-runtime-daemon/dist/runtime/supervisor.d.ts

@@ -1,23 +0,0 @@
-import { type ChildProcess } from "node:child_process";
-import { type DaemonAccountPaths, type DaemonHomePaths } from "./home.js";
-import { type DaemonStatus } from "./runtime-contract.js";
-import type { AccountSubject, DaemonRuntimeOptions } from "./types.js";
-export interface SupervisedRuntime {
-    child: ChildProcess;
-    nonce: string;
-    paths: DaemonHomePaths;
-}
-export declare function startManagedDaemon(options: {
-    sdk: DaemonRuntimeOptions;
-    paths: DaemonHomePaths;
-    account: DaemonAccountPaths;
-    profiles: readonly string[];
-    subject: AccountSubject;
-    nonce: string;
-}): Promise<{
-    supervised: SupervisedRuntime;
-    status: DaemonStatus;
-}>;
-export declare function stopManagedDaemon(supervised: SupervisedRuntime): Promise<void>;
-export declare function runtimeStatus(supervised: SupervisedRuntime): Promise<DaemonStatus | undefined>;
-export declare function childEnvironment(paths: DaemonHomePaths): NodeJS.ProcessEnv;