@mininglamp-oss/octo-runtime 1.0.1 → 1.1.0

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

@@ -1,478 +1,386 @@
-import { getExtra, setExtra } from "./extras.js";
-import { cliVersionInfo, helpText, validateCommand } from "./help.js";
-import { formatDaemonResult } from "./daemon-output.js";
-import { createHash, randomUUID } from "node:crypto";
-import { access } from "node:fs/promises";
 import net from "node:net";
+import { randomUUID } from "node:crypto";
+import { access, mkdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { arch, hostname, platform as osPlatform, release } from "node:os";
-import { resolveServiceControl, verifyServiceProgram } from "./service-control.js";
-import { assertHomeConfiguration, defaultRuntimeHome, ensureMachineIdentity, runtimePaths, prepareRuntimeDirectories, readJsonFile, reconcileHomeConfiguration, withSetupLock } from "./state.js";
-const DEFAULT_WAIT_MS = 30_000;
-const BOOLEAN_FLAGS = new Set([
-    "help",
-    "version",
-    "json",
-    "noAutostart",
-    "tokenStdin",
-    "quiet",
-    "verbose",
-    "waitOnline"
-]);
+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 { getExtra, readExtra, setExtra } from "./extras.js";
+import { cliVersionInfo, helpText } from "./help.js";
+import { runForegroundService } from "./foreground.js";
+import { defaultRuntimeHome, runtimePaths, withSetupLock, readJsonFile } from "./state.js";
+import { resolveServiceControl } from "./service-control.js";
+import { initializeCliOpenClaw, syncCliOpenClawToolEnvironment } from "./openclaw.js";
+import { readExtraDirectory } from "@mininglamp-oss/octo-runtime-host-sdk";
+import { describeError, formatStatus, recordStartupFailure, readStartupFailure } from "./output.js";
+const components = ["executor-kernel", "channel-gateway"];
+const builtinComponents = [...components, "channel-wecom", "webui"];
 export async function runCli(args, dependencies = {}) {
-    const normalizedArgs = [...args];
-    if (normalizedArgs[0] === "--")
-        normalizedArgs.shift();
-    const { positionals, flags } = parseArguments(normalizedArgs);
-    const output = dependencies.output ?? ((value) => process.stdout.write(`${value}\n`));
-    const command = validateCommand(positionals, flags);
-    if (flags.version === true || (positionals[0] === "version" && flags.help !== true)) {
-        output(cliVersionInfo);
-        return 0;
-    }
-    if (command.help) {
-        output(helpText(command.path));
-        return 0;
-    }
-    if (positionals[0] === "playboard" && flags.help !== true) {
-        if (positionals.length !== 1 ||
-            Object.keys(flags).some((key) => !["manifest", "home", "profile", "verbose"].includes(key))) {
-            throw new Error("playboard accepts only --manifest, --home and --profile; pass the request JSON on stdin");
+    const output = dependencies.output ?? ((line) => process.stdout.write(`${line}\n`));
+    let json = args.includes("--json");
+    let context = {};
+    let runningComponent;
+    try {
+        const { flags, positional } = parse(args);
+        json = Boolean(flags.json);
+        if (flags.version || positional[0] === "version") {
+            output(cliVersionInfo);
+            return 0;
         }
-        const { runPlayboard } = await import("./playboard.js");
-        return runPlayboard({
-            input: dependencies.input ?? process.stdin,
-            output: dependencies.output,
-            env: dependencies.env,
-            home: optionalString(flags.home) ?? defaultRuntimeHome(dependencies.env, dependencies.platform),
-            profile: optionalString(flags.profile) ?? "default",
-            manifest: flags.manifest === undefined ? undefined : requiredFlag(flags.manifest, "manifest")
-        });
-    }
-    const profile = optionalString(flags.profile) ?? "default";
-    const home = optionalString(flags.home) ?? defaultRuntimeHome(dependencies.env, dependencies.platform);
-    const paths = runtimePaths(home, profile);
-    const context = {
-        env: dependencies.env ?? process.env,
-        home: paths.home,
-        profile,
-        paths,
-        flags,
-        positionals,
-        service: resolveServiceControl(dependencies),
-        fetchImplementation: dependencies.fetchImplementation,
-        input: dependencies.input ?? process.stdin,
-        output,
-        sleep: dependencies.sleep ??
-            ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds))),
-        runForegroundDaemon: dependencies.runForegroundDaemon ??
-            (async (daemonArgs) => {
-                const originalArgv = process.argv;
-                const originalExitCode = process.exitCode;
-                process.argv = [process.execPath, originalArgv[1] ?? "octo-runtime", ...daemonArgs];
-                process.exitCode = undefined;
-                try {
-                    await import("../../daemon/dist/launcher.js");
-                    return typeof process.exitCode === "number" ? process.exitCode : 0;
-                }
-                finally {
-                    process.argv = originalArgv;
-                    process.exitCode = originalExitCode;
+        if (flags.help || !positional.length || positional[0] === "help") {
+            output(helpText(builtinComponents.includes(positional[0]) ? positional[0] : undefined));
+            return 0;
+        }
+        // 裸组件帮助仅做词法校验，不读取配置或创建服务管理器。
+        if (positional.length === 1 && builtinComponents.includes(positional[0])) {
+            output(helpText(positional[0]));
+            return 0;
+        }
+        const home = resolve(flags.home ?? defaultRuntimeHome(dependencies.env, dependencies.platform));
+        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 componentNames = [
+            ...new Set([...components, ...registrations.map((entry) => entry.name)])
+        ];
+        const isComponent = (name) => builtinComponents.includes(name) || registrations.some((entry) => entry.name === name);
+        if (positional.length === 1 && isComponent(positional[0])) {
+            output(helpText(positional[0]));
+            return 0;
+        }
+        const service = resolveServiceControl(dependencies);
+        const input = dependencies.input ?? process.stdin;
+        const publish = (value, human) => output(typeof value === "string" ? value : !json && human ? human : JSON.stringify(value, null, 2));
+        const snapshot = async (component) => {
+            const inspect = async () => {
+                let spec = service.spec(home, component);
+                let native = await service.backend.inspect(spec);
+                // 自启是已安装服务的事实，不能用 status 的默认 spec(false) 伪造配置漂移。
+                if (native.enabled) {
+                    spec = { ...spec, enabled: true };
+                    native = await service.backend.inspect(spec);
                 }
-            })
-    };
-    const result = await dispatchCli(context);
-    if (result.diagnostic) {
-        (dependencies.errorOutput ?? ((value) => process.stderr.write(`${value}\n`)))(result.diagnostic);
-    }
-    if (!result.streamed && result.value !== undefined) {
-        output(positionals[0] === "daemon" && flags.json !== true && typeof result.value !== "string"
-            ? formatDaemonResult(result.value)
-            : typeof result.value === "string"
-                ? result.value
-                : JSON.stringify(result.value, null, 2));
-    }
-    return result.exitCode ?? 0;
-}
-async function dispatchCli(context) {
-    const [group, action, id] = context.positionals;
-    if (group === "extraset") {
-        return { value: await setExtra(context.paths, required(action, "extra-name"), context.input) };
-    }
-    if (group === "extraget")
-        return {
-            value: await getExtra(context.paths, required(action, "extra-name")),
-            diagnostic: `Config file: ${join(context.home, "extras", action, "config.json")}`
+                return native;
+            };
+            // 原生管理器和 IPC 是两条独立事实；管理器失效不能跳过 Extra 自身的 status。
+            const [native, runtime] = await Promise.all([
+                inspect().catch((error) => ({
+                    manager: service.backend.kind,
+                    state: "unknown",
+                    enabled: false,
+                    drift: [],
+                    detail: describeError(error).code
+                })),
+                componentStatus(home, component, dependencies.platform).catch((error) => ({
+                    available: false,
+                    error: describeError(error, "COMPONENT_UNAVAILABLE")
+                }))
+            ]);
+            return { service: native, runtime };
         };
-    if (group === "status")
-        return { value: await readRuntimeStatus(context.paths.socket) };
-    if (group === "daemon")
-        return runDaemonCommand(context, action);
-    if (group === "doctor")
-        return runDoctor(context);
-    const request = daemonRequest(group, action, id);
-    if (group === "adapter")
-        request.params = { ...request.params, profile: context.profile };
-    return { value: await callDaemon(context.paths.socket, request) };
-}
-async function runDaemonCommand(context, action) {
-    if (!action)
-        return { value: helpText(["daemon"]) };
-    const selected = action;
-    if (selected === "run") {
-        await withSetupLock(context.paths, () => ensureLocalRuntime(context));
-        const exitCode = await context.runForegroundDaemon([
-            "--home",
-            context.home,
-            ...loggingArguments(context),
-            ...(context.flags.quiet === true ? [] : ["--console"]),
-            ...(context.flags.verbose === true ? ["--verbose"] : [])
-        ]);
-        return { streamed: true, exitCode: exitCode ?? 0 };
-    }
-    if (selected === "install")
-        return installDaemonService(context);
-    if (selected === "uninstall")
-        return uninstallDaemonService(context);
-    const spec = await daemonServiceSpec(context);
-    if (selected === "status") {
-        const service = await context.service.backend.inspect(spec);
-        const application = await readRuntimeStatus(context.paths.socket).catch(() => undefined);
-        return { value: { service, application: application ?? { ready: false } } };
-    }
-    if (!["start", "stop", "restart"].includes(selected)) {
-        throw new Error("daemon action must be install, uninstall, run, start, stop, restart, or status");
-    }
-    if (selected === "stop") {
-        daemonProgress(context, "Stopping background service...");
-        await context.service.backend.stop(spec);
-        daemonProgress(context, "Waiting for backend to stop...");
-        await waitForDaemonStopped(context, 15_000);
-        return {
-            value: { ok: true, action: "stop", service: await context.service.backend.inspect(spec) }
-        };
-    }
-    if (context.flags.waitOnline)
-        throw new Error("Worker cloud connections are no longer built in");
-    if (selected === "start") {
-        daemonProgress(context, "Checking background service...");
-        await installDaemonService(context, true);
-    }
-    await verifyServiceProgram(spec);
-    if (selected === "restart") {
-        daemonProgress(context, "Restarting background service...");
-        await context.service.backend.restart(spec);
-    }
-    else {
-        daemonProgress(context, "Starting backend in the background...");
-        await context.service.backend.start(spec);
-    }
-    daemonProgress(context, "Waiting for local backend readiness...");
-    const readiness = await waitForDaemonReady(context, DEFAULT_WAIT_MS);
-    return {
-        value: {
-            ok: true,
-            action: selected,
-            service: await context.service.backend.inspect(spec),
-            readiness
+        const snapshots = async (names) => Object.fromEntries(await Promise.all(names.map(async (name) => [
+            name,
+            await snapshot(name)
+        ])));
+        if (["extraset", "extraget"].includes(positional[0]) && flags.profile)
+            throw new Error("INVALID_ARGUMENTS");
+        if (positional[0] === "extraset" && positional.length === 2) {
+            publish(await setExtra(paths, positional[1], input));
+            return 0;
         }
-    };
-}
-async function installDaemonService(context, onlyIfMissing = false) {
-    return withSetupLock(context.paths, async () => {
-        if (onlyIfMissing) {
-            const spec = await daemonServiceSpec(context);
-            const service = await context.service.backend.inspect(spec);
-            if (service.state !== "not_installed") {
-                daemonProgress(context, "Background service is already installed.");
-                return {};
-            }
+        if (positional[0] === "extraget" && positional.length === 2) {
+            // 配置命令是数据接口，保持紧凑 JSON 与慢管道完整输出合同。
+            output(JSON.stringify(await getExtra(paths, positional[1])));
+            (dependencies.errorOutput ?? ((line) => process.stderr.write(`${line}\n`)))(`Config file: ${join(home, "extras", positional[1], "config.json")}`);
+            return 0;
         }
-        await ensureLocalRuntime(context);
-        const autostart = onlyIfMissing || context.flags.noAutostart !== true;
-        const spec = context.service.spec(context.paths, autostart, loggingArguments(context));
-        await verifyServiceProgram(spec);
-        const probe = await context.service.backend.probe();
-        if (!probe.supported) {
-            throw new Error(`${probe.manager} is unavailable: ${probe.detail ?? "unsupported user session"}`);
+        if (positional[0] === "playboard" && positional.length === 1) {
+            const { runPlayboard } = await import("./playboard.js");
+            return runPlayboard({
+                home,
+                profile,
+                manifest: flags.manifest,
+                input,
+                output: dependencies.output
+            });
         }
-        daemonProgress(context, `Installing background service (${probe.manager})...`);
-        await context.service.backend.install(spec);
-        daemonProgress(context, autostart ? "Enabling start at login..." : "Disabling start at login...");
-        if (autostart)
-            await context.service.backend.enable(spec);
-        else
-            await context.service.backend.disable(spec);
-        return {
-            value: {
-                ok: true,
-                action: "install",
-                service: await context.service.backend.inspect(spec)
+        if (positional[0] === "adapter" && positional[1] === "list" && positional.length === 2) {
+            const client = attachKernel({ endpoint });
+            try {
+                publish(await client.list());
             }
-        };
-    });
-}
-async function uninstallDaemonService(context) {
-    return withSetupLock(context.paths, async () => {
-        const spec = await daemonServiceSpec(context);
-        const before = await context.service.backend.inspect(spec);
-        const application = await tryDaemonStatus(context.paths.socket);
-        const managedProcessActive = ["running", "starting", "stopping"].includes(before.state);
-        daemonProgress(context, "Stopping and removing background service...");
-        await context.service.backend.uninstall(spec);
-        if (application && managedProcessActive) {
-            await waitForDaemonStopped(context, 15_000);
+            finally {
+                client.close();
+            }
+            return 0;
         }
-        return {
-            value: {
-                ok: true,
-                action: "uninstall",
-                service: await context.service.backend.inspect(spec),
-                data_preserved: true
+        if (positional[0] === "adapter" && positional[1] === "probe" && positional.length === 3) {
+            const client = attachKernel({ endpoint });
+            try {
+                const adapter = (await client.list()).find((value) => value.type === positional[2]);
+                if (!adapter)
+                    throw new Error("ADAPTER_NOT_FOUND");
+                publish(adapter);
             }
-        };
-    });
-}
-function daemonProgress(context, message) {
-    if (context.flags.json !== true)
-        context.output(message);
-}
-async function readRuntimeStatus(socketPath) {
-    const application = await callDaemon(socketPath, { method: "status" });
-    const extras = application.extras;
-    if (!extras || typeof extras !== "object" || Array.isArray(extras))
-        return application;
-    const entries = await Promise.all(Object.entries(extras).map(async ([name, value]) => {
-        if (!value || typeof value !== "object" || Array.isArray(value))
-            return [name, value];
-        const lifecycle = value;
-        if (lifecycle.phase !== "loaded")
-            return [name, lifecycle];
-        try {
-            const status = await callDaemon(socketPath, { method: "extra.status", params: { name } });
-            return [name, { ...lifecycle, status }];
+            finally {
+                client.close();
+            }
+            return 0;
         }
-        catch {
-            return [name, { ...lifecycle, status_error: "EXTRA_STATUS_FAILED" }];
+        if (positional[0] === "doctor" && positional.length === 1) {
+            const manager = await service.backend.probe();
+            const status = await snapshots(componentNames);
+            const checks = Object.entries(status).map(([component, value]) => ({ component, ...value }));
+            publish({ manager, checks }, `Manager: ${manager.manager} (${manager.supported ? "available" : "unavailable"})\n\n${Object.entries(status)
+                .map(([name, value]) => formatStatus(name, value))
+                .join("\n\n")}`);
+            return 0;
         }
-    }));
-    return { ...application, extras: Object.fromEntries(entries) };
-}
-// Call under the Home setup lock; existing configuration and identity stay intact.
-async function ensureLocalRuntime(context) {
-    const homeConfiguration = await readJsonFile(context.paths.rootConfig);
-    assertHomeConfiguration(homeConfiguration);
-    await ensureMachineIdentity(context.paths);
-    await prepareRuntimeDirectories(context.paths);
-    if (homeConfiguration === undefined) {
-        await reconcileHomeConfiguration(context.paths, context.profile, "stable");
+        if (positional[0] === "status" && positional.length === 1) {
+            const status = await snapshots(componentNames);
+            publish(status, Object.entries(status)
+                .map(([name, value]) => formatStatus(name, value))
+                .join("\n\n"));
+            return 0;
+        }
+        const component = positional[0], action = positional[1];
+        if (!isComponent(component) ||
+            positional.length !== 2 ||
+            !["uninstall", "install", "start", "restart", "stop", "run", "status"].includes(action))
+            throw new Error("INVALID_ARGUMENTS");
+        if (flags.autostart !== undefined && action !== "install")
+            throw new Error("INVALID_ARGUMENTS");
+        if (action === "status") {
+            const status = await snapshots([component]);
+            publish(status[component], formatStatus(component, status[component]));
+            return 0;
+        }
+        if (action === "run") {
+            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)),
+                    adapterConfigurations: readAdapterConfigurations(paths.profileRoot, config?.adapters),
+                    env: {
+                        ...(dependencies.env ?? process.env),
+                        OCTO_RUNTIME_HOME: home,
+                        OCTO_RUNTIME_LOGS_DIRECTORY: join(home, "logs")
+                    }
+                });
+            }
+            else {
+                const registration = extraRegistration(await readExtra(paths, component));
+                const module = registration.enabled === false
+                    ? { name: registration.name, default: () => () => { } }
+                    : await registration.load();
+                if (module.name !== registration.name)
+                    throw new Error("EXTRA_NAME_MISMATCH");
+                handle = createExtraService({
+                    logging: { directory: join(home, "logs") },
+                    module,
+                    config: registration.config,
+                    dependencies: {},
+                    enabled: registration.enabled,
+                    endpoint,
+                    controlEndpoint: componentEndpoint(home, component, dependencies.platform)
+                });
+            }
+            return runForegroundService(handle, () => publish({ component, state: "ready" }, `${component}: ready`), async (error) => {
+                try {
+                    await recordStartupFailure(join(home, "logs"), component, error);
+                }
+                finally {
+                    const failure = {
+                        ...describeError(error, "SERVICE_INITIALIZATION_FAILED"),
+                        ...context
+                    };
+                    if (json)
+                        publish({ error: failure });
+                    else
+                        (dependencies.errorOutput ?? ((line) => process.stderr.write(`${line}\n`)))(`${component}: ${failure.code}${failure.cause_code ? ` (${failure.cause_code})` : ""}\n${failure.message}\nLogs: ${context.logs}`);
+                }
+            });
+        }
+        const serviceArgs = [
+            ...(flags.profile ? ["--profile", profile] : []),
+            ...(flags.manifest ? ["--manifest", resolve(flags.manifest)] : [])
+        ];
+        let spec = service.spec(home, component, false, serviceArgs);
+        // 同组件所有部署修改及最终状态确认串行；不同组件仍可独立启动。
+        return await withSetupLock({ ...paths, setupLock: join(home, "run", `${component}.setup.lock`) }, async () => {
+            if (action === "install") {
+                spec = { ...spec, enabled: flags.autostart !== "false" };
+                await mkdir(home, { recursive: true, mode: 0o700 });
+                await service.backend.install(spec);
+            }
+            else {
+                if (action === "start") {
+                    const before = await service.backend.inspect(spec);
+                    if (before.state === "not_installed") {
+                        const progress = dependencies.errorOutput ?? ((line) => process.stderr.write(`${line}\n`));
+                        progress(`${component}: service not installed; installing with autostart enabled...`);
+                        spec = { ...spec, enabled: true };
+                        await mkdir(home, { recursive: true, mode: 0o700 });
+                        await service.backend.install(spec);
+                        progress(`${component}: installation complete; starting service...`);
+                    }
+                }
+                else if (action === "restart") {
+                    const before = await service.backend.inspect(spec);
+                    if (before.state === "not_installed")
+                        throw new Error("SERVICE_NOT_INSTALLED");
+                }
+                if (action === "uninstall")
+                    await service.backend.uninstall(spec);
+                if (action === "stop")
+                    await service.backend.stop(spec);
+                const startedAt = Date.now();
+                if (action === "start")
+                    await service.backend.start(spec);
+                if (action === "restart")
+                    await service.backend.restart(spec);
+                if (action === "start" || action === "restart") {
+                    const end = Date.now() + 30_000;
+                    while (true) {
+                        try {
+                            await componentStatus(home, component, dependencies.platform, true);
+                            break;
+                        }
+                        catch (error) {
+                            const failure = await readStartupFailure(join(home, "logs"), component, startedAt);
+                            if (failure)
+                                throw failure;
+                            // LastTaskResult/ExecMainStatus 可能仍属于旧进程；无本次失败证据就保留就绪预算。
+                            if (Date.now() >= end)
+                                throw new Error("COMPONENT_UNAVAILABLE", { cause: error });
+                            await (dependencies.sleep ?? sleep)(100);
+                        }
+                    }
+                }
+            }
+            if (action === "start" || action === "restart") {
+                const status = await snapshot(component);
+                publish({ component, action, ...status }, `${component}: ${action} succeeded\n${formatStatus(component, status)}\nLogs: ${join(home, "logs")}`);
+                return 0;
+            }
+            // 后续操作不把默认的 false 当作修改已安装服务自启的意图。
+            const native = await service.backend.inspect(spec);
+            publish({ component, action, service: native }, `${component}: ${action} succeeded\nService: ${native.state}  Autostart: ${native.enabled ? "on" : "off"}\n${action === "install" ? `Next: octo-runtime ${component} start --home ${JSON.stringify(home)}\n` : ""}Logs: ${join(home, "logs")}`);
+            return 0;
+        });
     }
-}
-async function runDoctor(context) {
-    const checks = [];
-    const nodeMajor = Number(process.versions.node.split(".")[0]);
-    checks.push(check("node.version", nodeMajor >= 24, `Node.js ${process.versions.node}`, "Install Node.js 24 or newer"));
-    const homeConfig = await inspectJson(context.paths.rootConfig);
-    checks.push(check("home.config", homeConfig.ok, homeConfig.detail, "Run octo-runtime daemon install or daemon run"));
-    const spec = await daemonServiceSpec(context);
-    const program = await pathCheck(spec.command, spec.args?.[0]);
-    checks.push(check("service.program", program.ok, program.detail, "Rerun the installer to repair absolute program paths"));
-    const probe = await context.service.backend.probe();
-    checks.push(check("service.manager", probe.supported, probe.detail ?? probe.manager, "Use a supported current-user service session"));
-    if (probe.supported) {
-        const service = await context.service.backend.inspect(spec);
-        checks.push(check("service.definition", service.state !== "not_installed" && service.drift.length === 0, `${service.state}; drift=${service.drift.join(",") || "none"}`, "Run octo-runtime daemon install to reconcile the service definition"));
+    catch (error) {
+        if (runningComponent && context.logs)
+            await recordStartupFailure(context.logs, runningComponent, error);
+        const failure = { ...describeError(error), ...context };
+        const code = failure.code;
+        if (json)
+            output(JSON.stringify({ error: failure }, null, 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)
+            ? 3
+            : /INVALID|REQUIRED/.test(code)
+                ? 2
+                : /INCOMPLETE/.test(code)
+                    ? 5
+                    : /UNAVAILABLE|SERVICE_PROCESS_EXITED/.test(code)
+                        ? 4
+                        : 1;
     }
-    const application = await tryDaemonStatus(context.paths.socket);
-    checks.push(check("daemon.ipc", Boolean(application), application ? "ready" : "not reachable", "Run octo-runtime daemon start"));
-    const ok = checks.every((item) => item.ok === true);
-    return {
-        value: { ok, profile: context.profile, home: context.home, checks },
-        exitCode: ok ? 0 : 1
-    };
 }
-function daemonRequest(group, action, id) {
-    if (group === "status")
-        return { method: "status" };
-    if (group === "adapter" && action === "list")
-        return { method: "adapter.list" };
-    if (group === "adapter" && action === "probe") {
-        return { method: "adapter.probe", params: { adapterType: required(id, "adapter-type") } };
+async function componentStatus(home, component, platform, requireReady = false) {
+    const endpoint = componentEndpoint(home, component, platform);
+    if (component === "executor-kernel") {
+        const client = attachKernel({ endpoint });
+        try {
+            const status = await client.status();
+            if (requireReady && !status.execution_ready)
+                throw new Error("COMPONENT_UNAVAILABLE");
+            return status;
+        }
+        finally {
+            client.close();
+        }
     }
-    throw new Error("unknown command; run octo-runtime help");
-}
-export async function callDaemon(socketPath, request) {
-    const socket = await connectDaemon(socketPath);
-    socket.write(`${JSON.stringify({ id: randomUUID(), ...request })}\n`);
-    const response = await new Promise((resolveResponse, reject) => {
-        let buffered = "";
-        socket.setEncoding("utf8");
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(endpoint);
+        const id = randomUUID();
+        let bytes = "";
+        socket.setTimeout(1000, () => {
+            socket.destroy();
+            reject(new Error("COMPONENT_UNAVAILABLE"));
+        });
+        socket.once("error", reject);
+        socket.once("connect", () => socket.write(`${JSON.stringify({ jsonrpc: "2.0", id, method: "status" })}\n`));
         socket.on("data", (chunk) => {
-            buffered += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-            const newline = buffered.indexOf("\n");
-            if (newline < 0)
+            bytes += chunk.toString("utf8");
+            if (bytes.length > 65536) {
+                socket.destroy();
+                reject(new Error("INVALID_RESPONSE"));
                 return;
-            socket.removeAllListeners("data");
-            try {
-                resolveResponse(JSON.parse(buffered.slice(0, newline)));
             }
-            catch (error) {
-                reject(error instanceof Error ? error : new Error("invalid daemon response", { cause: error }));
+            if (bytes.includes("\n")) {
+                try {
+                    const response = JSON.parse(bytes.slice(0, bytes.indexOf("\n")));
+                    if (response.jsonrpc !== "2.0" ||
+                        response.id !== id ||
+                        response.result?.name !== component ||
+                        typeof response.result.pid !== "number" ||
+                        !response.result.status ||
+                        typeof response.result.status !== "object")
+                        throw new Error("INVALID_RESPONSE");
+                    resolve(response.result);
+                }
+                catch {
+                    reject(new Error("INVALID_RESPONSE"));
+                }
+                socket.destroy();
             }
         });
-        socket.once("error", reject);
         socket.once("end", () => {
-            if (!buffered.includes("\n"))
-                reject(new Error("daemon closed before returning a response"));
+            if (!bytes.includes("\n"))
+                reject(new Error("COMPONENT_UNAVAILABLE"));
         });
     });
-    socket.destroy();
-    if (response.error)
-        throw new Error(response.error.message ?? "daemon request failed");
-    return response.result;
-}
-async function waitForDaemonReady(context, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    let lastError;
-    while (Date.now() < deadline) {
-        try {
-            const status = await callDaemon(context.paths.socket, {
-                method: "status"
-            });
-            if (status.ready === true)
-                return status;
-        }
-        catch (error) {
-            lastError = error;
-        }
-        await context.sleep(100);
-    }
-    throw new Error(`daemon did not become ready within ${timeoutMs}ms`, { cause: lastError });
-}
-async function waitForDaemonStopped(context, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (!(await tryDaemonStatus(context.paths.socket)))
-            return;
-        await context.sleep(100);
-    }
-    throw new Error(`daemon IPC remained reachable after ${timeoutMs}ms`);
-}
-async function tryDaemonStatus(socketPath) {
-    try {
-        return await callDaemon(socketPath, { method: "status" });
-    }
-    catch {
-        return undefined;
-    }
 }
-async function connectDaemon(socketPath) {
-    const socket = net.createConnection(socketPath);
-    try {
-        await new Promise((resolveConnection, reject) => {
-            socket.once("connect", resolveConnection);
-            socket.once("error", reject);
-        });
-    }
-    catch (error) {
-        socket.destroy();
-        const code = error.code;
-        if (code && ["ENOENT", "ECONNREFUSED", "EINVAL"].includes(code)) {
-            throw new Error(`cannot connect to Octo Runtime daemon at ${socketPath}; start it with: octo-runtime daemon start`, {
-                cause: error
-            });
-        }
-        throw error;
-    }
-    return socket;
-}
-async function inspectJson(path) {
-    try {
-        const value = await readJsonFile(path);
-        return value ? { ok: true, detail: path, value } : { ok: false, detail: `missing: ${path}` };
-    }
-    catch (error) {
-        return { ok: false, detail: error instanceof Error ? error.message : String(error) };
-    }
-}
-async function pathCheck(...paths) {
-    try {
-        const selected = paths.filter((value) => Boolean(value));
-        await Promise.all(selected.map((path) => access(path)));
-        return { ok: true, detail: selected.join(", ") };
-    }
-    catch (error) {
-        return { ok: false, detail: error instanceof Error ? error.message : String(error) };
-    }
-}
-function check(id, ok, detail, remediation) {
-    return { id, ok, detail, ...(ok ? {} : { remediation }) };
-}
-function parseArguments(args) {
-    const flags = {};
-    const positionals = [];
-    for (let index = 0; index < args.length; index++) {
-        const argument = args[index] === "-h" ? "--help" : args[index] === "-v" ? "--version" : args[index];
-        if (argument.startsWith("-") && !argument.startsWith("--"))
-            throw new Error(`unknown option ${argument}`);
-        if (!argument.startsWith("--")) {
-            positionals.push(argument);
-            continue;
-        }
-        const separator = argument.indexOf("=");
-        const rawKey = argument.slice(2, separator < 0 ? undefined : separator);
-        const normalizedKey = rawKey.replace(/[-_]([a-z])/g, (_match, character) => character.toUpperCase());
-        const key = normalizedKey === "agentIdentit" ? "agentIdentity" : normalizedKey;
-        if (!["home", "profile", "manifest", ...BOOLEAN_FLAGS].includes(key))
-            throw new Error(`unknown option --${rawKey}`);
-        if (["force", "timeoutMs", "waitDrained"].includes(key))
-            throw new Error(`unknown option --${rawKey}`);
-        if ((key === "agentIdentity" || key === "agentName") && Object.hasOwn(flags, key))
-            throw new Error(`duplicate --${rawKey}`);
-        if (BOOLEAN_FLAGS.has(key)) {
-            if (separator >= 0)
-                throw new Error(`--${rawKey} does not accept a value`);
-            flags[key] = true;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function parse(args) {
+    const flags = {}, positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] === "-h" ? "--help" : args[i] === "-v" ? "--version" : args[i];
+        if (!arg.startsWith("-")) {
+            positional.push(arg);
             continue;
         }
-        const next = args[index + 1];
-        flags[key] =
-            separator >= 0
-                ? argument.slice(separator + 1)
-                : next && !next.startsWith("-")
-                    ? args[++index]
-                    : true;
-        if (typeof flags[key] !== "string" || !flags[key])
-            throw new Error(`--${rawKey} requires a nonempty value`);
-        if ((key === "agentIdentity" || key === "agentName") &&
-            (typeof flags[key] !== "string" || !flags[key]))
-            throw new Error(`--${rawKey} requires a nonempty value`);
+        const match = /^--([a-z-]+)(?:=(.*))?$/.exec(arg);
+        if (!match ||
+            !["home", "profile", "manifest", "json", "help", "version", "autostart"].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]);
+        if (!flags[key] ||
+            flags[key].startsWith("--") ||
+            (key === "autostart" && !["true", "false"].includes(flags[key])))
+            throw new Error("INVALID_ARGUMENTS");
     }
-    return { flags, positionals };
-}
-function required(value, name) {
-    if (typeof value !== "string" || value.length === 0)
-        throw new Error(`missing --${name}`);
-    return value;
-}
-function requiredFlag(value, name) {
-    return required(value, name);
-}
-function optionalString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-async function daemonServiceSpec(context, enabled = true) {
-    const configuration = await readJsonFile(context.paths.rootConfig);
-    assertHomeConfiguration(configuration);
-    return context.service.spec(context.paths, enabled, loggingArguments(context));
-}
-function loggingArguments(context) {
-    return context.flags.logsDir === undefined
-        ? []
-        : ["--logs-dir", resolve(requiredFlag(context.flags.logsDir, "logs-dir"))];
-}
-export function runtimeFingerprint() {
-    return createHash("sha256")
-        .update([hostname(), osPlatform(), release(), arch()].join("\0"))
-        .digest("hex");
+    return { flags, positional };
 }