copilot-hub 0.1.32 → 0.1.34

package/scripts/dist/service.mjs

@@ -4,10 +4,11 @@ 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 { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { initializeCopilotHubLayout, resolveCopilotHubLayout } from "./install-layout.mjs";
-import { buildWindowsHiddenLauncherCommand, ensureWindowsHiddenLauncher, getWindowsHiddenLauncherScriptPath, resolveWindowsScriptHost, } from "./windows-hidden-launcher.mjs";
+import { isManagedProcessRunning, normalizePid } from "./process-identity.mjs";
+import { buildWindowsHiddenLauncherCommand, ensureWindowsHiddenLauncher, getWindowsHiddenLauncherScriptPath, getWindowsHiddenLauncherStopSignalPath, resolveWindowsScriptHost, } from "./windows-hidden-launcher.mjs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..");
@@ -15,12 +16,16 @@ const layout = resolveCopilotHubLayout({ repoRoot });
 initializeCopilotHubLayout({ repoRoot, layout });
 const nodeBin = process.execPath;
 const daemonScriptPath = path.join(repoRoot, "scripts", "dist", "daemon.mjs");
+const daemonStatePath = path.join(layout.runtimeDir, "pids", "daemon.json");
 const windowsLauncherScriptPath = getWindowsHiddenLauncherScriptPath(layout.runtimeDir);
+const windowsLauncherStopSignalPath = getWindowsHiddenLauncherStopSignalPath(layout.runtimeDir);
 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 WINDOWS_LAUNCHER_STOP_TIMEOUT_MS = 12_000;
+const WINDOWS_LAUNCHER_POLL_INTERVAL_MS = 250;
 const action = String(process.argv[2] ?? "status")
     .trim()
     .toLowerCase();
@@ -59,7 +64,7 @@ async function main() {
 async function installService() {
     ensureDaemonScript();
     if (process.platform === "win32") {
-        const mode = installWindowsAutoStart();
+        const mode = await installWindowsAutoStart();
         if (mode === "task") {
             console.log("Service installed (Windows Task Scheduler).");
         }
@@ -82,7 +87,7 @@ async function installService() {
 }
 async function uninstallService() {
     if (process.platform === "win32") {
-        const removed = uninstallWindowsAutoStart();
+        const removed = await uninstallWindowsAutoStart();
         if (!removed) {
             console.log("Service auto-start is already absent.");
             return;
@@ -119,7 +124,7 @@ async function showStatus() {
 }
 async function startService() {
     if (process.platform === "win32") {
-        const mode = startWindowsAutoStart();
+        const mode = await startWindowsAutoStart();
         if (mode === "run-key") {
             console.log("Service started in background (Windows startup registry entry).");
         }
@@ -141,7 +146,7 @@ async function startService() {
 }
 async function stopService() {
     if (process.platform === "win32") {
-        runDaemon("stop");
+        await stopWindowsAutoStart();
         return;
     }
     if (process.platform === "linux") {
@@ -155,26 +160,35 @@ async function stopService() {
     }
     throw new Error(`Unsupported platform: ${process.platform}`);
 }
-function installWindowsAutoStart() {
+async 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();
+        clearWindowsLauncherStopRequest();
+        await ensureWindowsSessionRunning("task");
         return "task";
     }
     if (!isAccessDeniedMessage(taskCreate.combinedOutput)) {
         throw new Error(taskCreate.combinedOutput || "Failed to create Windows auto-start task.");
     }
     installWindowsRunKey(command);
-    runWindowsHiddenLauncher();
+    clearWindowsLauncherStopRequest();
+    await ensureWindowsSessionRunning("run-key");
     return "run-key";
 }
-function uninstallWindowsAutoStart() {
+async 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 });
+    requestWindowsLauncherStop();
+    try {
+        runDaemon("stop", { allowFailure: true });
+        await waitForWindowsLauncherStopAck();
+    }
+    finally {
+        clearWindowsLauncherStopRequest();
+    }
     let removed = false;
     const taskDelete = runChecked("schtasks", ["/Delete", "/TN", WINDOWS_TASK_NAME, "/F"], {
         allowFailure: true,
@@ -229,12 +243,13 @@ function runWindowsTask() {
         throw new Error(result.combinedOutput || "Failed to run service task.");
     }
 }
-function startWindowsAutoStart() {
+async function startWindowsAutoStart() {
     const command = buildWindowsLaunchCommand();
     const runKey = queryWindowsRunKey();
     if (runKey.installed) {
         installWindowsRunKey(command);
-        runWindowsHiddenLauncher();
+        clearWindowsLauncherStopRequest();
+        await ensureWindowsSessionRunning("run-key");
         return "run-key";
     }
     const task = queryWindowsTask();
@@ -242,7 +257,8 @@ function startWindowsAutoStart() {
         throw new Error("Service is not installed. Run 'copilot-hub service install' first.");
     }
     ensureTaskSchedulerAutoStart(command);
-    runWindowsTask();
+    clearWindowsLauncherStopRequest();
+    await ensureWindowsSessionRunning("task");
     return "task";
 }
 function queryWindowsRunKey() {
@@ -460,12 +476,19 @@ function runWindowsHiddenLauncher() {
     if (!fs.existsSync(scriptHost)) {
         throw new Error("Windows Script Host is not available.");
     }
-    const result = runChecked(scriptHost, ["//B", "//Nologo", launcherScriptPath], {
-        allowFailure: true,
+    const child = spawn(scriptHost, ["//B", "//Nologo", launcherScriptPath], {
+        cwd: layout.runtimeDir,
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        shell: false,
+        env: process.env,
     });
-    if (!result.ok) {
-        throw new Error(result.combinedOutput || "Failed to launch hidden Windows service starter.");
+    const pid = normalizePid(child?.pid);
+    if (pid <= 0) {
+        throw new Error("Failed to launch hidden Windows service starter.");
     }
+    child.unref();
 }
 function ensureSystemctl() {
     ensureCommandAvailable("systemctl", ["--version"], "systemd is not available. This command requires Linux with systemd user services.");
@@ -485,6 +508,7 @@ function runDaemon(actionValue, { allowFailure = false } = {}) {
     if (!result.ok && !allowFailure) {
         throw new Error(result.combinedOutput || `Failed to execute daemon action '${actionValue}'.`);
     }
+    return result;
 }
 function runChecked(command, args, { stdio = "pipe", allowFailure = false } = {}) {
     const result = spawnSync(command, args, {
@@ -583,6 +607,153 @@ function ensureWindowsLauncherScript() {
         runtimeDir: layout.runtimeDir,
     });
 }
+async function ensureWindowsSessionRunning(mode) {
+    if (isWindowsHiddenLauncherRunning()) {
+        return;
+    }
+    if (mode === "task") {
+        runWindowsTask();
+    }
+    else {
+        runWindowsHiddenLauncher();
+    }
+    const ready = await waitForWindowsSessionStart();
+    if (!ready) {
+        throw new Error("Windows background service did not start cleanly.");
+    }
+}
+async function stopWindowsAutoStart() {
+    requestWindowsLauncherStop();
+    try {
+        runDaemon("stop", { allowFailure: true });
+        await waitForWindowsLauncherStopAck();
+    }
+    finally {
+        clearWindowsLauncherStopRequest();
+    }
+}
+async function waitForWindowsSessionStart(timeoutMs = WINDOWS_LAUNCHER_STOP_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (getRunningDaemonPid() > 0 || isWindowsHiddenLauncherRunning()) {
+            return true;
+        }
+        await sleep(WINDOWS_LAUNCHER_POLL_INTERVAL_MS);
+    }
+    return getRunningDaemonPid() > 0 || isWindowsHiddenLauncherRunning();
+}
+async function waitForWindowsLauncherStopAck(timeoutMs = WINDOWS_LAUNCHER_STOP_TIMEOUT_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const daemonRunning = getRunningDaemonPid() > 0;
+        const launcherRunning = isWindowsHiddenLauncherRunning();
+        const stopRequested = fs.existsSync(windowsLauncherStopSignalPath);
+        if (!daemonRunning && !launcherRunning && !stopRequested) {
+            return true;
+        }
+        await sleep(WINDOWS_LAUNCHER_POLL_INTERVAL_MS);
+    }
+    return getRunningDaemonPid() <= 0 && !isWindowsHiddenLauncherRunning();
+}
+function requestWindowsLauncherStop() {
+    fs.mkdirSync(path.dirname(windowsLauncherStopSignalPath), { recursive: true });
+    fs.writeFileSync(windowsLauncherStopSignalPath, `${new Date().toISOString()}\n`, "utf8");
+}
+function clearWindowsLauncherStopRequest() {
+    if (!fs.existsSync(windowsLauncherStopSignalPath)) {
+        return;
+    }
+    fs.rmSync(windowsLauncherStopSignalPath, { force: true });
+}
+function getRunningDaemonPid() {
+    const state = readManagedState(daemonStatePath);
+    const pid = normalizePid(state?.pid);
+    if (pid <= 0) {
+        return 0;
+    }
+    if (!isManagedProcessRunning(state)) {
+        try {
+            fs.rmSync(daemonStatePath, { force: true });
+        }
+        catch {
+            // Best effort cleanup only.
+        }
+        return 0;
+    }
+    return pid;
+}
+function readManagedState(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function isWindowsHiddenLauncherRunning() {
+    return listWindowsHiddenLauncherPids().length > 0;
+}
+function listWindowsHiddenLauncherPids() {
+    if (process.platform !== "win32") {
+        return [];
+    }
+    const targetScriptPath = windowsLauncherScriptPath.toLowerCase();
+    const script = [
+        `$target = '${escapePowerShellSingleQuoted(targetScriptPath)}'`,
+        "$matches = @(Get-CimInstance Win32_Process -Filter \"Name = 'wscript.exe'\" -ErrorAction SilentlyContinue | Where-Object {",
+        "  $cmd = [string]$_.CommandLine",
+        "  -not [string]::IsNullOrWhiteSpace($cmd) -and $cmd.ToLower().Contains($target)",
+        "} | ForEach-Object { [int]$_.ProcessId })",
+        "$matches | ConvertTo-Json -Compress",
+    ].join("\n");
+    for (const shell of resolveWindowsPowerShellCandidates()) {
+        const result = spawnSync(shell, ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script], {
+            cwd: layout.runtimeDir,
+            shell: false,
+            windowsHide: true,
+            encoding: "utf8",
+            env: process.env,
+        });
+        if (result.error || result.status !== 0) {
+            continue;
+        }
+        return parsePidListJson(result.stdout);
+    }
+    return [];
+}
+function resolveWindowsPowerShellCandidates() {
+    const systemRoot = String(process.env.SystemRoot ?? process.env.SYSTEMROOT ?? "C:\\Windows");
+    return [
+        path.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+        "powershell.exe",
+    ];
+}
+function parsePidListJson(value) {
+    const text = String(value ?? "").trim();
+    if (!text) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(text);
+        const values = Array.isArray(parsed) ? parsed : [parsed];
+        return values.map((entry) => normalizePid(entry)).filter((pid) => pid > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function escapePowerShellSingleQuoted(value) {
+    return String(value ?? "").replace(/'/g, "''");
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 function escapeXml(value) {
     return String(value ?? "")
         .replace(/&/g, "&amp;")

package/scripts/dist/windows-hidden-launcher.mjs

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+export const WINDOWS_HIDDEN_LAUNCHER_RESTART_DELAY_MS = 5_000;
 export function resolveWindowsScriptHost(env = process.env) {
     const systemRoot = String(env.SystemRoot ?? env.SYSTEMROOT ?? "C:\\Windows").trim();
     const baseDir = systemRoot || "C:\\Windows";
@@ -8,6 +9,9 @@ export function resolveWindowsScriptHost(env = process.env) {
 export function getWindowsHiddenLauncherScriptPath(runtimeDir) {
     return path.win32.join(runtimeDir, "windows-daemon-launcher.vbs");
 }
+export function getWindowsHiddenLauncherStopSignalPath(runtimeDir) {
+    return path.win32.join(runtimeDir, "windows-daemon-launcher.stop");
+}
 export function ensureWindowsHiddenLauncher({ scriptPath, nodeBin, daemonScriptPath, runtimeDir, }) {
     const content = buildWindowsHiddenLauncherContent({
         nodeBin,
@@ -32,13 +36,34 @@ export function buildWindowsHiddenLauncherCommand(scriptPath, env = process.env)
     return `"${scriptHost}" //B //Nologo "${scriptPath}"`;
 }
 export function buildWindowsHiddenLauncherContent({ nodeBin, daemonScriptPath, runtimeDir, }) {
-    const command = buildWindowsCommandLine([nodeBin, daemonScriptPath, "start"]);
+    const command = buildWindowsCommandLine([nodeBin, daemonScriptPath, "run"]);
+    const stopSignalPath = getWindowsHiddenLauncherStopSignalPath(runtimeDir);
     return [
         "Option Explicit",
-        "Dim shell",
+        "Dim shell, fso, command, stopSignalPath, restartDelayMs",
         'Set shell = CreateObject("WScript.Shell")',
+        'Set fso = CreateObject("Scripting.FileSystemObject")',
         `shell.CurrentDirectory = "${escapeVbsString(runtimeDir)}"`,
-        `shell.Run "${escapeVbsString(command)}", 0, False`,
+        `command = "${escapeVbsString(command)}"`,
+        `stopSignalPath = "${escapeVbsString(stopSignalPath)}"`,
+        `restartDelayMs = ${String(WINDOWS_HIDDEN_LAUNCHER_RESTART_DELAY_MS)}`,
+        "Do",
+        "  If fso.FileExists(stopSignalPath) Then",
+        "    On Error Resume Next",
+        "    fso.DeleteFile stopSignalPath, True",
+        "    On Error GoTo 0",
+        "    Exit Do",
+        "  End If",
+        "  shell.Run command, 0, True",
+        "  If fso.FileExists(stopSignalPath) Then",
+        "    On Error Resume Next",
+        "    fso.DeleteFile stopSignalPath, True",
+        "    On Error GoTo 0",
+        "    Exit Do",
+        "  End If",
+        "  WScript.Sleep restartDelayMs",
+        "Loop",
+        "Set fso = Nothing",
         "Set shell = Nothing",
         "",
     ].join("\r\n");

package/scripts/src/codex-version.mts

@@ -1,7 +1,8 @@
 export const codexNpmPackage = "@openai/codex";
 export const minimumCodexVersion = "0.113.0";
-export const maximumCodexVersionExclusive = "0.114.0";
-export const codexInstallPackageSpec = `${codexNpmPackage}@${minimumCodexVersion}`;
+export const preferredCodexVersion = "0.117.0";
+export const maximumCodexVersionExclusive = "0.118.0";
+export const codexInstallPackageSpec = `${codexNpmPackage}@${preferredCodexVersion}`;
 export const codexVersionRequirementLabel = `>= ${minimumCodexVersion} < ${maximumCodexVersionExclusive}`;
 
 type Semver = {

package/scripts/src/daemon.mts

@@ -207,9 +207,7 @@ async function runDaemonLoop() {
 
     failureCount += 1;
     const delay = computeBackoffDelay(failureCount);
-    const reason =
-      firstLine(ensureResult.combinedOutput) ||
-      `supervisor ensure exited with code ${String(ensureResult.status ?? "unknown")}`;
+    const reason = formatRunCheckedFailureReason(ensureResult, "supervisor ensure");
     console.error(
       `[daemon] worker health check failed: ${reason}. Retrying in ${Math.ceil(delay / 1000)}s.`,
     );
@@ -503,6 +501,26 @@ function firstLine(value) {
   return String(line ?? "").trim();
 }
 
+function formatRunCheckedFailureReason(result, label) {
+  const line = firstLine(result?.combinedOutput);
+  if (line) {
+    return line;
+  }
+
+  const spawnErrorCode = String(result?.spawnErrorCode ?? "")
+    .trim()
+    .toUpperCase();
+  if (spawnErrorCode) {
+    return `${label} failed to spawn (${spawnErrorCode})`;
+  }
+
+  if (typeof result?.status === "number") {
+    return `${label} exited with code ${result.status}`;
+  }
+
+  return `${label} exited with code unknown`;
+}
+
 function getErrorMessage(error) {
   if (error instanceof Error && error.message) {
     return error.message;