copilot-hub 0.1.7 → 0.1.9

package/README.md

@@ -81,6 +81,7 @@ copilot-hub start
 ```
 
 `start` runs guided setup automatically if required values are missing.
+On interactive terminals, `start` can also offer OS-native service installation when it is not yet configured.
 
 ## Quick start from source
 
@@ -175,6 +176,24 @@ npm run format:check
 npm run check:apps
 ```
 
+Service mode (optional, OS-native):
+
+```bash
+copilot-hub service install
+copilot-hub service status
+copilot-hub service stop
+copilot-hub service start
+copilot-hub service uninstall
+```
+
+Service mode runs a persistent daemon that keeps `agent-engine` and `control-plane` alive and auto-restarts them if one exits.
+
+Service backend by OS:
+
+- Windows: Task Scheduler (`CopilotHub`) with user-startup fallback if task creation is denied
+- Linux: systemd user service (`copilot-hub.service`)
+- macOS: launchd agent (`com.copilot-hub.service`)
+
 ## npm release (CI)
 
 Publishing is automated from GitHub Actions on tags (`v*`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-hub",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Copilot Hub CLI and runtime bundle",
   "license": "MIT",
   "repository": {

package/scripts/dist/cli.mjs

@@ -9,6 +9,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..");
 const packageJsonPath = path.join(repoRoot, "package.json");
+const runtimeDir = path.join(repoRoot, ".copilot-hub");
+const servicePromptStatePath = path.join(runtimeDir, "service-onboarding.json");
 const nodeBin = process.execPath;
 const agentEngineEnvPath = path.join(repoRoot, "apps", "agent-engine", ".env");
 const controlPlaneEnvPath = path.join(repoRoot, "apps", "control-plane", ".env");
@@ -39,19 +41,37 @@ async function main() {
             runNode(["scripts/dist/configure.mjs", "--required-only"]);
             runNode(["scripts/dist/ensure-shared-build.mjs"]);
             await ensureCodexLogin();
+            await maybeOfferServiceInstall();
+            if (isServiceAlreadyInstalled()) {
+                runNode(["scripts/dist/service.mjs", "start"]);
+                return;
+            }
             runNode(["scripts/dist/supervisor.mjs", "up"]);
             return;
         }
         case "stop": {
+            if (isServiceAlreadyInstalled()) {
+                runNode(["scripts/dist/service.mjs", "stop"]);
+                return;
+            }
             runNode(["scripts/dist/supervisor.mjs", "down"]);
             return;
         }
         case "restart": {
             runNode(["scripts/dist/ensure-shared-build.mjs"]);
+            if (isServiceAlreadyInstalled()) {
+                runNode(["scripts/dist/service.mjs", "stop"]);
+                runNode(["scripts/dist/service.mjs", "start"]);
+                return;
+            }
             runNode(["scripts/dist/supervisor.mjs", "restart"]);
             return;
         }
         case "status": {
+            if (isServiceAlreadyInstalled()) {
+                runNode(["scripts/dist/daemon.mjs", "status"]);
+                return;
+            }
             runNode(["scripts/dist/supervisor.mjs", "status"]);
             return;
         }
@@ -63,6 +83,10 @@ async function main() {
             runNode(["scripts/dist/configure.mjs"]);
             return;
         }
+        case "service": {
+            runNode(["scripts/dist/service.mjs", ...rawArgs.slice(1)]);
+            return;
+        }
         default: {
             printUsage();
             process.exit(1);
@@ -70,16 +94,33 @@ async function main() {
     }
 }
 function runNode(scriptArgs) {
-    const result = spawnSync(nodeBin, scriptArgs, {
-        cwd: repoRoot,
-        stdio: "inherit",
-        shell: false,
-    });
+    const result = runNodeCapture(scriptArgs, "inherit");
     const code = Number.isInteger(result.status) ? result.status : 1;
     if (code !== 0) {
         process.exit(code);
     }
 }
+function runNodeCapture(scriptArgs, stdioMode = "pipe") {
+    const stdio = stdioMode === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"];
+    const result = spawnSync(nodeBin, scriptArgs, {
+        cwd: repoRoot,
+        stdio,
+        shell: false,
+        encoding: "utf8",
+    });
+    const stdout = String(result.stdout ?? "").trim();
+    const stderr = String(result.stderr ?? "").trim();
+    const combinedOutput = [stdout, stderr].filter(Boolean).join("\n").trim();
+    const ok = !result.error && result.status === 0;
+    return {
+        ok,
+        status: result.status,
+        stdout,
+        stderr,
+        combinedOutput,
+        error: result.error,
+    };
+}
 async function ensureCodexLogin() {
     const resolved = resolveCodexBinForStart();
     let codexBin = resolved.bin;
@@ -149,6 +190,81 @@ async function ensureCodexLogin() {
     }
     console.log("Codex login configured.");
 }
+async function maybeOfferServiceInstall() {
+    if (!process.stdin.isTTY) {
+        return;
+    }
+    if (!isServiceSupportedOnCurrentPlatform()) {
+        return;
+    }
+    if (isServiceAlreadyInstalled()) {
+        return;
+    }
+    const state = readServicePromptState();
+    if (state?.decision === "declined") {
+        return;
+    }
+    const rl = createInterface({ input, output });
+    let shouldInstall = false;
+    try {
+        shouldInstall = await askYesNo(rl, "Enable OS-native auto-start service now? (recommended for reliability)", false);
+    }
+    finally {
+        rl.close();
+    }
+    if (!shouldInstall) {
+        writeServicePromptState("declined");
+        console.log("Service setup skipped. You can run 'copilot-hub service install' anytime.");
+        return;
+    }
+    const install = runNodeCapture(["scripts/dist/service.mjs", "install"], "inherit");
+    if (!install.ok) {
+        console.log("Service install failed. Continuing in local mode.");
+        return;
+    }
+    writeServicePromptState("accepted");
+}
+function isServiceSupportedOnCurrentPlatform() {
+    return (process.platform === "win32" || process.platform === "linux" || process.platform === "darwin");
+}
+function isServiceAlreadyInstalled() {
+    const status = runNodeCapture(["scripts/dist/service.mjs", "status"], "pipe");
+    const message = String(status.combinedOutput ?? "").toLowerCase();
+    if (message.includes("service not installed")) {
+        return false;
+    }
+    if (message.includes("not installed")) {
+        return false;
+    }
+    return status.ok;
+}
+function readServicePromptState() {
+    if (!fs.existsSync(servicePromptStatePath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(servicePromptStatePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeServicePromptState(decision) {
+    try {
+        fs.mkdirSync(runtimeDir, { recursive: true });
+        fs.writeFileSync(servicePromptStatePath, `${JSON.stringify({
+            decision: String(decision ?? "")
+                .trim()
+                .toLowerCase(),
+            updatedAt: new Date().toISOString(),
+        }, null, 2)}\n`, "utf8");
+    }
+    catch {
+        // Non-critical state cache only.
+    }
+}
 async function recoverCodexBinary({ resolved, status }) {
     const detected = findDetectedCodexBin();
     if (detected && detected !== resolved.bin) {
@@ -469,7 +585,11 @@ function spawnNpm(args, options) {
     });
 }
 function printUsage() {
-    console.log("Usage: node scripts/dist/cli.mjs <start|stop|restart|status|logs|configure|version|help>");
+    console.log([
+        "Usage: node scripts/dist/cli.mjs <start|stop|restart|status|logs|configure|service|version|help>",
+        "Service management:",
+        "  node scripts/dist/cli.mjs service <install|uninstall|status|start|stop|help>",
+    ].join("\n"));
 }
 function readPackageVersion() {
     try {

package/scripts/dist/daemon.mjs

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..", "..");
+const runtimeDir = path.join(repoRoot, ".copilot-hub");
+const pidsDir = path.join(runtimeDir, "pids");
+const logsDir = path.join(repoRoot, "logs");
+const daemonStatePath = path.join(pidsDir, "daemon.json");
+const daemonLogPath = path.join(logsDir, "service-daemon.log");
+const daemonScriptPath = path.join(repoRoot, "scripts", "dist", "daemon.mjs");
+const supervisorScriptPath = path.join(repoRoot, "scripts", "dist", "supervisor.mjs");
+const nodeBin = process.execPath;
+const BASE_CHECK_MS = 5000;
+const MAX_BACKOFF_MS = 60000;
+const action = String(process.argv[2] ?? "status")
+    .trim()
+    .toLowerCase();
+try {
+    await main();
+}
+catch (error) {
+    console.error(getErrorMessage(error));
+    process.exit(1);
+}
+async function main() {
+    switch (action) {
+        case "start":
+            await startDaemonProcess();
+            return;
+        case "run":
+            await runDaemonLoop();
+            return;
+        case "stop":
+            await stopDaemonProcess();
+            return;
+        case "status":
+            showDaemonStatus();
+            return;
+        case "help":
+            printUsage();
+            return;
+        default:
+            printUsage();
+            process.exit(1);
+    }
+}
+async function startDaemonProcess() {
+    ensureScripts();
+    ensureRuntimeDirs();
+    const existingPid = getRunningDaemonPid();
+    if (existingPid > 0) {
+        console.log(`[daemon] already running (pid ${existingPid})`);
+        return;
+    }
+    removeDaemonState();
+    const logFd = fs.openSync(daemonLogPath, "a");
+    let child;
+    try {
+        child = spawn(nodeBin, [daemonScriptPath, "run"], {
+            cwd: repoRoot,
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            windowsHide: true,
+            shell: false,
+            env: process.env,
+        });
+    }
+    finally {
+        fs.closeSync(logFd);
+    }
+    const pid = normalizePid(child?.pid);
+    if (pid <= 0) {
+        throw new Error("Failed to spawn daemon process.");
+    }
+    child.unref();
+    const ready = await waitForExit(pid, 250, false);
+    if (ready) {
+        throw new Error(`Daemon process exited immediately (pid ${pid}). Check logs: ${daemonLogPath}`);
+    }
+    console.log(`[daemon] started (pid ${pid})`);
+}
+async function runDaemonLoop() {
+    ensureScripts();
+    ensureRuntimeDirs();
+    const existingPid = getRunningDaemonPid();
+    if (existingPid > 0 && existingPid !== process.pid) {
+        console.log(`[daemon] already running (pid ${existingPid})`);
+        return;
+    }
+    writeDaemonState({
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        command: `${nodeBin} ${daemonScriptPath} run`,
+    });
+    const state = { stopping: false, shuttingDown: false };
+    setupSignalHandlers(state);
+    console.log(`[daemon] running (pid ${process.pid})`);
+    let failureCount = 0;
+    while (!state.stopping) {
+        const ensureResult = runSupervisor("ensure", { allowFailure: true });
+        if (ensureResult.ok) {
+            if (failureCount > 0) {
+                console.log("[daemon] workers recovered.");
+            }
+            failureCount = 0;
+            await sleepInterruptible(BASE_CHECK_MS, () => state.stopping);
+            continue;
+        }
+        failureCount += 1;
+        const delay = computeBackoffDelay(failureCount);
+        const reason = firstLine(ensureResult.combinedOutput) ||
+            `supervisor ensure exited with code ${String(ensureResult.status ?? "unknown")}`;
+        console.error(`[daemon] worker health check failed: ${reason}. Retrying in ${Math.ceil(delay / 1000)}s.`);
+        await sleepInterruptible(delay, () => state.stopping);
+    }
+    await shutdownDaemon(state, { reason: "stop-request", exitCode: 0 });
+}
+async function stopDaemonProcess() {
+    ensureRuntimeDirs();
+    const pid = getRunningDaemonPid();
+    if (pid <= 0) {
+        removeDaemonState();
+        runSupervisor("down", { allowFailure: true });
+        console.log("[daemon] not running.");
+        return;
+    }
+    await terminateProcess(pid);
+    if (isProcessRunning(pid)) {
+        throw new Error(`Daemon did not stop cleanly (pid ${pid}).`);
+    }
+    removeDaemonState();
+    runSupervisor("down", { allowFailure: true });
+    console.log("[daemon] stopped.");
+}
+function showDaemonStatus() {
+    ensureRuntimeDirs();
+    const pid = getRunningDaemonPid();
+    const running = pid > 0;
+    if (!running) {
+        removeDaemonState();
+    }
+    console.log("\n=== daemon ===");
+    console.log(`running: ${running ? "yes" : "no"}`);
+    console.log(`pid: ${running ? String(pid) : "-"}`);
+    console.log(`logFile: ${daemonLogPath}`);
+    if (!fs.existsSync(supervisorScriptPath)) {
+        console.log("\n(worker status unavailable: supervisor script missing)");
+        return;
+    }
+    console.log("\n=== workers ===");
+    runSupervisor("status", { allowFailure: true, stdio: "inherit" });
+}
+function setupSignalHandlers(state) {
+    const requestStop = () => {
+        state.stopping = true;
+    };
+    process.on("SIGINT", requestStop);
+    process.on("SIGTERM", requestStop);
+    process.on("SIGHUP", requestStop);
+    process.on("uncaughtException", (error) => {
+        if (!state.shuttingDown) {
+            console.error(`[daemon] uncaught exception: ${getErrorMessage(error)}`);
+        }
+        state.stopping = true;
+        void shutdownDaemon(state, { reason: "uncaught-exception", exitCode: 1 });
+    });
+    process.on("unhandledRejection", (reason) => {
+        if (!state.shuttingDown) {
+            console.error(`[daemon] unhandled rejection: ${getErrorMessage(reason)}`);
+        }
+        state.stopping = true;
+        void shutdownDaemon(state, { reason: "unhandled-rejection", exitCode: 1 });
+    });
+}
+async function shutdownDaemon(state, { reason, exitCode }) {
+    if (state.shuttingDown) {
+        return;
+    }
+    state.shuttingDown = true;
+    console.log(`[daemon] stopping (${reason})...`);
+    runSupervisor("down", { allowFailure: true });
+    removeDaemonState();
+    process.exit(exitCode);
+}
+function ensureScripts() {
+    if (!fs.existsSync(supervisorScriptPath)) {
+        throw new Error([
+            "Supervisor script is missing.",
+            "Run 'npm run build:scripts' (or reinstall package) and retry.",
+        ].join("\n"));
+    }
+    if (!fs.existsSync(daemonScriptPath)) {
+        throw new Error([
+            "Daemon script is missing.",
+            "Run 'npm run build:scripts' (or reinstall package) and retry.",
+        ].join("\n"));
+    }
+}
+function ensureRuntimeDirs() {
+    fs.mkdirSync(runtimeDir, { recursive: true });
+    fs.mkdirSync(pidsDir, { recursive: true });
+    fs.mkdirSync(logsDir, { recursive: true });
+}
+function getRunningDaemonPid() {
+    const state = readDaemonState();
+    const pid = normalizePid(state?.pid);
+    if (pid <= 0) {
+        return 0;
+    }
+    return isProcessRunning(pid) ? pid : 0;
+}
+function readDaemonState() {
+    if (!fs.existsSync(daemonStatePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(daemonStatePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeDaemonState(value) {
+    fs.mkdirSync(path.dirname(daemonStatePath), { recursive: true });
+    fs.writeFileSync(daemonStatePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function removeDaemonState() {
+    if (!fs.existsSync(daemonStatePath)) {
+        return;
+    }
+    fs.rmSync(daemonStatePath, { force: true });
+}
+function normalizePid(value) {
+    const pid = Number.parseInt(String(value ?? ""), 10);
+    if (!Number.isFinite(pid) || pid <= 0) {
+        return 0;
+    }
+    return pid;
+}
+function isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+async function terminateProcess(pid) {
+    if (process.platform === "win32") {
+        await killTreeWindows(pid);
+        if (!(await waitForExit(pid, 7000))) {
+            await killTreeWindows(pid);
+        }
+        return;
+    }
+    sendSignal(pid, "SIGTERM");
+    if (await waitForExit(pid, 7000)) {
+        return;
+    }
+    sendSignal(pid, "SIGKILL");
+    await waitForExit(pid, 2000);
+}
+function killTreeWindows(pid) {
+    return new Promise((resolve) => {
+        const child = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            shell: false,
+            windowsHide: true,
+        });
+        child.once("error", () => resolve());
+        child.once("exit", () => resolve());
+    });
+}
+function sendSignal(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+        return;
+    }
+    catch {
+        // continue
+    }
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        // ignore
+    }
+}
+async function waitForExit(pid, timeoutMs, expectExit = true) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const running = isProcessRunning(pid);
+        if (expectExit && !running) {
+            return true;
+        }
+        if (!expectExit && running) {
+            return false;
+        }
+        await sleep(100);
+    }
+    const stillRunning = isProcessRunning(pid);
+    return expectExit ? !stillRunning : stillRunning === false;
+}
+function runSupervisor(actionValue, { allowFailure = false, stdio = "pipe" } = {}) {
+    return runChecked(nodeBin, [supervisorScriptPath, String(actionValue ?? "").trim()], {
+        allowFailure,
+        stdio,
+    });
+}
+function runChecked(command, args, { stdio = "pipe", allowFailure = false } = {}) {
+    const spawnStdio = stdio;
+    const result = spawnSync(command, args, {
+        cwd: repoRoot,
+        shell: false,
+        stdio: spawnStdio,
+        encoding: "utf8",
+        env: process.env,
+    });
+    const stdout = String(result.stdout ?? "").trim();
+    const stderr = String(result.stderr ?? "").trim();
+    const combinedOutput = [stdout, stderr].filter(Boolean).join("\n").trim();
+    const spawnErrorCode = String(result.error?.code ?? "")
+        .trim()
+        .toUpperCase();
+    const ok = !result.error && result.status === 0;
+    if (!ok && !allowFailure) {
+        const errorMessage = result.error && spawnErrorCode
+            ? `${command} failed (${spawnErrorCode}).`
+            : combinedOutput || `${command} exited with code ${String(result.status ?? "unknown")}.`;
+        throw new Error(errorMessage);
+    }
+    return {
+        ok,
+        status: result.status,
+        stdout,
+        stderr,
+        combinedOutput,
+        spawnErrorCode,
+    };
+}
+function computeBackoffDelay(failureCount) {
+    const power = Math.max(0, failureCount - 1);
+    const calculated = BASE_CHECK_MS * 2 ** power;
+    return Math.min(calculated, MAX_BACKOFF_MS);
+}
+async function sleepInterruptible(ms, shouldStop) {
+    const deadline = Date.now() + ms;
+    while (Date.now() < deadline) {
+        if (shouldStop()) {
+            return;
+        }
+        await sleep(Math.min(250, Math.max(1, deadline - Date.now())));
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function firstLine(value) {
+    const text = String(value ?? "").trim();
+    if (!text) {
+        return "";
+    }
+    const [line] = text.split(/\r?\n/, 1);
+    return String(line ?? "").trim();
+}
+function getErrorMessage(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return String(error ?? "Unknown error.");
+}
+function printUsage() {
+    console.log("Usage: node scripts/dist/daemon.mjs <start|run|stop|status|help>");
+}