@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/apps/daemon/dist/openclaw.js

@@ -0,0 +1,234 @@
+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";
+import { join, resolve } from "node:path";
+import JSON5 from "json5";
+import { configureOpenClawConnection, readOpenClawConnection, loadLocalOpenClawGateway, LocalGatewayError, createOpenClawAdapter, OPENCLAW_RUNTIME_ROOT } from "@mininglamp-oss/octo-runtime-adapter-openclaw";
+/** CLI composition only: resolve discovery before entering the shared execution path. */
+export async function configureCliOpenClaw(runtimeRoot, input = {}, env = process.env) {
+    const explicit = Object.values(input).some((value) => value !== undefined);
+    let savedConfigFile;
+    if (!explicit) {
+        const saved = await readOpenClawConnection(runtimeRoot);
+        if (saved) {
+            const origin = await readCliOrigin(runtimeRoot);
+            if (origin?.credential_ref === saved.credential_ref) {
+                input = { openclawHome: origin.openclaw_home };
+                savedConfigFile = origin.openclaw_config_path;
+            }
+            else {
+                await loadLocalOpenClawGateway(runtimeRoot);
+                return saved;
+            }
+        }
+        else {
+            input = {
+                openclawHome: env.OPENCLAW_HOME,
+                url: env.OPENCLAW_GATEWAY_URL,
+                token: env.OPENCLAW_GATEWAY_TOKEN
+            };
+        }
+    }
+    if (input.openclawHome !== undefined && (input.url !== undefined || input.token !== undefined))
+        throw new LocalGatewayError("connection_sources_conflict");
+    if (input.url !== undefined || input.token !== undefined)
+        return configureOpenClawConnection(runtimeRoot, input);
+    if (input.openclawHome !== undefined && !input.openclawHome.trim())
+        throw new LocalGatewayError("openclaw_home_invalid");
+    let configFile = env.OPENCLAW_CONFIG_PATH;
+    if (input.openclawHome === undefined && !configFile && !env.OPENCLAW_STATE_DIR) {
+        try {
+            const output = await promisify(execFile)("openclaw", ["config", "file", "--json"], {
+                env,
+                timeout: 5000,
+                maxBuffer: 64 * 1024
+            });
+            const discovered = record(JSON.parse(output.stdout));
+            if (typeof discovered?.path === "string")
+                configFile = discovered.path;
+        }
+        catch {
+            /* An absent optional CLI falls back to the established local source. */
+        }
+    }
+    const expand = (path) => resolve(path.replace(/^~(?=\/|$)/, env.HOME || homedir()));
+    const home = expand(input.openclawHome ??
+        env.OPENCLAW_STATE_DIR ??
+        join(env.HOME || homedir(), env.OPENCLAW_PROFILE ? `.openclaw-${env.OPENCLAW_PROFILE}` : ".openclaw"));
+    const activeConfig = savedConfigFile ??
+        (input.openclawHome !== undefined
+            ? join(home, "openclaw.json")
+            : configFile
+                ? expand(configFile)
+                : join(home, "openclaw.json"));
+    const connection = await readOpenClawHome(home, activeConfig);
+    const saved = await configureOpenClawConnection(runtimeRoot, connection);
+    const directory = join(runtimeRoot, "adapters", "openclaw");
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const temporary = join(directory, `.cli-source-${randomUUID()}.tmp`);
+    await writeFile(temporary, JSON.stringify({
+        openclaw_home: home,
+        openclaw_config_path: activeConfig,
+        credential_ref: saved.credential_ref
+    }), { mode: 0o600 });
+    await rename(temporary, join(directory, "cli-source.json"));
+    return saved;
+}
+async function readCliOrigin(root) {
+    try {
+        const value = record(JSON.parse(await readFile(join(root, "adapters", "openclaw", "cli-source.json"), "utf8")));
+        if (typeof value?.openclaw_home !== "string" || typeof value?.credential_ref !== "string")
+            throw new LocalGatewayError("cli_source_invalid");
+        return {
+            openclaw_home: value.openclaw_home,
+            ...(typeof value.openclaw_config_path === "string"
+                ? { openclaw_config_path: value.openclaw_config_path }
+                : {}),
+            credential_ref: value.credential_ref
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new LocalGatewayError("cli_source_invalid");
+    }
+}
+/** Octospec F24: one instance uses the last enabled OpenClaw Bot, never another Adapter. */
+export async function syncCliOpenClawToolEnvironment(runtimeRoot, extras) {
+    const channel = extras.find((extra) => extra.name === "channel-gateway" && extra.enabled !== false);
+    if (!channel || channel.config.bots === undefined)
+        return { written: false, restartRequired: false };
+    const bots = channel.config.bots;
+    validateImBots(bots);
+    let values;
+    for (const bot of bots) {
+        if (bot.enabled === false || bot.adapter.adapter_type !== "openclaw")
+            continue;
+        const token = configuredCredential(bot);
+        if (!token)
+            throw new Error("IM_CREDENTIALS_REQUIRED");
+        values = Object.fromEntries(octoCliEnvironment(bot.api_url, token).env_variables.map(({ key, value }) => [key, value]));
+    }
+    if (!values)
+        return { written: false, restartRequired: false };
+    const origin = await readCliOrigin(runtimeRoot);
+    const connection = await readOpenClawConnection(runtimeRoot);
+    if (!origin || origin.credential_ref !== connection?.credential_ref)
+        return { written: false, restartRequired: false };
+    const file = join(origin.openclaw_home, ".env");
+    const directory = await lstat(origin.openclaw_home);
+    if (!directory.isDirectory())
+        throw new Error("OPENCLAW_ENV_DIRECTORY_INVALID");
+    let previous = "";
+    try {
+        const info = await lstat(file);
+        if (!info.isFile())
+            throw new Error("OPENCLAW_ENV_FILE_INVALID");
+        previous = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    // Remove only complete managed assignments, including quoted multiline values.
+    const retained = previous.replace(/^[\t ]*(?:export[\t ]+)?(?:OCTO_BOT_TOKEN|OCTO_API_BASE_URL)[\t ]*=[\t ]*(?:"(?:\\.|[^"\\])*"|'[^']*'|[^\r\n]*)(?:[\t ]*#[^\r\n]*)?[\t ]*(?:\r?\n|$)/gm, "");
+    const content = retained +
+        (retained && !retained.endsWith("\n") ? "\n" : "") +
+        Object.entries(values)
+            .map(([key, value]) => `${key}=${JSON.stringify(value)}\n`)
+            .join("");
+    const before = parseEnv(previous), after = parseEnv(content);
+    if (Object.entries(before).some(([key, value]) => !Object.hasOwn(values, key) && after[key] !== value) ||
+        Object.entries(values).some(([key, value]) => after[key] !== value))
+        throw new Error("OPENCLAW_ENV_UPDATE_INVALID");
+    if (content === previous) {
+        await chmod(file, 0o600);
+        return { file, written: false, restartRequired: true };
+    }
+    const temporary = join(origin.openclaw_home, `.octo-env-${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, content, { mode: 0o600, flag: "wx" });
+        await rename(temporary, file);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return { file, written: true, restartRequired: true };
+}
+/** An absent optional Provider must not prevent the CLI daemon from starting. */
+export async function initializeCliOpenClaw(runtimeRoot, env = process.env) {
+    try {
+        await configureCliOpenClaw(runtimeRoot, {}, env);
+        const probe = await createOpenClawAdapter().probe({
+            providerOptions: { [OPENCLAW_RUNTIME_ROOT]: runtimeRoot }
+        });
+        if (!probe.available)
+            console.error(`OpenClaw: ${probe.reason}`);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof LocalGatewayError && error.reason === "config_not_found")
+            return (await readOpenClawConnection(runtimeRoot)) === undefined;
+        // Report only controlled reason codes; never echo config contents or credentials.
+        if (error instanceof LocalGatewayError) {
+            console.error(`OpenClaw: ${error.reason}`);
+            return false;
+        }
+        throw error;
+    }
+}
+async function readOpenClawHome(home, configFile = join(home, "openclaw.json")) {
+    let source;
+    try {
+        source = await readFile(configFile, "utf8");
+    }
+    catch (error) {
+        throw new LocalGatewayError(error.code === "ENOENT" ? "config_not_found" : "config_unreadable");
+    }
+    let config;
+    try {
+        const parsed = record(JSON5.parse(source));
+        if (!parsed)
+            throw new Error();
+        config = parsed;
+    }
+    catch {
+        throw new LocalGatewayError("config_invalid");
+    }
+    const gateway = record(config.gateway);
+    if (Object.hasOwn(config, "$include") ||
+        !gateway ||
+        (gateway.mode && gateway.mode !== "local") ||
+        record(gateway.tls)?.enabled)
+        throw new LocalGatewayError("config_unsupported");
+    const auth = record(gateway.auth);
+    const token = auth?.token;
+    if ((auth?.mode && auth.mode !== "token") ||
+        typeof token !== "string" ||
+        !token.trim() ||
+        token.includes("${"))
+        throw new LocalGatewayError("auth_config_unsupported");
+    const port = gateway.port ?? 18789;
+    if (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)
+        throw new LocalGatewayError("config_invalid");
+    const bind = gateway.bind ?? "loopback";
+    const host = bind === "custom" ? gateway.customBindHost : "127.0.0.1";
+    const localAddresses = Object.values(networkInterfaces()).flatMap((entries) => entries?.map((entry) => entry.address) ?? []);
+    if (typeof bind !== "string" ||
+        !["loopback", "lan", "auto", "custom"].includes(bind) ||
+        typeof host !== "string" ||
+        !isIP(host) ||
+        !["127.0.0.1", "::1", "0.0.0.0", "::", ...localAddresses].includes(host))
+        throw new LocalGatewayError("local_address_unsupported");
+    const localHost = host === "0.0.0.0" ? "127.0.0.1" : host === "::" ? "::1" : host;
+    return { url: `ws://${isIP(localHost) === 6 ? `[${localHost}]` : localHost}:${port}`, token };
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}

package/apps/daemon/dist/runtime-options.d.ts

@@ -0,0 +1,9 @@
+import type { StartDaemonServerOptions } from "./server.js";
+export declare function resolveDaemonRuntimePaths(args?: string[], env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): StartDaemonServerOptions & {
+    executionOnly: boolean;
+    profile: string;
+};
+export declare function daemonRuntimeArguments(paths: StartDaemonServerOptions & {
+    executionOnly?: boolean;
+    profile?: string;
+}): string[];

package/apps/daemon/dist/runtime-options.js

@@ -0,0 +1,58 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runtimeControlEndpoint } from "@mininglamp-oss/octo-runtime-daemon/runtime-endpoint";
+export function resolveDaemonRuntimePaths(args = process.argv.slice(2), env = process.env, platform = process.platform) {
+    const defaultHome = platform === "win32" && env.LOCALAPPDATA?.trim()
+        ? join(env.LOCALAPPDATA.trim(), "OctoRuntime")
+        : join(env.HOME?.trim() || homedir(), ".octo-runtime");
+    const home = resolve(option(args, ["--home"], env.OCTO_RUNTIME_HOME ?? defaultHome));
+    const socket = runtimeControlEndpoint(home, platform);
+    return {
+        executionOnly: args.includes("--execution-only"),
+        profile: option(args, ["--profile"], "default"),
+        ...(args.includes("--state-directory")
+            ? { stateDirectory: resolve(option(args, ["--state-directory"], "")) }
+            : {}),
+        homePath: home,
+        pidPath: resolve(option(args, ["--pid-file"], env.OCTO_RUNTIME_PID_FILE ?? join(home, "octo-daemon.pid"))),
+        consoleOutput: args.includes("--console"),
+        ...(args.includes("--logs-dir")
+            ? { logging: { directory: resolve(option(args, ["--logs-dir"], "")) } }
+            : {}),
+        socketPath: option(args, ["--socket"], env.OCTO_RUNTIME_SOCKET ?? socket),
+        // 这是 CLI 模式的 daemon 默认值；SDK 使用自己的代码装配入口，不读取此资源。
+        manifestPath: resolve(option(args, ["--manifest"], env.OCTO_RUNTIME_MANIFEST ??
+            fileURLToPath(new URL("../../cli/dist/default_adapters.json", import.meta.url)))),
+        hostEntrypoint: resolve(option(args, ["--adapter-host", "--host-entrypoint"], env.OCTO_RUNTIME_ADAPTER_HOST ??
+            fileURLToPath(import.meta.resolve("@mininglamp-oss/octo-runtime-adapter-host/runner"))))
+    };
+}
+export function daemonRuntimeArguments(paths) {
+    return [
+        ...(paths.executionOnly ? ["--execution-only"] : []),
+        ...(paths.profile ? ["--profile", paths.profile] : []),
+        ...(paths.stateDirectory ? ["--state-directory", paths.stateDirectory] : []),
+        ...(paths.homePath ? ["--home", paths.homePath] : []),
+        ...(paths.pidPath ? ["--pid-file", paths.pidPath] : []),
+        ...(paths.consoleOutput ? ["--console"] : []),
+        ...(paths.logging ? ["--logs-dir", paths.logging.directory] : []),
+        "--socket",
+        paths.socketPath,
+        ...(paths.manifestPath ? ["--manifest", paths.manifestPath] : []),
+        "--adapter-host",
+        paths.hostEntrypoint
+    ];
+}
+function option(args, names, fallback) {
+    for (const name of names) {
+        const index = args.indexOf(name);
+        if (index < 0)
+            continue;
+        const value = args[index + 1];
+        if (!value || value.startsWith("--"))
+            throw new Error(`missing value for ${name}`);
+        return value;
+    }
+    return fallback;
+}

package/apps/daemon/dist/server.d.ts

@@ -0,0 +1 @@
+export * from "@mininglamp-oss/octo-runtime-daemon";

package/apps/daemon/dist/server.js

@@ -0,0 +1 @@
+export * from "@mininglamp-oss/octo-runtime-daemon";

package/dist/public/extra.d.ts

@@ -0,0 +1,4 @@
+export * from "./protocol.js";
+export type { ExtraAdapterHost, ExtraContext, RuntimeLog, RuntimeLogLevel, ExtraDisposer, ExtraInitializer, ChannelDependencies, LoadContexts, ExtraPlugin, ExtraPluginModule, ExtraRegistration, ExtraStatus, ExtraStatusHandler, JsonObject, JsonValue } from "@mininglamp-oss/octo-runtime-daemon/extra";
+export { ExtraPlugins } from "@mininglamp-oss/octo-runtime-daemon/extra";
+export type { ExtraDescriptor, StoredExtra } from "@mininglamp-oss/octo-runtime-daemon/extra-config";

package/dist/public/extra.js

@@ -0,0 +1,2 @@
+export * from "./protocol.js";
+export { ExtraPlugins } from "@mininglamp-oss/octo-runtime-daemon/extra";

package/dist/public/protocol.d.ts

@@ -0,0 +1,3 @@
+export type * from "@mininglamp-oss/octo-runtime-protocol";
+export type { CanonicalEventWire, ContextMcpLocator, ContextMcpPayload, ContextModelSelectionPayload, PersistentContextEnvelope, PublicObjectMaterial } from "@mininglamp-oss/octo-runtime-protocol/browser";
+export { InvokeInput, assertInvokeInput, CONTEXT_SCHEMA, CONTEXT_MAX_BYTES, CONTEXT_MAX_ITEMS, RUNTIME_RUN_CONTRACT, PROTOCOL_VERSION, APPROVAL_MODES, CANONICAL_EVENT_TYPES, TERMINAL_EVENT_TYPES, INTERACTION_RESPONSE_OUTCOMES, IMAGE_INPUT_LIMITS, IMAGE_INPUT_MIME_TYPES, assertContextEnvelope, assertModelInputParts, assertRuntimeLimits, assertCanonicalEvent, assertApprovalRequest, assertInteractionResponse, assertNativeInteractionResponse, assertHostRunReceipt, assertHostControl, assertHostFrame, assertHostFrameIdentity, assertFailureEnvelope, isTerminal, isHostTerminal, canonicalEvents, contextItem, contextHash, messageExposure, isFailureEnvelope, failureMessage } from "@mininglamp-oss/octo-runtime-protocol";

package/dist/public/protocol.js

@@ -0,0 +1 @@
+export { InvokeInput, assertInvokeInput, CONTEXT_SCHEMA, CONTEXT_MAX_BYTES, CONTEXT_MAX_ITEMS, RUNTIME_RUN_CONTRACT, PROTOCOL_VERSION, APPROVAL_MODES, CANONICAL_EVENT_TYPES, TERMINAL_EVENT_TYPES, INTERACTION_RESPONSE_OUTCOMES, IMAGE_INPUT_LIMITS, IMAGE_INPUT_MIME_TYPES, assertContextEnvelope, assertModelInputParts, assertRuntimeLimits, assertCanonicalEvent, assertApprovalRequest, assertInteractionResponse, assertNativeInteractionResponse, assertHostRunReceipt, assertHostControl, assertHostFrame, assertHostFrameIdentity, assertFailureEnvelope, isTerminal, isHostTerminal, canonicalEvents, contextItem, contextHash, messageExposure, isFailureEnvelope, failureMessage } from "@mininglamp-oss/octo-runtime-protocol";

package/node_modules/@mininglamp-oss/octo-runtime-acp-client/dist/index.d.ts

@@ -0,0 +1,120 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+type JsonRecord = Record<string, unknown>;
+type PermissionHandler = (params: JsonRecord) => unknown;
+export interface AcpUpdate extends JsonRecord {
+    type?: string;
+    usage?: JsonRecord;
+    model?: string;
+    stopReason?: string;
+    finishReason?: string;
+}
+export interface SpawnAcpClientOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    signal?: AbortSignal;
+    permissionHandler?: PermissionHandler;
+    onPermissionResponseWritten?: (params: JsonRecord) => void;
+    onPermissionResponseFailed?: (params: JsonRecord, error: Error) => void;
+}
+export interface AcpRequestOptions {
+    timeoutMs?: number;
+    onWritten?: () => void;
+    /** A real JSON-RPC id previously allocated by `reserveRequestId`. */
+    requestId?: number;
+}
+export type AcpPromptContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    mimeType: string;
+    data: string;
+};
+/** Build the exact params serialized by `session/new`. */
+export declare function acpNewSessionParams({ cwd, model }: {
+    cwd: string;
+    model?: string;
+}): JsonRecord;
+/** Build the exact params serialized by `session/load`. */
+export declare function acpLoadSessionParams(sessionId: string, { cwd }?: {
+    cwd?: string;
+}): JsonRecord;
+/** Build the exact params serialized by `session/prompt`. */
+export declare function acpPromptParams(sessionId: string, input: string | readonly AcpPromptContent[]): JsonRecord;
+/**
+ * JSON-RPC 2.0 client for an ACP (Agent Client Protocol) subprocess, used by the
+ * CodeBuddy adapter. Frames are newline-delimited JSON over the child's stdio.
+ * The client multiplexes three inbound message kinds on one stdout stream:
+ * responses matched to outbound requests by numeric `id`, `session/update`
+ * notifications routed to the per-session update queue, and inbound permission
+ * *requests* the client must answer. If the process dies with work outstanding,
+ * every pending request and update queue is failed with the captured stderr.
+ */
+export declare class AcpClient {
+    #private;
+    constructor({ child, permissionHandler, onPermissionResponseWritten, onPermissionResponseFailed, processGroup }: {
+        child: ChildProcessWithoutNullStreams;
+        processGroup?: boolean;
+        permissionHandler?: PermissionHandler;
+        onPermissionResponseWritten?: (params: JsonRecord) => void;
+        onPermissionResponseFailed?: (params: JsonRecord, error: Error) => void;
+    });
+    /**
+     * Allocate the JSON-RPC id that a later request will put on the wire. This
+     * lets callers durably record the exact request identity before dispatch
+     * without fabricating an adapter-local correlation id.
+     */
+    reserveRequestId(): number;
+    /**
+     * Issue a JSON-RPC request and resolve with its `result`.
+     *
+     * `onWritten` runs after the serialized frame is accepted by the child stdin
+     * stream and therefore precedes acknowledgement by the peer. A per-call
+     * timeout (unref'd, so it never keeps Node alive) rejects if no response
+     * arrives.
+     */
+    request<T = unknown>(method: string, params: JsonRecord, { timeoutMs, onWritten, requestId }?: AcpRequestOptions): Promise<T>;
+    /** ACP handshake; must precede any session call. Advertises client info and (empty) capabilities. */
+    initialize(input?: JsonRecord): Promise<unknown>;
+    /** Start a fresh provider session and return its ACP `sessionId` (also aliased as `id`); throws if the provider omits it. */
+    newSession(input: {
+        cwd: string;
+        model?: string;
+    }, options?: AcpRequestOptions): Promise<JsonRecord & {
+        id: string;
+        sessionId: string;
+    }>;
+    /** Resume a prior provider session by id; the long timeout accommodates providers that replay history on load. */
+    loadSession(sessionId: string, input?: {
+        cwd?: string;
+    }, options?: AcpRequestOptions): Promise<{
+        id: string;
+    }>;
+    /**
+     * Send a prompt and stream the session's `session/update` events until the
+     * turn completes. The `session/prompt` response is awaited concurrently: its
+     * terminal `usage`/`model` and prompt stop reason are pushed as final
+     * synthetic updates before the queue closes, or a rejection closes the queue
+     * with that error. The
+     * per-session queue is always removed in `finally`. The multi-hour timeout
+     * covers long autonomous turns. `onWritten` observes only the outbound
+     * `session/prompt` frame; completion of this generator implies the correlated
+     * JSON-RPC response was received and is the provider acknowledgement boundary.
+     */
+    prompt(sessionId: string, text: string | readonly AcpPromptContent[], { onWritten, requestId, params }?: Pick<AcpRequestOptions, "onWritten" | "requestId"> & {
+        params?: JsonRecord;
+    }): AsyncGenerator<AcpUpdate>;
+    /** Fire-and-forget cancel notification (no id, so no response is expected) asking the provider to abort the turn. */
+    cancel(sessionId: string): void;
+    /** R06：所有关闭调用等待同一次进程组回收，失败保留给调用方。 */
+    close(): Promise<void>;
+}
+/**
+ * Spawn an ACP provider subprocess and wrap it in an `AcpClient`. On non-Windows
+ * the child is detached into its own process group so cleanup can signal the
+ * whole tree; aborting `signal` closes the client (and thus the process).
+ */
+export declare function spawnAcpClient(options: SpawnAcpClientOptions): AcpClient;
+export {};