copilot-hub 0.1.21 → 0.1.24

package/scripts/dist/install-layout.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function resolveCopilotHubLayout({ repoRoot, env = process.env, platform = process.platform, homeDirectory = os.homedir(), }) {
+    const pathApi = getPathApi(platform);
+    const homeDir = resolveCopilotHubHomeDir({
+        env,
+        platform,
+        homeDirectory,
+    });
+    const configDir = pathApi.join(homeDir, "config");
+    const dataDir = pathApi.join(homeDir, "data");
+    const logsDir = pathApi.join(homeDir, "logs");
+    const runtimeDir = pathApi.join(homeDir, "runtime");
+    void repoRoot;
+    return {
+        homeDir,
+        configDir,
+        dataDir,
+        logsDir,
+        runtimeDir,
+        agentEngineEnvPath: pathApi.join(configDir, "agent-engine.env"),
+        controlPlaneEnvPath: pathApi.join(configDir, "control-plane.env"),
+        agentEngineDataDir: pathApi.join(dataDir, "agent-engine"),
+        controlPlaneDataDir: pathApi.join(dataDir, "control-plane"),
+        servicePromptStatePath: pathApi.join(runtimeDir, "service-onboarding.json"),
+    };
+}
+export function initializeCopilotHubLayout({ repoRoot, layout, }) {
+    ensureCopilotHubLayout(layout);
+    const migratedPaths = migrateLegacyLayout({ repoRoot, layout });
+    return { migratedPaths };
+}
+export function ensureCopilotHubLayout(layout) {
+    fs.mkdirSync(layout.homeDir, { recursive: true });
+    fs.mkdirSync(layout.configDir, { recursive: true });
+    fs.mkdirSync(layout.dataDir, { recursive: true });
+    fs.mkdirSync(layout.logsDir, { recursive: true });
+    fs.mkdirSync(layout.runtimeDir, { recursive: true });
+}
+export function resolveCopilotHubHomeDir({ env = process.env, platform = process.platform, homeDirectory = os.homedir(), } = {}) {
+    const pathApi = getPathApi(platform);
+    const explicit = normalizePath(env.COPILOT_HUB_HOME_DIR ?? env.COPILOT_HUB_HOME ?? "", pathApi);
+    if (explicit) {
+        return explicit;
+    }
+    if (platform === "win32") {
+        const appData = normalizePath(env.APPDATA ?? "", pathApi);
+        if (appData) {
+            return pathApi.join(appData, "copilot-hub");
+        }
+        return pathApi.join(homeDirectory, "AppData", "Roaming", "copilot-hub");
+    }
+    if (platform === "darwin") {
+        return pathApi.join(homeDirectory, "Library", "Application Support", "copilot-hub");
+    }
+    const xdgConfigHome = normalizePath(env.XDG_CONFIG_HOME ?? "", pathApi);
+    if (xdgConfigHome) {
+        return pathApi.join(xdgConfigHome, "copilot-hub");
+    }
+    return pathApi.join(homeDirectory, ".config", "copilot-hub");
+}
+function migrateLegacyLayout({ repoRoot, layout, }) {
+    const migratedPaths = [];
+    const legacy = resolveLegacyPaths(repoRoot);
+    if (copyFileIfMissing(legacy.agentEngineEnvPath, layout.agentEngineEnvPath)) {
+        migratedPaths.push(layout.agentEngineEnvPath);
+    }
+    if (copyFileIfMissing(legacy.controlPlaneEnvPath, layout.controlPlaneEnvPath)) {
+        migratedPaths.push(layout.controlPlaneEnvPath);
+    }
+    if (copyDirectoryIfMissing(legacy.agentEngineDataDir, layout.agentEngineDataDir)) {
+        migratedPaths.push(layout.agentEngineDataDir);
+    }
+    if (copyDirectoryIfMissing(legacy.controlPlaneDataDir, layout.controlPlaneDataDir)) {
+        migratedPaths.push(layout.controlPlaneDataDir);
+    }
+    if (copyFileIfMissing(legacy.servicePromptStatePath, layout.servicePromptStatePath)) {
+        migratedPaths.push(layout.servicePromptStatePath);
+    }
+    return migratedPaths;
+}
+function resolveLegacyPaths(repoRoot) {
+    return {
+        agentEngineEnvPath: path.join(repoRoot, "apps", "agent-engine", ".env"),
+        controlPlaneEnvPath: path.join(repoRoot, "apps", "control-plane", ".env"),
+        agentEngineDataDir: path.join(repoRoot, "apps", "agent-engine", "data"),
+        controlPlaneDataDir: path.join(repoRoot, "apps", "control-plane", "data"),
+        servicePromptStatePath: path.join(repoRoot, ".copilot-hub", "service-onboarding.json"),
+    };
+}
+function copyFileIfMissing(sourcePath, targetPath) {
+    if (!fs.existsSync(sourcePath) || fs.existsSync(targetPath)) {
+        return false;
+    }
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.copyFileSync(sourcePath, targetPath);
+    return true;
+}
+function copyDirectoryIfMissing(sourceDir, targetDir) {
+    if (!fs.existsSync(sourceDir) || !fs.statSync(sourceDir).isDirectory()) {
+        return false;
+    }
+    if (directoryHasEntries(targetDir)) {
+        return false;
+    }
+    fs.mkdirSync(path.dirname(targetDir), { recursive: true });
+    fs.cpSync(sourceDir, targetDir, {
+        recursive: true,
+        errorOnExist: false,
+        force: false,
+    });
+    removeVolatileRuntimeFiles(targetDir);
+    return true;
+}
+function directoryHasEntries(directoryPath) {
+    if (!fs.existsSync(directoryPath)) {
+        return false;
+    }
+    try {
+        return fs.readdirSync(directoryPath).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizePath(value, pathApi) {
+    const normalized = String(value ?? "").trim();
+    return normalized ? pathApi.resolve(normalized) : "";
+}
+function getPathApi(platform) {
+    return platform === "win32" ? path.win32 : path.posix;
+}
+function removeVolatileRuntimeFiles(targetDir) {
+    const runtimeLockPath = path.join(targetDir, "runtime.lock");
+    if (fs.existsSync(runtimeLockPath)) {
+        fs.rmSync(runtimeLockPath, { force: true });
+    }
+}

package/scripts/dist/service.mjs

@@ -6,11 +6,16 @@ import path from "node:path";
 import process from "node:process";
 import { 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";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..");
+const layout = resolveCopilotHubLayout({ repoRoot });
+initializeCopilotHubLayout({ repoRoot, layout });
 const nodeBin = process.execPath;
 const daemonScriptPath = path.join(repoRoot, "scripts", "dist", "daemon.mjs");
+const windowsLauncherScriptPath = getWindowsHiddenLauncherScriptPath(layout.runtimeDir);
 const WINDOWS_TASK_NAME = "CopilotHub";
 const WINDOWS_RUN_KEY_PATH = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
 const WINDOWS_RUN_VALUE_NAME = "CopilotHub";
@@ -114,7 +119,13 @@ async function showStatus() {
 }
 async function startService() {
     if (process.platform === "win32") {
-        startWindowsAutoStart();
+        const mode = startWindowsAutoStart();
+        if (mode === "run-key") {
+            console.log("Service started in background (Windows startup registry entry).");
+        }
+        else {
+            console.log("Service started in background (Windows Task Scheduler).");
+        }
         return;
     }
     if (process.platform === "linux") {
@@ -157,7 +168,7 @@ function installWindowsAutoStart() {
         throw new Error(taskCreate.combinedOutput || "Failed to create Windows auto-start task.");
     }
     installWindowsRunKey(command);
-    runDaemon("start");
+    runWindowsHiddenLauncher();
     return "run-key";
 }
 function uninstallWindowsAutoStart() {
@@ -182,6 +193,9 @@ function uninstallWindowsAutoStart() {
     else if (!isRegistryValueNotFoundMessage(runKeyDelete.combinedOutput)) {
         throw new Error(runKeyDelete.combinedOutput || "Failed to remove Windows startup registry entry.");
     }
+    if (fs.existsSync(windowsLauncherScriptPath)) {
+        fs.rmSync(windowsLauncherScriptPath, { force: true });
+    }
     return removed;
 }
 function showWindowsAutoStartStatus() {
@@ -216,12 +230,20 @@ function runWindowsTask() {
     }
 }
 function startWindowsAutoStart() {
+    const command = buildWindowsLaunchCommand();
     const runKey = queryWindowsRunKey();
     if (runKey.installed) {
-        runDaemon("start");
-        return;
+        installWindowsRunKey(command);
+        runWindowsHiddenLauncher();
+        return "run-key";
+    }
+    const task = queryWindowsTask();
+    if (!task.installed) {
+        throw new Error("Service is not installed. Run 'copilot-hub service install' first.");
     }
+    ensureTaskSchedulerAutoStart(command);
     runWindowsTask();
+    return "task";
 }
 function queryWindowsRunKey() {
     const result = runChecked("reg", ["query", WINDOWS_RUN_KEY_PATH, "/v", WINDOWS_RUN_VALUE_NAME], {
@@ -235,6 +257,18 @@ function queryWindowsRunKey() {
     }
     throw new Error(result.combinedOutput || "Failed to query Windows startup registry entry.");
 }
+function queryWindowsTask() {
+    const result = runChecked("schtasks", ["/Query", "/TN", WINDOWS_TASK_NAME], {
+        allowFailure: true,
+    });
+    if (result.ok) {
+        return { installed: true };
+    }
+    if (isNotFoundMessage(result.combinedOutput)) {
+        return { installed: false };
+    }
+    throw new Error(result.combinedOutput || "Failed to query Windows auto-start task.");
+}
 function installWindowsRunKey(command) {
     runChecked("reg", [
         "add",
@@ -248,6 +282,16 @@ function installWindowsRunKey(command) {
         "/f",
     ], { stdio: "pipe" });
 }
+function ensureTaskSchedulerAutoStart(command) {
+    const result = runChecked("schtasks", ["/Create", "/TN", WINDOWS_TASK_NAME, "/SC", "ONLOGON", "/RL", "LIMITED", "/F", "/TR", command], { allowFailure: true });
+    if (result.ok) {
+        return;
+    }
+    if (isNotFoundMessage(result.combinedOutput)) {
+        throw new Error("Service is not installed. Run 'copilot-hub service install' first.");
+    }
+    throw new Error(result.combinedOutput || "Failed to update Windows auto-start task.");
+}
 function installLinuxService() {
     ensureSystemctl();
     const unitPath = getLinuxUnitPath();
@@ -282,7 +326,7 @@ 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.mkdirSync(layout.logsDir, { recursive: true });
     fs.writeFileSync(plistPath, buildMacosPlist(), "utf8");
     stopMacosService({ allowFailure: true });
     const target = getMacosLaunchTarget();
@@ -351,7 +395,7 @@ function buildLinuxUnitContent() {
         "",
         "[Service]",
         "Type=simple",
-        `WorkingDirectory=${repoRoot}`,
+        `WorkingDirectory=${layout.runtimeDir}`,
         `ExecStart="${nodeBin}" "${daemonScriptPath}" run`,
         `ExecStop="${nodeBin}" "${daemonScriptPath}" stop`,
         "Restart=always",
@@ -364,13 +408,13 @@ function buildLinuxUnitContent() {
     ].join("\n");
 }
 function buildMacosPlist() {
-    const stdoutPath = path.join(repoRoot, "logs", "service-launchd.log");
-    const stderrPath = path.join(repoRoot, "logs", "service-launchd.error.log");
+    const stdoutPath = path.join(layout.logsDir, "service-launchd.log");
+    const stderrPath = path.join(layout.logsDir, "service-launchd.error.log");
     const values = {
         label: escapeXml(MACOS_LABEL),
         node: escapeXml(nodeBin),
         script: escapeXml(daemonScriptPath),
-        cwd: escapeXml(repoRoot),
+        cwd: escapeXml(layout.runtimeDir),
         stdoutPath: escapeXml(stdoutPath),
         stderrPath: escapeXml(stderrPath),
     };
@@ -410,6 +454,19 @@ function ensureDaemonScript() {
         ].join("\n"));
     }
 }
+function runWindowsHiddenLauncher() {
+    const launcherScriptPath = ensureWindowsLauncherScript();
+    const scriptHost = resolveWindowsScriptHost(process.env);
+    if (!fs.existsSync(scriptHost)) {
+        throw new Error("Windows Script Host is not available.");
+    }
+    const result = runChecked(scriptHost, ["//B", "//Nologo", launcherScriptPath], {
+        allowFailure: true,
+    });
+    if (!result.ok) {
+        throw new Error(result.combinedOutput || "Failed to launch hidden Windows service starter.");
+    }
+}
 function ensureSystemctl() {
     ensureCommandAvailable("systemctl", ["--version"], "systemd is not available. This command requires Linux with systemd user services.");
 }
@@ -431,7 +488,7 @@ function runDaemon(actionValue, { allowFailure = false } = {}) {
 }
 function runChecked(command, args, { stdio = "pipe", allowFailure = false } = {}) {
     const result = spawnSync(command, args, {
-        cwd: repoRoot,
+        cwd: layout.runtimeDir,
         shell: false,
         stdio,
         windowsHide: true,
@@ -514,7 +571,17 @@ function getErrorMessage(error) {
     return String(error ?? "Unknown error.");
 }
 function buildWindowsLaunchCommand() {
-    return `"${nodeBin}" "${daemonScriptPath}" run`;
+    const launcherScriptPath = ensureWindowsLauncherScript();
+    return buildWindowsHiddenLauncherCommand(launcherScriptPath, process.env);
+}
+function ensureWindowsLauncherScript() {
+    ensureDaemonScript();
+    return ensureWindowsHiddenLauncher({
+        scriptPath: windowsLauncherScriptPath,
+        nodeBin,
+        daemonScriptPath,
+        runtimeDir: layout.runtimeDir,
+    });
 }
 function escapeXml(value) {
     return String(value ?? "")

package/scripts/dist/supervisor.mjs

@@ -4,28 +4,39 @@ import path from "node:path";
 import process from "node:process";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { initializeCopilotHubLayout, resolveCopilotHubLayout } from "./install-layout.mjs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..");
-const runtimeDir = path.join(repoRoot, ".copilot-hub");
+const layout = resolveCopilotHubLayout({ repoRoot });
+initializeCopilotHubLayout({ repoRoot, layout });
+const runtimeDir = layout.runtimeDir;
 const pidsDir = path.join(runtimeDir, "pids");
-const logsDir = path.join(repoRoot, "logs");
+const logsDir = layout.logsDir;
+const servicesRuntimeDir = path.join(runtimeDir, "services");
 const SERVICES = [
     {
         id: "agent-engine",
-        workingDir: path.join(repoRoot, "apps", "agent-engine"),
-        entryScript: "dist/index.js",
+        workingDir: path.join(servicesRuntimeDir, "agent-engine"),
+        entryScript: path.join(repoRoot, "apps", "agent-engine", "dist", "index.js"),
         logFile: path.join(logsDir, "agent-engine.log"),
+        envFilePath: layout.agentEngineEnvPath,
+        dataDir: layout.agentEngineDataDir,
     },
     {
         id: "control-plane",
-        workingDir: path.join(repoRoot, "apps", "control-plane"),
-        entryScript: "dist/copilot-hub.js",
+        workingDir: path.join(servicesRuntimeDir, "control-plane"),
+        entryScript: path.join(repoRoot, "apps", "control-plane", "dist", "copilot-hub.js"),
         logFile: path.join(logsDir, "control-plane.log"),
+        envFilePath: layout.controlPlaneEnvPath,
+        dataDir: layout.controlPlaneDataDir,
     },
 ].map((service) => ({
     ...service,
     pidFile: path.join(pidsDir, `${service.id}.json`),
+    botRegistryFilePath: path.join(service.dataDir, "bot-registry.json"),
+    secretStoreFilePath: path.join(service.dataDir, "secrets.json"),
+    instanceLockFilePath: path.join(service.dataDir, "runtime.lock"),
 }));
 const action = String(process.argv[2] ?? "up")
     .trim()
@@ -66,7 +77,7 @@ async function startServices() {
             for (let index = started.length - 1; index >= 0; index -= 1) {
                 await stopService(started[index]);
             }
-            console.error("One or more services failed to start. Run 'npm run logs' for details.");
+            console.error("One or more services failed to start. Run 'copilot-hub logs' for details.");
             process.exit(1);
         }
         started.push(service);
@@ -129,13 +140,14 @@ async function startService(service, options = {}) {
     const logFd = fs.openSync(service.logFile, "a");
     let child;
     try {
+        const childEnv = buildServiceEnvironment(service);
         child = spawn(process.execPath, [service.entryScript], {
             cwd: service.workingDir,
             detached: true,
             stdio: ["ignore", logFd, logFd],
             windowsHide: true,
             shell: false,
-            env: process.env,
+            env: childEnv,
         });
     }
     finally {
@@ -281,6 +293,21 @@ function ensureRuntimeDirs() {
     fs.mkdirSync(runtimeDir, { recursive: true });
     fs.mkdirSync(pidsDir, { recursive: true });
     fs.mkdirSync(logsDir, { recursive: true });
+    fs.mkdirSync(servicesRuntimeDir, { recursive: true });
+    for (const service of SERVICES) {
+        fs.mkdirSync(service.workingDir, { recursive: true });
+    }
+}
+function buildServiceEnvironment(service) {
+    return {
+        ...process.env,
+        COPILOT_HUB_HOME_DIR: process.env.COPILOT_HUB_HOME_DIR || layout.homeDir,
+        COPILOT_HUB_ENV_PATH: service.envFilePath,
+        BOT_DATA_DIR: service.dataDir,
+        BOT_REGISTRY_FILE: service.botRegistryFilePath,
+        SECRET_STORE_FILE: service.secretStoreFilePath,
+        INSTANCE_LOCK_FILE: service.instanceLockFilePath,
+    };
 }
 function printTail(filePath, lines) {
     if (!fs.existsSync(filePath)) {

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

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+export function resolveWindowsScriptHost(env = process.env) {
+    const systemRoot = String(env.SystemRoot ?? env.SYSTEMROOT ?? "C:\\Windows").trim();
+    const baseDir = systemRoot || "C:\\Windows";
+    return path.win32.join(baseDir, "System32", "wscript.exe");
+}
+export function getWindowsHiddenLauncherScriptPath(runtimeDir) {
+    return path.win32.join(runtimeDir, "windows-daemon-launcher.vbs");
+}
+export function ensureWindowsHiddenLauncher({ scriptPath, nodeBin, daemonScriptPath, runtimeDir, }) {
+    const content = buildWindowsHiddenLauncherContent({
+        nodeBin,
+        daemonScriptPath,
+        runtimeDir,
+    });
+    let current = "";
+    try {
+        current = fs.readFileSync(scriptPath, "utf8");
+    }
+    catch {
+        current = "";
+    }
+    if (current !== content) {
+        fs.mkdirSync(path.dirname(scriptPath), { recursive: true });
+        fs.writeFileSync(scriptPath, content, "utf8");
+    }
+    return scriptPath;
+}
+export function buildWindowsHiddenLauncherCommand(scriptPath, env = process.env) {
+    const scriptHost = resolveWindowsScriptHost(env);
+    return `"${scriptHost}" //B //Nologo "${scriptPath}"`;
+}
+export function buildWindowsHiddenLauncherContent({ nodeBin, daemonScriptPath, runtimeDir, }) {
+    const command = buildWindowsCommandLine([nodeBin, daemonScriptPath, "start"]);
+    return [
+        "Option Explicit",
+        "Dim shell",
+        'Set shell = CreateObject("WScript.Shell")',
+        `shell.CurrentDirectory = "${escapeVbsString(runtimeDir)}"`,
+        `shell.Run "${escapeVbsString(command)}", 0, False`,
+        "Set shell = Nothing",
+        "",
+    ].join("\r\n");
+}
+function buildWindowsCommandLine(args) {
+    return args.map((value) => `"${String(value ?? "")}"`).join(" ");
+}
+function escapeVbsString(value) {
+    return String(value ?? "").replace(/"/g, '""');
+}

package/scripts/src/cli.mts

@@ -6,6 +6,7 @@ import { spawnSync } from "node:child_process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { codexInstallPackageSpec } from "./codex-version.mjs";
+import { initializeCopilotHubLayout, resolveCopilotHubLayout } from "./install-layout.mjs";
 import {
   buildCodexCompatibilityError,
   buildCodexCompatibilityNotice,
@@ -17,12 +18,13 @@ import {
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..");
+const layout = resolveCopilotHubLayout({ repoRoot });
 const packageJsonPath = path.join(repoRoot, "package.json");
-const runtimeDir = path.join(repoRoot, ".copilot-hub");
-const servicePromptStatePath = path.join(runtimeDir, "service-onboarding.json");
+const runtimeDir = layout.runtimeDir;
+const servicePromptStatePath = layout.servicePromptStatePath;
 const nodeBin = process.execPath;
-const agentEngineEnvPath = path.join(repoRoot, "apps", "agent-engine", ".env");
-const controlPlaneEnvPath = path.join(repoRoot, "apps", "control-plane", ".env");
+const agentEngineEnvPath = layout.agentEngineEnvPath;
+const controlPlaneEnvPath = layout.controlPlaneEnvPath;
 const codexInstallCommand = `npm install -g ${codexInstallPackageSpec}`;
 const packageVersion = readPackageVersion();
 
@@ -50,6 +52,8 @@ async function main() {
     return;
   }
 
+  initializeCopilotHubLayout({ repoRoot, layout });
+
   switch (action) {
     case "start": {
       runNode(["scripts/dist/configure.mjs", "--required-only"]);
@@ -114,18 +118,6 @@ async function main() {
       runNode(["scripts/dist/service.mjs", ...rawArgs.slice(1)]);
       return;
     }
-    case "_update_resume": {
-      await resumeAfterUpdate({
-        serviceInstalled: rawArgs.includes("--service-installed"),
-        runningBeforeUpdate: rawArgs.includes("--resume-running"),
-      });
-      return;
-    }
-    case "update":
-    case "upgrade": {
-      await runSelfUpdate();
-      return;
-    }
     default: {
       printUsage();
       process.exit(1);
@@ -279,86 +271,6 @@ async function maybeOfferServiceInstall() {
   writeServicePromptState("accepted");
 }
 
-async function runSelfUpdate() {
-  const serviceInstalled = isServiceAlreadyInstalled();
-  const runningBeforeUpdate = serviceInstalled ? isDaemonRunning() : hasRunningSupervisorWorkers();
-
-  if (serviceInstalled) {
-    const stopService = runNodeCapture(["scripts/dist/service.mjs", "stop"], "inherit");
-    if (!stopService.ok) {
-      console.log("Service stop reported an error. Continuing update attempt.");
-    }
-  } else {
-    const stopLocal = runNodeCapture(["scripts/dist/supervisor.mjs", "down"], "inherit");
-    if (!stopLocal.ok) {
-      console.log("Local stop reported an error. Continuing update attempt.");
-    }
-  }
-
-  const install = runNpm(["install", "-g", "copilot-hub@latest"], "inherit");
-  if (!install.ok) {
-    const detail =
-      firstLine(install.errorMessage) || firstLine(install.stderr) || firstLine(install.stdout);
-    const normalizedDetail = detail.toLowerCase();
-    if (normalizedDetail.includes("ebusy") || normalizedDetail.includes("resource busy")) {
-      throw new Error(
-        [
-          "Update failed because files are locked by another process (EBUSY).",
-          "Close other terminals using copilot-hub, then retry 'copilot-hub update'.",
-        ].join("\n"),
-      );
-    }
-    throw new Error(`Update failed: ${detail || "Unknown npm error."}`);
-  }
-
-  console.log("copilot-hub updated to latest.");
-  const resume = runNodeCapture(
-    [
-      "scripts/dist/cli.mjs",
-      "_update_resume",
-      ...(serviceInstalled ? ["--service-installed"] : ["--local-mode"]),
-      ...(runningBeforeUpdate ? ["--resume-running"] : ["--stopped"]),
-    ],
-    "inherit",
-  );
-  if (!resume.ok) {
-    console.log(
-      "Update completed, but post-update Codex validation or restart failed. Run 'copilot-hub start' manually.",
-    );
-  }
-}
-
-async function resumeAfterUpdate({
-  serviceInstalled,
-  runningBeforeUpdate,
-}: {
-  serviceInstalled: boolean;
-  runningBeforeUpdate: boolean;
-}) {
-  await ensureCompatibleCodexBinary({
-    autoInstall: true,
-    purpose: "update",
-  });
-
-  if (!runningBeforeUpdate) {
-    console.log("Services remain stopped. Run 'copilot-hub start' when ready.");
-    return;
-  }
-
-  if (serviceInstalled) {
-    const startService = runNodeCapture(["scripts/dist/service.mjs", "start"], "inherit");
-    if (!startService.ok) {
-      console.log("Update completed, but service start failed. Run 'copilot-hub start' manually.");
-    }
-    return;
-  }
-
-  const startLocal = runNodeCapture(["scripts/dist/supervisor.mjs", "up"], "inherit");
-  if (!startLocal.ok) {
-    console.log("Update completed, but local start failed. Run 'copilot-hub start' manually.");
-  }
-}
-
 function isServiceSupportedOnCurrentPlatform() {
   return (
     process.platform === "win32" || process.platform === "linux" || process.platform === "darwin"
@@ -377,18 +289,6 @@ function isServiceAlreadyInstalled() {
   return status.ok;
 }
 
-function isDaemonRunning() {
-  const status = runNodeCapture(["scripts/dist/daemon.mjs", "status"], "pipe");
-  const output = String(status.combinedOutput ?? "").toLowerCase();
-  return output.includes("=== daemon ===") && output.includes("running: yes");
-}
-
-function hasRunningSupervisorWorkers() {
-  const status = runNodeCapture(["scripts/dist/supervisor.mjs", "status"], "pipe");
-  const output = String(status.combinedOutput ?? "").toLowerCase();
-  return output.includes("running: yes");
-}
-
 function readServicePromptState() {
   if (!fs.existsSync(servicePromptStatePath)) {
     return null;
@@ -429,7 +329,7 @@ async function ensureCompatibleCodexBinary({
   purpose,
 }: {
   autoInstall: boolean;
-  purpose: "start" | "restart" | "service" | "update";
+  purpose: "start" | "restart" | "service";
 }): Promise<string> {
   const resolved = resolveCodexBinForStart({
     repoRoot,
@@ -501,11 +401,7 @@ async function ensureCompatibleCodexBinary({
   }
 
   if (!shouldInstall) {
-    throw new Error(
-      purpose === "update"
-        ? "Compatible Codex CLI is required before restarting services."
-        : "Compatible Codex CLI is required before starting services.",
-    );
+    throw new Error("Compatible Codex CLI is required before starting services.");
   }
 
   const install = runNpm(["install", "-g", codexInstallPackageSpec], "inherit");
@@ -697,7 +593,6 @@ function printUsage() {
   console.log(
     [
       "Usage: node scripts/dist/cli.mjs <start|stop|restart|status|logs|configure|service|version|help>",
-      "  node scripts/dist/cli.mjs <update|upgrade>",
       "Service management:",
       "  node scripts/dist/cli.mjs service <install|uninstall|status|start|stop|help>",
     ].join("\n"),