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

package/apps/cli/dist/main.js

@@ -0,0 +1,478 @@
+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 { 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"
+]);
+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 { 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;
+                }
+            })
+    };
+    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")}`
+        };
+    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
+        }
+    };
+}
+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 {};
+            }
+        }
+        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"}`);
+        }
+        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)
+            }
+        };
+    });
+}
+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);
+        }
+        return {
+            value: {
+                ok: true,
+                action: "uninstall",
+                service: await context.service.backend.inspect(spec),
+                data_preserved: true
+            }
+        };
+    });
+}
+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 }];
+        }
+        catch {
+            return [name, { ...lifecycle, status_error: "EXTRA_STATUS_FAILED" }];
+        }
+    }));
+    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");
+    }
+}
+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"));
+    }
+    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") } };
+    }
+    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");
+        socket.on("data", (chunk) => {
+            buffered += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            const newline = buffered.indexOf("\n");
+            if (newline < 0)
+                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 }));
+            }
+        });
+        socket.once("error", reject);
+        socket.once("end", () => {
+            if (!buffered.includes("\n"))
+                reject(new Error("daemon closed before returning a response"));
+        });
+    });
+    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;
+            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`);
+    }
+    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");
+}

package/apps/cli/dist/playboard.d.ts

@@ -0,0 +1,9 @@
+export interface PlayboardOptions {
+    input: NodeJS.ReadableStream;
+    output?: (line: string) => void | Promise<void>;
+    env?: NodeJS.ProcessEnv;
+    manifest?: string;
+    home?: string;
+    profile?: string;
+}
+export declare function runPlayboard(options: PlayboardOptions): Promise<number>;

package/apps/cli/dist/playboard.js

@@ -0,0 +1,118 @@
+import { defaultRuntimeHome, runtimePaths } from "./state.js";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { startTemporaryDaemon } from "./temporary-daemon.js";
+import { invokeDaemonRun } from "@mininglamp-oss/octo-runtime-daemon/runtime/run-stream";
+import { identifyInvokeInput, createInputInvoke, isHostTerminal, isTerminal } from "@mininglamp-oss/octo-runtime-protocol";
+import { INVOKE_REQUEST_MAX_BYTES } from "@mininglamp-oss/octo-runtime-protocol";
+export async function runPlayboard(options) {
+    if (options.input.isTTY) {
+        throw new Error("playboard requires a JSON request on stdin; use <<< '...JSON...' or < request.json");
+    }
+    let body = Buffer.alloc(0);
+    let size = 0;
+    for await (const chunk of options.input) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        const nextSize = size + bytes.length;
+        if (nextSize > INVOKE_REQUEST_MAX_BYTES)
+            throw new TypeError("INVOKE_REQUEST_TOO_LARGE");
+        if (nextSize > body.length) {
+            const expanded = Buffer.allocUnsafe(Math.min(INVOKE_REQUEST_MAX_BYTES, Math.max(65536, body.length * 2, nextSize)));
+            body.copy(expanded, 0, 0, size);
+            body = expanded;
+        }
+        bytes.copy(body, size);
+        size = nextSize;
+    }
+    let value;
+    try {
+        value = JSON.parse(body.toString("utf8", 0, size));
+        body = Buffer.alloc(0);
+    }
+    catch {
+        throw new TypeError("playboard stdin must contain one complete JSON object");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("playboard stdin must contain one JSON input object");
+    const input = identifyInvokeInput(value);
+    const profile = options.profile ?? "default";
+    const home = options.home ?? defaultRuntimeHome(options.env);
+    runtimePaths(home, profile); // Validate the selected profile before starting resources.
+    if (input.runMetadata?.profile !== undefined && input.runMetadata.profile !== profile)
+        throw new Error("RUNTIME_CONFIGURATION_NOT_FOUND: request profile differs from --profile");
+    input.runMetadata = { ...input.runMetadata, profile };
+    const output = options.output ?? writeLine;
+    const controller = new AbortController();
+    let interrupted = 0;
+    const onInterrupt = () => {
+        interrupted = 130;
+        controller.abort();
+    };
+    const onTerminate = () => {
+        interrupted = 143;
+        controller.abort();
+    };
+    const onOutputError = (error) => {
+        controller.abort(error);
+    };
+    if (!options.output)
+        process.stdout.on("error", onOutputError);
+    process.once("SIGINT", onInterrupt);
+    process.once("SIGTERM", onTerminate);
+    let daemon;
+    try {
+        daemon = await startTemporaryDaemon({
+            home,
+            profile,
+            manifest: options.manifest
+                ? resolve(options.manifest)
+                : fileURLToPath(new URL("./default_adapters.json", import.meta.url)),
+            env: options.env ?? process.env,
+            signal: controller.signal
+        });
+        const socket = daemon.socket;
+        const invoke = createInputInvoke((input, environment) => invokeDaemonRun(socket, input, environment));
+        let exitCode = 1;
+        for await (const frame of invoke(input, { signal: controller.signal })) {
+            await output(JSON.stringify(frame));
+            if (("kind" in frame &&
+                frame.kind === "control" &&
+                frame.control.type === "interaction" &&
+                frame.control.status === "pending") ||
+                (!("kind" in frame) && frame.type === "interaction.requested")) {
+                throw new Error("PLAYBOARD_INTERACTION_REQUIRED: one-shot stdin cannot answer provider interactions");
+            }
+            if ("kind" in frame &&
+                isHostTerminal(frame) &&
+                frame.kind === "control" &&
+                frame.control.type === "state") {
+                exitCode =
+                    frame.control.state === "completed" ? 0 : frame.control.state === "cancelled" ? 130 : 1;
+            }
+            if (!("kind" in frame) && isTerminal(frame))
+                exitCode = frame.type === "run.completed" ? 0 : frame.type === "run.cancelled" ? 130 : 1;
+        }
+        return interrupted || exitCode;
+    }
+    catch (error) {
+        if (interrupted)
+            return interrupted;
+        throw error;
+    }
+    finally {
+        try {
+            await daemon?.close();
+        }
+        finally {
+            if (!options.output)
+                process.stdout.removeListener("error", onOutputError);
+            process.removeListener("SIGINT", onInterrupt);
+            process.removeListener("SIGTERM", onTerminate);
+        }
+    }
+}
+function writeLine(line) {
+    return new Promise((resolve, reject) => {
+        process.stdout.write(`${line}\n`, (error) => (error ? reject(error) : resolve()));
+    });
+}

package/apps/cli/dist/service-control.d.ts

@@ -0,0 +1,16 @@
+import { type ServiceBackend, type ServiceSpec } from "@mininglamp-oss/octo-runtime-cross-service";
+import type { RuntimePaths } from "./state.js";
+export declare const RUNTIME_SERVICE_ID = "cn.mininglamp.octo-runtime.daemon";
+export interface ServiceControlOptions {
+    backend?: ServiceBackend;
+    daemonEntrypoint?: string;
+    nodeExecutable?: string;
+    systemHome?: string;
+    platform?: NodeJS.Platform;
+    environment?: NodeJS.ProcessEnv;
+}
+export declare function resolveServiceControl(options?: ServiceControlOptions): {
+    backend: ServiceBackend;
+    spec(paths: RuntimePaths, enabled?: boolean, daemonArgs?: string[]): ServiceSpec;
+};
+export declare function verifyServiceProgram(spec: ServiceSpec): Promise<void>;

package/apps/cli/dist/service-control.js

@@ -0,0 +1,49 @@
+import { access, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServiceBackend } from "@mininglamp-oss/octo-runtime-cross-service";
+export const RUNTIME_SERVICE_ID = "cn.mininglamp.octo-runtime.daemon";
+export function resolveServiceControl(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const environment = options.environment ?? process.env;
+    const daemonEntrypoint = resolve(options.daemonEntrypoint ??
+        fileURLToPath(new URL("../../daemon/dist/launcher.js", import.meta.url)));
+    const nodeExecutable = resolve(options.nodeExecutable ?? process.execPath);
+    const backend = options.backend ??
+        createServiceBackend({
+            platform,
+            homeDirectory: options.systemHome ?? homedir()
+        });
+    return {
+        backend,
+        spec(paths, enabled = true, daemonArgs = []) {
+            return {
+                id: RUNTIME_SERVICE_ID,
+                description: "Octo Runtime daemon",
+                command: nodeExecutable,
+                args: [daemonEntrypoint, "--home", paths.home, ...daemonArgs],
+                workingDirectory: paths.home,
+                environment: {
+                    ...(environment.PATH || environment.Path
+                        ? { PATH: environment.PATH ?? environment.Path ?? "" }
+                        : {})
+                },
+                enabled,
+                restart: { policy: "on-failure", delaySeconds: 5, maxBurst: 5 },
+                timeoutStopSeconds: 45,
+                names: {
+                    launchdLabel: RUNTIME_SERVICE_ID,
+                    systemdUnit: `${RUNTIME_SERVICE_ID}.service`,
+                    windowsTaskName: "\\OctoRuntime.daemon"
+                }
+            };
+        }
+    };
+}
+export async function verifyServiceProgram(spec) {
+    await Promise.all([access(spec.command), access(spec.args?.[0] ?? "")]);
+    await mkdir(spec.workingDirectory, { recursive: true, mode: 0o700 });
+    if (spec.stdoutPath)
+        await mkdir(dirname(spec.stdoutPath), { recursive: true, mode: 0o700 });
+}