@todu/cli 0.1.1 → 0.2.1

package/dist/commands/daemon.js

@@ -0,0 +1,675 @@
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveRemoteSyncConfig } from "@todu/core";
+import { getConfigPath, loadConfig, resolveDataDir } from "../config.js";
+import { formatDaemonCommandError, resolveDaemonSocketPath, } from "../daemon-command-client.js";
+import { resolveDaemonPluginConfig, TODUAI_DAEMON_PLUGIN_CONFIG_ENV, } from "../daemon-plugin-config.js";
+import { resolveDaemonPluginPaths, TODUAI_DAEMON_PLUGIN_PATHS_ENV, } from "../daemon-plugin-paths.js";
+import { resolveDaemonAssignedWorkers, TODUAI_DAEMON_ASSIGNED_WORKERS_ENV, } from "../daemon-worker-assignment.js";
+import { formatJSON } from "../format.js";
+const DIRECT_PID_FILENAME = "daemon.pid";
+const SYSTEMD_SERVICE_NAME = "toduai-daemon";
+const SYSTEMD_SERVICE_PATH = ".config/systemd/user/toduai-daemon.service";
+const LAUNCHD_LABEL = "com.todu.daemon";
+const LAUNCHD_PLIST_PATH = "Library/LaunchAgents/com.todu.daemon.plist";
+const LIFECYCLE_MODE_ENV = "TODUAI_DAEMON_LIFECYCLE_MODE";
+const STARTUP_TIMEOUT_MS = 5_000;
+const STOP_TIMEOUT_MS = 5_000;
+export function registerDaemonCommands(program, invokeDaemon) {
+    const daemon = program.command("daemon").description("Manage local daemon lifecycle");
+    daemon
+        .command("run")
+        .description("Run local daemon in foreground mode")
+        .action(async () => {
+        const context = resolveDaemonCommandContext(program);
+        if (!fs.existsSync(context.daemonEntrypoint)) {
+            console.error(`Error: daemon entrypoint not found at ${context.daemonEntrypoint}`);
+            process.exitCode = 1;
+            return;
+        }
+        const child = spawn(process.execPath, [context.daemonEntrypoint], {
+            cwd: process.cwd(),
+            stdio: "inherit",
+            env: createDaemonChildEnv(context),
+        });
+        const forwardSigInt = () => {
+            child.kill("SIGINT");
+        };
+        const forwardSigTerm = () => {
+            child.kill("SIGTERM");
+        };
+        process.on("SIGINT", forwardSigInt);
+        process.on("SIGTERM", forwardSigTerm);
+        try {
+            const result = await new Promise((resolve, reject) => {
+                child.once("error", reject);
+                child.once("exit", (code, signal) => {
+                    resolve({ code, signal });
+                });
+            });
+            if (result.signal) {
+                process.exitCode = result.signal === "SIGINT" || result.signal === "SIGTERM" ? 0 : 1;
+                return;
+            }
+            process.exitCode = result.code ?? 1;
+        }
+        finally {
+            process.off("SIGINT", forwardSigInt);
+            process.off("SIGTERM", forwardSigTerm);
+        }
+    });
+    daemon
+        .command("status")
+        .description("Show daemon availability and health")
+        .action(async () => {
+        const result = await invokeDaemon("daemon.status", {});
+        const format = program.opts().format;
+        if (!result.ok) {
+            if (result.error.code === "DAEMON_UNAVAILABLE") {
+                const unavailable = {
+                    running: false,
+                    reason: result.error.message,
+                };
+                if (format === "json") {
+                    console.log(formatJSON(unavailable));
+                }
+                else {
+                    console.log("Daemon: not running");
+                    console.log(`Reason: ${result.error.message}`);
+                }
+                return;
+            }
+            console.error(formatDaemonCommandError(result.error));
+            process.exitCode = 1;
+            return;
+        }
+        const running = result.value.state === "running" && result.value.healthy;
+        const output = {
+            running,
+            status: result.value,
+        };
+        if (format === "json") {
+            console.log(formatJSON(output));
+            return;
+        }
+        console.log(`Daemon: ${running ? "running" : "not running"}`);
+        console.log(`State:  ${result.value.state}`);
+        console.log(`Role:   ${result.value.role}`);
+        if (result.value.transport?.path) {
+            console.log(`Socket: ${result.value.transport.path}`);
+        }
+        console.log(`Healthy: ${result.value.healthy ? "yes" : "no"}`);
+        if (result.value.catalog.id) {
+            console.log(`Catalog: ${result.value.catalog.id}`);
+        }
+    });
+    daemon
+        .command("start")
+        .description("Start daemon via configured service manager or direct fallback")
+        .action(async () => {
+        await handleLifecycleAction("start", program, invokeDaemon);
+    });
+    daemon
+        .command("stop")
+        .description("Stop daemon via configured service manager or direct fallback")
+        .action(async () => {
+        await handleLifecycleAction("stop", program, invokeDaemon);
+    });
+    daemon
+        .command("restart")
+        .description("Restart daemon via configured service manager or direct fallback")
+        .action(async () => {
+        await handleLifecycleAction("restart", program, invokeDaemon);
+    });
+}
+async function handleLifecycleAction(action, program, invokeDaemon) {
+    const context = resolveDaemonCommandContext(program);
+    const format = program.opts().format;
+    let mode;
+    try {
+        mode = resolveLifecycleMode();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const invalidModeResult = {
+            action,
+            ok: false,
+            mode: "direct",
+            delegated: false,
+            message,
+        };
+        renderLifecycleResult(invalidModeResult, format);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await executeLifecycleAction(action, mode, context, invokeDaemon);
+    renderLifecycleResult(result, format);
+    if (!result.ok) {
+        process.exitCode = 1;
+    }
+}
+function renderLifecycleResult(result, format) {
+    if (format === "json") {
+        console.log(formatJSON(result));
+        return;
+    }
+    if (!result.ok) {
+        console.error(`Error: ${result.message}`);
+        console.error(`Mode: ${result.mode}`);
+        if (result.details) {
+            console.error(`Details: ${result.details}`);
+        }
+        return;
+    }
+    console.log(`Daemon ${result.action}: ${result.message}`);
+    console.log(`Mode: ${result.mode}${result.delegated ? " (delegated)" : ""}`);
+    if (typeof result.running === "boolean") {
+        console.log(`Running: ${result.running ? "yes" : "no"}`);
+    }
+    if (typeof result.pid === "number") {
+        console.log(`PID: ${result.pid}`);
+    }
+    if (result.details) {
+        console.log(`Details: ${result.details}`);
+    }
+}
+async function executeLifecycleAction(action, mode, context, invokeDaemon) {
+    if (mode === "systemd-user") {
+        return executeSystemdLifecycleAction(action);
+    }
+    if (mode === "launchd") {
+        return executeLaunchdLifecycleAction(action);
+    }
+    if (action === "start") {
+        return executeDirectStart(action, context, invokeDaemon);
+    }
+    if (action === "stop") {
+        return executeDirectStop(action, context, invokeDaemon, {
+            allowUnmanagedRunning: false,
+        });
+    }
+    const stop = await executeDirectStop("restart", context, invokeDaemon, {
+        allowUnmanagedRunning: false,
+    });
+    if (!stop.ok) {
+        return stop;
+    }
+    return executeDirectStart("restart", context, invokeDaemon);
+}
+function executeSystemdLifecycleAction(action) {
+    const servicePath = path.join(os.homedir(), SYSTEMD_SERVICE_PATH);
+    if (!fs.existsSync(servicePath)) {
+        return {
+            action,
+            ok: false,
+            mode: "systemd-user",
+            delegated: true,
+            message: `systemd user service is not configured at ${servicePath}`,
+            details: "Create the service using docs/daemon-service-operations.md or use direct mode.",
+        };
+    }
+    const command = runCommand("systemctl", ["--user", action, SYSTEMD_SERVICE_NAME]);
+    if (!command.ok) {
+        return {
+            action,
+            ok: false,
+            mode: "systemd-user",
+            delegated: true,
+            message: `systemctl --user ${action} ${SYSTEMD_SERVICE_NAME} failed`,
+            details: command.message,
+        };
+    }
+    return {
+        action,
+        ok: true,
+        mode: "systemd-user",
+        delegated: true,
+        message: `${action} delegated to systemd user service`,
+        details: servicePath,
+    };
+}
+function executeLaunchdLifecycleAction(action) {
+    const plistPath = path.join(os.homedir(), LAUNCHD_PLIST_PATH);
+    const uid = process.getuid?.();
+    if (!Number.isInteger(uid)) {
+        return {
+            action,
+            ok: false,
+            mode: "launchd",
+            delegated: true,
+            message: "launchd delegation requires a macOS user session with a numeric uid",
+        };
+    }
+    if (!fs.existsSync(plistPath)) {
+        return {
+            action,
+            ok: false,
+            mode: "launchd",
+            delegated: true,
+            message: `launchd plist is not configured at ${plistPath}`,
+            details: "Create the LaunchAgent using docs/daemon-service-operations.md or use direct mode.",
+        };
+    }
+    const domainTarget = `gui/${uid}`;
+    const serviceTarget = `${domainTarget}/${LAUNCHD_LABEL}`;
+    if (action === "stop") {
+        const stop = runCommand("launchctl", ["bootout", domainTarget, plistPath]);
+        if (!stop.ok && !isLaunchdAlreadyStopped(stop.message)) {
+            return {
+                action,
+                ok: false,
+                mode: "launchd",
+                delegated: true,
+                message: `launchctl bootout failed for ${serviceTarget}`,
+                details: stop.message,
+            };
+        }
+        return {
+            action,
+            ok: true,
+            mode: "launchd",
+            delegated: true,
+            message: "stop delegated to launchd",
+            details: plistPath,
+        };
+    }
+    if (action === "restart") {
+        const start = runLaunchdStart(serviceTarget, domainTarget, plistPath);
+        if (!start.ok) {
+            return {
+                action,
+                ok: false,
+                mode: "launchd",
+                delegated: true,
+                message: `launchctl restart failed for ${serviceTarget}`,
+                details: start.message,
+            };
+        }
+        return {
+            action,
+            ok: true,
+            mode: "launchd",
+            delegated: true,
+            message: "restart delegated to launchd",
+            details: plistPath,
+        };
+    }
+    const start = runLaunchdStart(serviceTarget, domainTarget, plistPath);
+    if (!start.ok) {
+        return {
+            action,
+            ok: false,
+            mode: "launchd",
+            delegated: true,
+            message: `launchctl start failed for ${serviceTarget}`,
+            details: start.message,
+        };
+    }
+    return {
+        action,
+        ok: true,
+        mode: "launchd",
+        delegated: true,
+        message: "start delegated to launchd",
+        details: plistPath,
+    };
+}
+function runLaunchdStart(serviceTarget, domainTarget, plistPath) {
+    const print = runCommand("launchctl", ["print", serviceTarget]);
+    if (!print.ok) {
+        const bootstrap = runCommand("launchctl", ["bootstrap", domainTarget, plistPath]);
+        if (!bootstrap.ok && !isLaunchdAlreadyLoaded(bootstrap.message)) {
+            return bootstrap;
+        }
+    }
+    return runCommand("launchctl", ["kickstart", "-k", serviceTarget]);
+}
+function isLaunchdAlreadyLoaded(message) {
+    return message.includes("already loaded") || message.includes("service already bootstrapped");
+}
+function isLaunchdAlreadyStopped(message) {
+    return message.includes("No such process") || message.includes("Could not find service");
+}
+async function executeDirectStart(action, context, invokeDaemon) {
+    const pidInfo = readDaemonPid(context.daemonPidPath);
+    if (pidInfo.pid && isProcessAlive(pidInfo.pid)) {
+        const running = await waitForDaemonRunning(invokeDaemon, STARTUP_TIMEOUT_MS);
+        if (!running.running) {
+            return {
+                action,
+                ok: false,
+                mode: "direct",
+                delegated: false,
+                message: "managed daemon process exists but daemon socket is not responding",
+                pid: pidInfo.pid,
+            };
+        }
+        return {
+            action,
+            ok: true,
+            mode: "direct",
+            delegated: false,
+            message: "daemon already running",
+            running: true,
+            pid: pidInfo.pid,
+        };
+    }
+    if (pidInfo.pid && !isProcessAlive(pidInfo.pid)) {
+        safeUnlink(context.daemonPidPath);
+    }
+    const unmanagedRunning = await waitForDaemonRunning(invokeDaemon, 400);
+    if (unmanagedRunning.running) {
+        return {
+            action,
+            ok: false,
+            mode: "direct",
+            delegated: false,
+            message: "daemon is running but not managed by direct lifecycle wrapper",
+            details: "Use daemon stop via the service manager that started it.",
+        };
+    }
+    if (!fs.existsSync(context.daemonEntrypoint)) {
+        return {
+            action,
+            ok: false,
+            mode: "direct",
+            delegated: false,
+            message: `daemon entrypoint not found at ${context.daemonEntrypoint}`,
+        };
+    }
+    fs.mkdirSync(context.storagePath, { recursive: true });
+    const daemonProcess = spawn(process.execPath, [context.daemonEntrypoint], {
+        cwd: process.cwd(),
+        detached: true,
+        stdio: "ignore",
+        env: createDaemonChildEnv(context),
+    });
+    const daemonPid = daemonProcess.pid;
+    if (!daemonPid) {
+        return {
+            action,
+            ok: false,
+            mode: "direct",
+            delegated: false,
+            message: "failed to spawn daemon process",
+        };
+    }
+    daemonProcess.unref();
+    try {
+        fs.writeFileSync(context.daemonPidPath, `${daemonPid}\n`, "utf8");
+    }
+    catch (error) {
+        terminateProcess(daemonPid, "SIGTERM");
+        return {
+            action,
+            ok: false,
+            mode: "direct",
+            delegated: false,
+            message: "failed to write daemon pid file",
+            details: error instanceof Error ? error.message : String(error),
+        };
+    }
+    const running = await waitForDaemonRunning(invokeDaemon, STARTUP_TIMEOUT_MS);
+    if (!running.running) {
+        terminateProcess(daemonPid, "SIGTERM");
+        safeUnlink(context.daemonPidPath);
+        return {
+            action,
+            ok: false,
+            mode: "direct",
+            delegated: false,
+            message: "daemon failed to become healthy after start",
+            pid: daemonPid,
+            details: running.reason,
+        };
+    }
+    return {
+        action,
+        ok: true,
+        mode: "direct",
+        delegated: false,
+        message: "started managed daemon process",
+        running: true,
+        pid: daemonPid,
+    };
+}
+async function executeDirectStop(action, context, invokeDaemon, options = { allowUnmanagedRunning: true }) {
+    const pidInfo = readDaemonPid(context.daemonPidPath);
+    if (!pidInfo.pid) {
+        const running = await waitForDaemonRunning(invokeDaemon, 400);
+        if (running.running && !options.allowUnmanagedRunning) {
+            return {
+                action,
+                ok: false,
+                mode: "direct",
+                delegated: false,
+                message: "daemon is running but not managed by direct lifecycle wrapper",
+                details: "Stop it through the service manager that started it.",
+            };
+        }
+        return {
+            action,
+            ok: true,
+            mode: "direct",
+            delegated: false,
+            message: "daemon already stopped",
+            running: false,
+        };
+    }
+    if (!isProcessAlive(pidInfo.pid)) {
+        safeUnlink(context.daemonPidPath);
+        return {
+            action,
+            ok: true,
+            mode: "direct",
+            delegated: false,
+            message: "removed stale daemon pid file",
+            running: false,
+        };
+    }
+    terminateProcess(pidInfo.pid, "SIGTERM");
+    const stopped = await waitForProcessExit(pidInfo.pid, STOP_TIMEOUT_MS);
+    if (!stopped) {
+        terminateProcess(pidInfo.pid, "SIGKILL");
+        const killed = await waitForProcessExit(pidInfo.pid, 1_000);
+        if (!killed) {
+            return {
+                action,
+                ok: false,
+                mode: "direct",
+                delegated: false,
+                message: `failed to stop managed daemon process ${pidInfo.pid}`,
+            };
+        }
+    }
+    safeUnlink(context.daemonPidPath);
+    const running = await waitForDaemonRunning(invokeDaemon, 1_000);
+    if (running.running) {
+        return {
+            action,
+            ok: false,
+            mode: "direct",
+            delegated: false,
+            message: "daemon socket still responds after managed process stop",
+        };
+    }
+    return {
+        action,
+        ok: true,
+        mode: "direct",
+        delegated: false,
+        message: "stopped managed daemon process",
+        running: false,
+    };
+}
+async function waitForDaemonRunning(invokeDaemon, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastReason;
+    while (Date.now() < deadline) {
+        const status = await invokeDaemon("daemon.status", {});
+        if (status.ok) {
+            if (status.value.state === "running" && status.value.healthy) {
+                return { running: true };
+            }
+            lastReason = `state=${status.value.state}, healthy=${status.value.healthy ? "yes" : "no"}`;
+            await sleep(100);
+            continue;
+        }
+        lastReason = status.error.message;
+        await sleep(100);
+    }
+    return {
+        running: false,
+        reason: lastReason,
+    };
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid)) {
+            return true;
+        }
+        await sleep(50);
+    }
+    return !isProcessAlive(pid);
+}
+function terminateProcess(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        // Process may have already exited.
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readDaemonPid(pidPath) {
+    try {
+        const raw = fs.readFileSync(pidPath, "utf8").trim();
+        if (!raw) {
+            return { pid: null };
+        }
+        const pid = Number.parseInt(raw, 10);
+        if (!Number.isInteger(pid) || pid < 1) {
+            return { pid: null };
+        }
+        return { pid };
+    }
+    catch {
+        return { pid: null };
+    }
+}
+function safeUnlink(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // File may already be removed.
+    }
+}
+function resolveDaemonCommandContext(program) {
+    const configOpt = program.opts().config;
+    const configPath = getConfigPath(configOpt);
+    const fileConfig = loadConfig(configPath);
+    const storagePath = resolveDataDir(configPath, fileConfig);
+    const remoteSync = resolveRemoteSyncConfig(fileConfig);
+    const assignedWorkers = resolveDaemonAssignedWorkers(fileConfig);
+    const pluginPaths = resolveDaemonPluginPaths(configPath, fileConfig);
+    const pluginConfig = resolveDaemonPluginConfig(fileConfig);
+    return {
+        storagePath,
+        socketPath: resolveDaemonSocketPath(storagePath),
+        daemonPidPath: path.join(storagePath, DIRECT_PID_FILENAME),
+        daemonEntrypoint: resolveDaemonEntrypoint(),
+        remoteSyncServer: remoteSync?.server ?? null,
+        assignedWorkersEnvValue: assignedWorkers.value,
+        pluginPathsEnvValue: pluginPaths.value,
+        pluginConfigEnvValue: pluginConfig.value,
+    };
+}
+function createDaemonChildEnv(context) {
+    const childEnv = {
+        ...process.env,
+        TODUAI_DATA_DIR: context.storagePath,
+    };
+    if (context.remoteSyncServer) {
+        childEnv.TODUAI_SYNC_SERVER = context.remoteSyncServer;
+        childEnv.TODUAI_SYNC_ENABLED = "1";
+    }
+    if (context.socketPath) {
+        childEnv.TODUAI_DAEMON_SOCKET = context.socketPath;
+    }
+    if (context.assignedWorkersEnvValue !== undefined) {
+        childEnv[TODUAI_DAEMON_ASSIGNED_WORKERS_ENV] = context.assignedWorkersEnvValue;
+    }
+    if (context.pluginPathsEnvValue !== undefined) {
+        childEnv[TODUAI_DAEMON_PLUGIN_PATHS_ENV] = context.pluginPathsEnvValue;
+    }
+    if (context.pluginConfigEnvValue !== undefined) {
+        childEnv[TODUAI_DAEMON_PLUGIN_CONFIG_ENV] = context.pluginConfigEnvValue;
+    }
+    return childEnv;
+}
+function resolveLifecycleMode() {
+    const override = process.env[LIFECYCLE_MODE_ENV]?.trim();
+    if (override && override !== "auto") {
+        if (override === "direct" || override === "systemd-user" || override === "launchd") {
+            return override;
+        }
+        throw new Error(`Invalid ${LIFECYCLE_MODE_ENV} value: ${override}. Expected auto, direct, systemd-user, or launchd.`);
+    }
+    if (process.platform === "linux" &&
+        fs.existsSync(path.join(os.homedir(), SYSTEMD_SERVICE_PATH))) {
+        return "systemd-user";
+    }
+    if (process.platform === "darwin" && fs.existsSync(path.join(os.homedir(), LAUNCHD_PLIST_PATH))) {
+        return "launchd";
+    }
+    return "direct";
+}
+function runCommand(command, args) {
+    const result = spawnSync(command, args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.error) {
+        return {
+            ok: false,
+            message: result.error.message,
+        };
+    }
+    if (result.status !== 0) {
+        const stderr = result.stderr?.trim();
+        const stdout = result.stdout?.trim();
+        return {
+            ok: false,
+            message: stderr || stdout || `exit code ${result.status}`,
+        };
+    }
+    return {
+        ok: true,
+        message: result.stdout?.trim() ?? "",
+    };
+}
+function resolveDaemonEntrypoint() {
+    const explicit = process.env.TODUAI_DAEMON_ENTRYPOINT;
+    if (explicit && explicit.trim().length > 0) {
+        return path.resolve(explicit);
+    }
+    return path.resolve(import.meta.dirname, "../../../daemon/dist/entrypoint.js");
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+//# sourceMappingURL=daemon.js.map