copilot-hub 0.1.7 → 0.1.8

package/scripts/dist/service.mjs

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { 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 nodeBin = process.execPath;
+const daemonScriptPath = path.join(repoRoot, "scripts", "dist", "daemon.mjs");
+const WINDOWS_TASK_NAME = "CopilotHub";
+const WINDOWS_RUN_KEY_PATH = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+const WINDOWS_RUN_VALUE_NAME = "CopilotHub";
+const LINUX_UNIT_NAME = "copilot-hub.service";
+const MACOS_LABEL = "com.copilot-hub.service";
+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 "install":
+            await installService();
+            return;
+        case "uninstall":
+            await uninstallService();
+            return;
+        case "status":
+            await showStatus();
+            return;
+        case "start":
+            await startService();
+            return;
+        case "stop":
+            await stopService();
+            return;
+        case "help":
+            printUsage();
+            return;
+        default:
+            printUsage();
+            process.exit(1);
+    }
+}
+async function installService() {
+    ensureDaemonScript();
+    if (process.platform === "win32") {
+        const mode = installWindowsAutoStart();
+        if (mode === "task") {
+            console.log("Service installed (Windows Task Scheduler).");
+        }
+        else {
+            console.log("Service installed (Windows startup registry entry).");
+        }
+        return;
+    }
+    if (process.platform === "linux") {
+        installLinuxService();
+        console.log("Service installed (systemd user service).");
+        return;
+    }
+    if (process.platform === "darwin") {
+        installMacosService();
+        console.log("Service installed (launchd user agent).");
+        return;
+    }
+    throw new Error(`Unsupported platform: ${process.platform}`);
+}
+async function uninstallService() {
+    if (process.platform === "win32") {
+        const removed = uninstallWindowsAutoStart();
+        if (!removed) {
+            console.log("Service auto-start is already absent.");
+            return;
+        }
+        console.log("Service uninstalled (Windows auto-start).");
+        return;
+    }
+    if (process.platform === "linux") {
+        uninstallLinuxService();
+        console.log("Service uninstalled (systemd user service).");
+        return;
+    }
+    if (process.platform === "darwin") {
+        uninstallMacosService();
+        console.log("Service uninstalled (launchd user agent).");
+        return;
+    }
+    throw new Error(`Unsupported platform: ${process.platform}`);
+}
+async function showStatus() {
+    if (process.platform === "win32") {
+        showWindowsAutoStartStatus();
+        return;
+    }
+    if (process.platform === "linux") {
+        showLinuxServiceStatus();
+        return;
+    }
+    if (process.platform === "darwin") {
+        showMacosServiceStatus();
+        return;
+    }
+    throw new Error(`Unsupported platform: ${process.platform}`);
+}
+async function startService() {
+    if (process.platform === "win32") {
+        startWindowsAutoStart();
+        return;
+    }
+    if (process.platform === "linux") {
+        ensureSystemctl();
+        runChecked("systemctl", ["--user", "start", LINUX_UNIT_NAME], { stdio: "inherit" });
+        return;
+    }
+    if (process.platform === "darwin") {
+        startMacosService();
+        return;
+    }
+    throw new Error(`Unsupported platform: ${process.platform}`);
+}
+async function stopService() {
+    if (process.platform === "win32") {
+        runDaemon("stop");
+        return;
+    }
+    if (process.platform === "linux") {
+        ensureSystemctl();
+        runChecked("systemctl", ["--user", "stop", LINUX_UNIT_NAME], { stdio: "inherit" });
+        return;
+    }
+    if (process.platform === "darwin") {
+        stopMacosService();
+        return;
+    }
+    throw new Error(`Unsupported platform: ${process.platform}`);
+}
+function installWindowsAutoStart() {
+    ensureCommandAvailable("schtasks", ["/?"], "Windows Task Scheduler is not available.");
+    ensureCommandAvailable("reg", ["query", WINDOWS_RUN_KEY_PATH], "Windows registry tools are not available.");
+    const command = buildWindowsLaunchCommand();
+    const taskCreate = runChecked("schtasks", ["/Create", "/TN", WINDOWS_TASK_NAME, "/SC", "ONLOGON", "/RL", "LIMITED", "/F", "/TR", command], { allowFailure: true });
+    if (taskCreate.ok) {
+        runWindowsTask();
+        return "task";
+    }
+    if (!isAccessDeniedMessage(taskCreate.combinedOutput)) {
+        throw new Error(taskCreate.combinedOutput || "Failed to create Windows auto-start task.");
+    }
+    installWindowsRunKey(command);
+    runDaemon("start");
+    return "run-key";
+}
+function uninstallWindowsAutoStart() {
+    ensureCommandAvailable("schtasks", ["/?"], "Windows Task Scheduler is not available.");
+    ensureCommandAvailable("reg", ["query", WINDOWS_RUN_KEY_PATH], "Windows registry tools are not available.");
+    runDaemon("stop", { allowFailure: true });
+    let removed = false;
+    const taskDelete = runChecked("schtasks", ["/Delete", "/TN", WINDOWS_TASK_NAME, "/F"], {
+        allowFailure: true,
+    });
+    if (taskDelete.ok) {
+        removed = true;
+    }
+    else if (!isNotFoundMessage(taskDelete.combinedOutput) &&
+        !isAccessDeniedMessage(taskDelete.combinedOutput)) {
+        throw new Error(taskDelete.combinedOutput || "Failed to remove Windows Task Scheduler entry.");
+    }
+    const runKeyDelete = runChecked("reg", ["delete", WINDOWS_RUN_KEY_PATH, "/v", WINDOWS_RUN_VALUE_NAME, "/f"], { allowFailure: true });
+    if (runKeyDelete.ok) {
+        removed = true;
+    }
+    else if (!isRegistryValueNotFoundMessage(runKeyDelete.combinedOutput)) {
+        throw new Error(runKeyDelete.combinedOutput || "Failed to remove Windows startup registry entry.");
+    }
+    return removed;
+}
+function showWindowsAutoStartStatus() {
+    ensureCommandAvailable("schtasks", ["/?"], "Windows Task Scheduler is not available.");
+    ensureCommandAvailable("reg", ["query", WINDOWS_RUN_KEY_PATH], "Windows registry tools are not available.");
+    const runKey = queryWindowsRunKey();
+    if (runKey.installed) {
+        console.log("Service installed (Windows startup registry entry).");
+        return;
+    }
+    const result = runChecked("schtasks", ["/Query", "/TN", WINDOWS_TASK_NAME, "/FO", "LIST", "/V"], {
+        allowFailure: true,
+    });
+    if (!result.ok &&
+        (isNotFoundMessage(result.combinedOutput) || isAccessDeniedMessage(result.combinedOutput))) {
+        console.log("Service not installed.");
+        return;
+    }
+    if (!result.ok) {
+        throw new Error(result.combinedOutput || "Failed to query service task.");
+    }
+    console.log("Service installed (Windows Task Scheduler).");
+}
+function runWindowsTask() {
+    ensureCommandAvailable("schtasks", ["/?"], "Windows Task Scheduler is not available.");
+    const result = runChecked("schtasks", ["/Run", "/TN", WINDOWS_TASK_NAME], { allowFailure: true });
+    if (!result.ok && isNotFoundMessage(result.combinedOutput)) {
+        throw new Error("Service is not installed. Run 'copilot-hub service install' first.");
+    }
+    if (!result.ok) {
+        throw new Error(result.combinedOutput || "Failed to run service task.");
+    }
+}
+function startWindowsAutoStart() {
+    const runKey = queryWindowsRunKey();
+    if (runKey.installed) {
+        runDaemon("start");
+        return;
+    }
+    runWindowsTask();
+}
+function queryWindowsRunKey() {
+    const result = runChecked("reg", ["query", WINDOWS_RUN_KEY_PATH, "/v", WINDOWS_RUN_VALUE_NAME], {
+        allowFailure: true,
+    });
+    if (result.ok) {
+        return { installed: true };
+    }
+    if (isRegistryValueNotFoundMessage(result.combinedOutput) || result.status === 1) {
+        return { installed: false };
+    }
+    throw new Error(result.combinedOutput || "Failed to query Windows startup registry entry.");
+}
+function installWindowsRunKey(command) {
+    runChecked("reg", [
+        "add",
+        WINDOWS_RUN_KEY_PATH,
+        "/v",
+        WINDOWS_RUN_VALUE_NAME,
+        "/t",
+        "REG_SZ",
+        "/d",
+        command,
+        "/f",
+    ], { stdio: "pipe" });
+}
+function installLinuxService() {
+    ensureSystemctl();
+    const unitPath = getLinuxUnitPath();
+    fs.mkdirSync(path.dirname(unitPath), { recursive: true });
+    fs.writeFileSync(unitPath, buildLinuxUnitContent(), "utf8");
+    runChecked("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+    runChecked("systemctl", ["--user", "enable", "--now", LINUX_UNIT_NAME], { stdio: "inherit" });
+}
+function uninstallLinuxService() {
+    ensureSystemctl();
+    runChecked("systemctl", ["--user", "disable", "--now", LINUX_UNIT_NAME], {
+        allowFailure: true,
+        stdio: "inherit",
+    });
+    const unitPath = getLinuxUnitPath();
+    if (fs.existsSync(unitPath)) {
+        fs.rmSync(unitPath, { force: true });
+    }
+    runChecked("systemctl", ["--user", "daemon-reload"], { stdio: "inherit" });
+}
+function showLinuxServiceStatus() {
+    ensureSystemctl();
+    const unitPath = getLinuxUnitPath();
+    const result = runChecked("systemctl", ["--user", "status", LINUX_UNIT_NAME, "--no-pager", "--lines=40"], { allowFailure: true });
+    if (!result.ok && !fs.existsSync(unitPath)) {
+        console.log("Service not installed.");
+        return;
+    }
+    console.log((result.stdout || result.stderr || "No status output.").trim());
+}
+function installMacosService() {
+    ensureCommandAvailable("launchctl", ["help"], "launchctl is not available.");
+    const plistPath = getMacosPlistPath();
+    fs.mkdirSync(path.dirname(plistPath), { recursive: true });
+    fs.mkdirSync(path.join(repoRoot, "logs"), { recursive: true });
+    fs.writeFileSync(plistPath, buildMacosPlist(), "utf8");
+    stopMacosService({ allowFailure: true });
+    const target = getMacosLaunchTarget();
+    runChecked("launchctl", ["bootstrap", target, plistPath], { stdio: "inherit" });
+    runChecked("launchctl", ["kickstart", "-k", `${target}/${MACOS_LABEL}`], { stdio: "inherit" });
+}
+function uninstallMacosService() {
+    ensureCommandAvailable("launchctl", ["help"], "launchctl is not available.");
+    stopMacosService({ allowFailure: true });
+    const plistPath = getMacosPlistPath();
+    if (fs.existsSync(plistPath)) {
+        fs.rmSync(plistPath, { force: true });
+    }
+}
+function showMacosServiceStatus() {
+    ensureCommandAvailable("launchctl", ["help"], "launchctl is not available.");
+    const target = getMacosLaunchTarget();
+    const label = `${target}/${MACOS_LABEL}`;
+    const result = runChecked("launchctl", ["print", label], { allowFailure: true });
+    if (!result.ok && !fs.existsSync(getMacosPlistPath())) {
+        console.log("Service not installed.");
+        return;
+    }
+    console.log((result.stdout || result.stderr || "No status output.").trim());
+}
+function startMacosService() {
+    ensureCommandAvailable("launchctl", ["help"], "launchctl is not available.");
+    const plistPath = getMacosPlistPath();
+    if (!fs.existsSync(plistPath)) {
+        throw new Error("Service is not installed. Run 'copilot-hub service install' first.");
+    }
+    const target = getMacosLaunchTarget();
+    const label = `${target}/${MACOS_LABEL}`;
+    const kickstart = runChecked("launchctl", ["kickstart", "-k", label], { allowFailure: true });
+    if (kickstart.ok) {
+        return;
+    }
+    runChecked("launchctl", ["bootstrap", target, plistPath], { stdio: "inherit" });
+    runChecked("launchctl", ["kickstart", "-k", label], { stdio: "inherit" });
+}
+function stopMacosService({ allowFailure = false } = {}) {
+    ensureCommandAvailable("launchctl", ["help"], "launchctl is not available.");
+    const target = getMacosLaunchTarget();
+    runChecked("launchctl", ["bootout", target, getMacosPlistPath()], {
+        allowFailure,
+        stdio: "inherit",
+    });
+}
+function getLinuxUnitPath() {
+    return path.join(os.homedir(), ".config", "systemd", "user", LINUX_UNIT_NAME);
+}
+function getMacosPlistPath() {
+    return path.join(os.homedir(), "Library", "LaunchAgents", `${MACOS_LABEL}.plist`);
+}
+function getMacosLaunchTarget() {
+    if (typeof process.getuid !== "function") {
+        throw new Error("Could not resolve macOS user id.");
+    }
+    return `gui/${process.getuid()}`;
+}
+function buildLinuxUnitContent() {
+    return [
+        "[Unit]",
+        "Description=Copilot Hub Service",
+        "After=network-online.target",
+        "",
+        "[Service]",
+        "Type=simple",
+        `WorkingDirectory=${repoRoot}`,
+        `ExecStart="${nodeBin}" "${daemonScriptPath}" run`,
+        `ExecStop="${nodeBin}" "${daemonScriptPath}" stop`,
+        "Restart=always",
+        "RestartSec=3",
+        "KillMode=process",
+        "",
+        "[Install]",
+        "WantedBy=default.target",
+        "",
+    ].join("\n");
+}
+function buildMacosPlist() {
+    const stdoutPath = path.join(repoRoot, "logs", "service-launchd.log");
+    const stderrPath = path.join(repoRoot, "logs", "service-launchd.error.log");
+    const values = {
+        label: escapeXml(MACOS_LABEL),
+        node: escapeXml(nodeBin),
+        script: escapeXml(daemonScriptPath),
+        cwd: escapeXml(repoRoot),
+        stdoutPath: escapeXml(stdoutPath),
+        stderrPath: escapeXml(stderrPath),
+    };
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        '<plist version="1.0">',
+        "<dict>",
+        "  <key>Label</key>",
+        `  <string>${values.label}</string>`,
+        "  <key>ProgramArguments</key>",
+        "  <array>",
+        `    <string>${values.node}</string>`,
+        `    <string>${values.script}</string>`,
+        "    <string>run</string>",
+        "  </array>",
+        "  <key>WorkingDirectory</key>",
+        `  <string>${values.cwd}</string>`,
+        "  <key>RunAtLoad</key>",
+        "  <true/>",
+        "  <key>KeepAlive</key>",
+        "  <true/>",
+        "  <key>StandardOutPath</key>",
+        `  <string>${values.stdoutPath}</string>`,
+        "  <key>StandardErrorPath</key>",
+        `  <string>${values.stderrPath}</string>`,
+        "</dict>",
+        "</plist>",
+        "",
+    ].join("\n");
+}
+function ensureDaemonScript() {
+    if (!fs.existsSync(daemonScriptPath)) {
+        throw new Error([
+            "Daemon script is missing.",
+            "Run 'npm run build:scripts' (or reinstall package) and retry.",
+        ].join("\n"));
+    }
+}
+function ensureSystemctl() {
+    ensureCommandAvailable("systemctl", ["--version"], "systemd is not available. This command requires Linux with systemd user services.");
+}
+function ensureCommandAvailable(command, args, errorMessage) {
+    const probe = runChecked(command, args, { allowFailure: true });
+    if (!probe.spawnErrorCode || probe.spawnErrorCode !== "ENOENT") {
+        return;
+    }
+    throw new Error(errorMessage);
+}
+function runDaemon(actionValue, { allowFailure = false } = {}) {
+    const result = runChecked(nodeBin, [daemonScriptPath, String(actionValue ?? "").trim()], {
+        stdio: "inherit",
+        allowFailure,
+    });
+    if (!result.ok && !allowFailure) {
+        throw new Error(result.combinedOutput || `Failed to execute daemon action '${actionValue}'.`);
+    }
+}
+function runChecked(command, args, { stdio = "pipe", allowFailure = false } = {}) {
+    const result = spawnSync(command, args, {
+        cwd: repoRoot,
+        shell: false,
+        stdio,
+        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 isNotFoundMessage(value) {
+    const message = String(value ?? "").toLowerCase();
+    if (!message) {
+        return false;
+    }
+    return (message.includes("cannot find") ||
+        message.includes("cannot be found") ||
+        message.includes("not found") ||
+        message.includes("introuvable") ||
+        message.includes("n'existe pas"));
+}
+function isAccessDeniedMessage(value) {
+    const message = String(value ?? "").toLowerCase();
+    if (!message) {
+        return false;
+    }
+    return message.includes("access is denied") || message.includes("accès refusé");
+}
+function isRegistryValueNotFoundMessage(value) {
+    const message = String(value ?? "").toLowerCase();
+    if (!message) {
+        return false;
+    }
+    return (message.includes("unable to find the specified registry key or value") ||
+        message.includes("the system was unable to find the specified registry key or value") ||
+        message.includes("impossible de trouver") ||
+        message.includes("n'a pas trouvé") ||
+        message.includes("n’a pas trouvé") ||
+        message.includes("n a pas trouvé") ||
+        message.includes("la clé ou la valeur de registre spécifiée") ||
+        message.includes("introuvable"));
+}
+function getErrorMessage(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return String(error ?? "Unknown error.");
+}
+function buildWindowsLaunchCommand() {
+    return `"${nodeBin}" "${daemonScriptPath}" run`;
+}
+function escapeXml(value) {
+    return String(value ?? "")
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function printUsage() {
+    console.log([
+        "Usage: node scripts/dist/service.mjs <install|uninstall|status|start|stop|help>",
+        "",
+        "Platform mapping:",
+        "- Windows: Task Scheduler task (fallback: user startup registry entry)",
+        "- Linux: systemd user service",
+        "- macOS: launchd user agent",
+    ].join("\n"));
+}

package/scripts/dist/supervisor.mjs

@@ -36,6 +36,9 @@ async function main() {
         case "up":
             await startServices();
             return;
+        case "ensure":
+            await ensureServices();
+            return;
         case "down":
             await stopServices();
             return;
@@ -69,6 +72,19 @@ async function startServices() {
         started.push(service);
     }
 }
+async function ensureServices() {
+    ensureRuntimeDirs();
+    let hasFailure = false;
+    for (const service of SERVICES) {
+        const ok = await startService(service, { suppressAlreadyRunning: true });
+        if (!ok) {
+            hasFailure = true;
+        }
+    }
+    if (hasFailure) {
+        process.exit(1);
+    }
+}
 async function stopServices() {
     for (const service of SERVICES) {
         await stopService(service);
@@ -96,11 +112,14 @@ function showLogs() {
         printTail(service.logFile, 120);
     }
 }
-async function startService(service) {
+async function startService(service, options = {}) {
+    const suppressAlreadyRunning = options?.suppressAlreadyRunning === true;
     const existing = readState(service);
     const existingPid = normalizePid(existing?.pid);
     if (existingPid > 0 && isProcessRunning(existingPid)) {
-        console.log(`[${service.id}] already running (pid ${existingPid})`);
+        if (!suppressAlreadyRunning) {
+            console.log(`[${service.id}] already running (pid ${existingPid})`);
+        }
         return true;
     }
     if (existing) {
@@ -281,5 +300,5 @@ function sleep(ms) {
     });
 }
 function printUsage() {
-    console.log("Usage: node scripts/dist/supervisor.mjs <up|down|restart|status|logs>");
+    console.log("Usage: node scripts/dist/supervisor.mjs <up|ensure|down|restart|status|logs>");
 }