copilot-hub 0.1.28 → 0.1.30

package/scripts/dist/configure.mjs

@@ -4,6 +4,7 @@ import path from "node:path";
 import process, { stdin as input, stdout as output } from "node:process";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
+import { parseEnvMap, readEnvLines, setEnvValue, writeEnvLines } from "./env-file-utils.mjs";
 import { initializeCopilotHubLayout, resolveCopilotHubLayout } from "./install-layout.mjs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -15,15 +16,16 @@ const engineExamplePath = path.join(repoRoot, "apps", "agent-engine", ".env.exam
 const controlPlaneEnvPath = layout.controlPlaneEnvPath;
 const controlPlaneExamplePath = path.join(repoRoot, "apps", "control-plane", ".env.example");
 const TELEGRAM_TOKEN_PATTERN = /^\d{5,}:[A-Za-z0-9_-]{20,}$/;
-const DEFAULT_CONTROL_PLANE_TOKEN_ENV = "HUB_TELEGRAM_TOKEN";
+const DEFAULT_CONTROL_PLANE_TOKEN_ENV = "HUB_TELEGRAM_TOKEN_FILE";
+const LEGACY_CONTROL_PLANE_TOKEN_ENV = "HUB_TELEGRAM_TOKEN";
 const args = new Set(process.argv.slice(2));
 const requiredOnly = args.has("--required-only");
 await main();
 async function main() {
     ensureEnvFile(engineEnvPath, engineExamplePath);
     ensureEnvFile(controlPlaneEnvPath, controlPlaneExamplePath);
-    const engineLines = readLines(engineEnvPath);
-    const controlPlaneLines = readLines(controlPlaneEnvPath);
+    const engineLines = readEnvLines(engineEnvPath);
+    const controlPlaneLines = readEnvLines(controlPlaneEnvPath);
     const rl = createInterface({ input, output });
     try {
         if (requiredOnly) {
@@ -40,13 +42,11 @@ async function main() {
     finally {
         rl.close();
     }
-    writeLines(engineEnvPath, engineLines);
-    writeLines(controlPlaneEnvPath, controlPlaneLines);
+    writeEnvLines(engineEnvPath, engineLines);
+    writeEnvLines(controlPlaneEnvPath, controlPlaneLines);
 }
 async function configureRequiredTokens({ rl, controlPlaneLines }) {
-    const controlPlaneMap = parseEnvMap(controlPlaneLines);
-    const controlPlaneTokenEnvName = nonEmpty(controlPlaneMap.HUB_TELEGRAM_TOKEN_ENV, DEFAULT_CONTROL_PLANE_TOKEN_ENV);
-    setEnvValue(controlPlaneLines, "HUB_TELEGRAM_TOKEN_ENV", controlPlaneTokenEnvName);
+    const controlPlaneTokenEnvName = migrateControlPlaneTokenEnv(controlPlaneLines);
     const postControlPlaneMap = parseEnvMap(controlPlaneLines);
     const currentToken = String(postControlPlaneMap[controlPlaneTokenEnvName] ?? "").trim();
     if (isUsableTelegramToken(currentToken)) {
@@ -62,10 +62,8 @@ async function configureRequiredTokens({ rl, controlPlaneLines }) {
     console.log("Required token saved.");
 }
 async function configureAll({ rl, controlPlaneLines }) {
-    const controlPlaneMap = parseEnvMap(controlPlaneLines);
     console.log("\nCopilot Hub control-plane configuration\n");
-    const controlPlaneTokenEnvDefault = nonEmpty(controlPlaneMap.HUB_TELEGRAM_TOKEN_ENV, DEFAULT_CONTROL_PLANE_TOKEN_ENV);
-    setEnvValue(controlPlaneLines, "HUB_TELEGRAM_TOKEN_ENV", controlPlaneTokenEnvDefault);
+    const controlPlaneTokenEnvDefault = migrateControlPlaneTokenEnv(controlPlaneLines);
     const currentControlPlaneToken = String(parseEnvMap(controlPlaneLines)[controlPlaneTokenEnvDefault] ?? "").trim();
     const newControlPlaneToken = currentControlPlaneToken
         ? await askTelegramToken(rl, "Control-plane Telegram token (press Enter to keep current)", true)
@@ -77,6 +75,23 @@ async function configureAll({ rl, controlPlaneLines }) {
         console.log("- Control-plane token left unchanged.");
     }
 }
+function migrateControlPlaneTokenEnv(lines) {
+    const controlPlaneMap = parseEnvMap(lines);
+    const configuredTokenEnvName = nonEmpty(controlPlaneMap.HUB_TELEGRAM_TOKEN_ENV, DEFAULT_CONTROL_PLANE_TOKEN_ENV);
+    const shouldMigrateLegacyName = configuredTokenEnvName === LEGACY_CONTROL_PLANE_TOKEN_ENV;
+    const nextTokenEnvName = shouldMigrateLegacyName
+        ? DEFAULT_CONTROL_PLANE_TOKEN_ENV
+        : configuredTokenEnvName;
+    setEnvValue(lines, "HUB_TELEGRAM_TOKEN_ENV", nextTokenEnvName);
+    if (shouldMigrateLegacyName) {
+        const legacyToken = String(controlPlaneMap[LEGACY_CONTROL_PLANE_TOKEN_ENV] ?? "").trim();
+        const dedicatedToken = String(controlPlaneMap[DEFAULT_CONTROL_PLANE_TOKEN_ENV] ?? "").trim();
+        if (legacyToken && !dedicatedToken) {
+            setEnvValue(lines, DEFAULT_CONTROL_PLANE_TOKEN_ENV, legacyToken);
+        }
+    }
+    return nextTokenEnvName;
+}
 function ensureEnvFile(envPath, examplePath) {
     fs.mkdirSync(path.dirname(envPath), { recursive: true });
     if (fs.existsSync(envPath)) {
@@ -88,67 +103,10 @@ function ensureEnvFile(envPath, examplePath) {
     }
     fs.writeFileSync(envPath, "", "utf8");
 }
-function readLines(filePath) {
-    const content = fs.readFileSync(filePath, "utf8");
-    return content.split(/\r?\n/);
-}
-function writeLines(filePath, lines) {
-    const normalized = [...lines];
-    if (normalized.length === 0 || normalized[normalized.length - 1] !== "") {
-        normalized.push("");
-    }
-    fs.writeFileSync(filePath, normalized.join("\n"), "utf8");
-}
-function parseEnvMap(lines) {
-    const map = {};
-    for (const line of lines) {
-        const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
-        if (!match) {
-            continue;
-        }
-        const key = match[1];
-        const value = unquote(match[2] ?? "");
-        map[key] = value;
-    }
-    return map;
-}
-function setEnvValue(lines, key, value) {
-    const safeValue = sanitizeValue(value);
-    const pattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=`);
-    for (let index = 0; index < lines.length; index += 1) {
-        if (!pattern.test(lines[index])) {
-            continue;
-        }
-        lines[index] = `${key}=${safeValue}`;
-        return;
-    }
-    if (lines.length > 0 && lines[lines.length - 1] !== "") {
-        lines.push("");
-    }
-    lines.push(`${key}=${safeValue}`);
-}
-function sanitizeValue(value) {
-    return String(value ?? "")
-        .replace(/[\r\n]/g, "")
-        .trim();
-}
-function unquote(value) {
-    const raw = String(value ?? "").trim();
-    if (!raw) {
-        return "";
-    }
-    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
-        return raw.slice(1, -1);
-    }
-    return raw;
-}
 function nonEmpty(value, fallback) {
     const normalized = String(value ?? "").trim();
     return normalized || fallback;
 }
-function escapeRegex(value) {
-    return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 async function askRequired(rl, label) {
     while (true) {
         const value = await rl.question(`${label}: `);

package/scripts/dist/daemon.mjs

@@ -508,6 +508,23 @@ function detectFatalStartupError(ensureResult) {
             detectedAt: new Date().toISOString(),
         };
     }
+    const invalidHubTokenLine = findLineContaining(evidenceChunks, (line) => line.includes("hub telegram token in") && line.includes("is invalid"));
+    if (invalidHubTokenLine) {
+        return {
+            reason: invalidHubTokenLine,
+            action: "Run 'copilot-hub configure' to save a valid hub token in the control-plane config, then retry service.",
+            detectedAt: new Date().toISOString(),
+        };
+    }
+    const workspaceRootLine = findLineContaining(evidenceChunks, (line) => line.includes("default_workspace_root must be outside kernel directory") ||
+        line.includes("hub_workspace_root must be outside kernel directory"));
+    if (workspaceRootLine) {
+        return {
+            reason: workspaceRootLine,
+            action: "Set DEFAULT_WORKSPACE_ROOT to a folder outside the copilot-hub installation, then retry service.",
+            detectedAt: new Date().toISOString(),
+        };
+    }
     return null;
 }
 function readLogTail(filePath, maxLines = 120) {

package/scripts/dist/env-file-utils.mjs

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+export function ensureEnvTextFile(filePath) {
+    if (fs.existsSync(filePath)) {
+        return;
+    }
+    fs.mkdirSync(requireParentDir(filePath), { recursive: true });
+    fs.writeFileSync(filePath, "", "utf8");
+}
+export function readEnvLines(filePath) {
+    const content = fs.readFileSync(filePath, "utf8");
+    return content.split(/\r?\n/);
+}
+export function writeEnvLines(filePath, lines) {
+    const normalized = [...lines];
+    if (normalized.length === 0 || normalized[normalized.length - 1] !== "") {
+        normalized.push("");
+    }
+    fs.writeFileSync(filePath, normalized.join("\n"), "utf8");
+}
+export function parseEnvMap(lines) {
+    const map = {};
+    for (const line of lines) {
+        const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
+        if (!match) {
+            continue;
+        }
+        const key = match[1];
+        const value = unquote(match[2] ?? "");
+        map[key] = value;
+    }
+    return map;
+}
+export function setEnvValue(lines, key, value) {
+    const safeValue = sanitizeEnvValue(value);
+    const pattern = new RegExp(`^\\s*${escapeRegex(key)}\\s*=`);
+    for (let index = 0; index < lines.length; index += 1) {
+        if (!pattern.test(lines[index])) {
+            continue;
+        }
+        lines[index] = `${key}=${safeValue}`;
+        return;
+    }
+    if (lines.length > 0 && lines[lines.length - 1] !== "") {
+        lines.push("");
+    }
+    lines.push(`${key}=${safeValue}`);
+}
+export function removeEnvKeys(lines, keys) {
+    const patterns = keys.map((key) => new RegExp(`^\\s*${escapeRegex(key)}\\s*=`));
+    const originalLength = lines.length;
+    const kept = lines.filter((line) => !patterns.some((pattern) => pattern.test(line)));
+    if (kept.length === originalLength) {
+        return false;
+    }
+    lines.splice(0, lines.length, ...kept);
+    return true;
+}
+export function sanitizeEnvValue(value) {
+    return String(value ?? "")
+        .replace(/[\r\n]/g, "")
+        .trim();
+}
+function unquote(value) {
+    const raw = String(value ?? "").trim();
+    if (!raw) {
+        return "";
+    }
+    if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+        return raw.slice(1, -1);
+    }
+    return raw;
+}
+function escapeRegex(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function requireParentDir(filePath) {
+    const parts = String(filePath ?? "").split(/[\\/]/);
+    if (parts.length <= 1) {
+        return ".";
+    }
+    parts.pop();
+    return parts.join("/") || ".";
+}

package/scripts/dist/install-layout.mjs

@@ -2,6 +2,8 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import process from "node:process";
+import { parseEnvMap, readEnvLines, removeEnvKeys, writeEnvLines } from "./env-file-utils.mjs";
 export function resolveCopilotHubLayout({ repoRoot, env = process.env, platform = process.platform, homeDirectory = os.homedir(), }) {
     const pathApi = getPathApi(platform);
     const homeDir = resolveCopilotHubHomeDir({
@@ -30,7 +32,35 @@ export function resolveCopilotHubLayout({ repoRoot, env = process.env, platform
 export function initializeCopilotHubLayout({ repoRoot, layout, }) {
     ensureCopilotHubLayout(layout);
     const migratedPaths = migrateLegacyLayout({ repoRoot, layout });
-    return { migratedPaths };
+    const normalizedEnvPaths = normalizePersistentEnvFiles(layout);
+    return { migratedPaths, normalizedEnvPaths };
+}
+export function resetCopilotHubConfig({ layout }) {
+    const removedPaths = [];
+    for (const target of [layout.configDir, layout.dataDir, layout.logsDir]) {
+        if (!fs.existsSync(target)) {
+            continue;
+        }
+        fs.rmSync(target, { recursive: true, force: true });
+        removedPaths.push(target);
+    }
+    const runtimeTargets = [
+        path.join(layout.runtimeDir, "pids"),
+        path.join(layout.runtimeDir, "services"),
+        path.join(layout.runtimeDir, "last-startup-error.json"),
+        layout.servicePromptStatePath,
+    ];
+    for (const target of runtimeTargets) {
+        if (!fs.existsSync(target)) {
+            continue;
+        }
+        fs.rmSync(target, { recursive: true, force: true });
+        removedPaths.push(target);
+    }
+    ensureCopilotHubLayout(layout);
+    return {
+        removedPaths: removedPaths.sort(),
+    };
 }
 export function ensureCopilotHubLayout(layout) {
     fs.mkdirSync(layout.homeDir, { recursive: true });
@@ -81,6 +111,98 @@ function migrateLegacyLayout({ repoRoot, layout, }) {
     }
     return migratedPaths;
 }
+function normalizePersistentEnvFiles(layout) {
+    const normalizedPaths = [];
+    if (normalizePersistentEnvFile(layout.agentEngineEnvPath, [
+        {
+            key: "BOT_DATA_DIR",
+            legacyValues: ["./data"],
+            wrongResolvedPath: path.join(layout.configDir, "data"),
+        },
+        {
+            key: "BOT_REGISTRY_FILE",
+            legacyValues: ["./data/bot-registry.json"],
+            wrongResolvedPath: path.join(layout.configDir, "data", "bot-registry.json"),
+        },
+        {
+            key: "SECRET_STORE_FILE",
+            legacyValues: ["./data/secrets.json"],
+            wrongResolvedPath: path.join(layout.configDir, "data", "secrets.json"),
+        },
+        {
+            key: "INSTANCE_LOCK_FILE",
+            legacyValues: ["./data/runtime.lock"],
+            wrongResolvedPath: path.join(layout.configDir, "data", "runtime.lock"),
+        },
+    ])) {
+        normalizedPaths.push(layout.agentEngineEnvPath);
+    }
+    if (normalizePersistentEnvFile(layout.controlPlaneEnvPath, [
+        {
+            key: "BOT_DATA_DIR",
+            legacyValues: ["./data"],
+            wrongResolvedPath: path.join(layout.configDir, "data"),
+        },
+        {
+            key: "BOT_REGISTRY_FILE",
+            legacyValues: ["./data/bot-registry.json"],
+            wrongResolvedPath: path.join(layout.configDir, "data", "bot-registry.json"),
+        },
+        {
+            key: "SECRET_STORE_FILE",
+            legacyValues: ["./data/secrets.json"],
+            wrongResolvedPath: path.join(layout.configDir, "data", "secrets.json"),
+        },
+        {
+            key: "INSTANCE_LOCK_FILE",
+            legacyValues: ["./data/runtime.lock"],
+            wrongResolvedPath: path.join(layout.configDir, "data", "runtime.lock"),
+        },
+        {
+            key: "HUB_DATA_DIR",
+            legacyValues: ["./data/copilot_hub"],
+            wrongResolvedPath: path.join(layout.configDir, "data", "copilot_hub"),
+        },
+    ])) {
+        normalizedPaths.push(layout.controlPlaneEnvPath);
+    }
+    return normalizedPaths.sort();
+}
+function normalizePersistentEnvFile(filePath, rules) {
+    if (!fs.existsSync(filePath)) {
+        return false;
+    }
+    const lines = readEnvLines(filePath);
+    const envMap = parseEnvMap(lines);
+    const keysToRemove = rules
+        .filter((rule) => shouldRemoveLegacyManagedPath(envMap[rule.key], {
+        legacyValues: rule.legacyValues,
+        wrongResolvedPath: rule.wrongResolvedPath,
+        configBaseDir: path.dirname(filePath),
+    }))
+        .map((rule) => rule.key);
+    if (keysToRemove.length === 0) {
+        return false;
+    }
+    removeEnvKeys(lines, keysToRemove);
+    writeEnvLines(filePath, lines);
+    return true;
+}
+function shouldRemoveLegacyManagedPath(rawValue, { legacyValues, wrongResolvedPath, configBaseDir, }) {
+    const value = String(rawValue ?? "").trim();
+    if (!value) {
+        return false;
+    }
+    const normalizedValue = normalizeForCompare(value);
+    if (legacyValues.some((entry) => normalizeForCompare(entry) === normalizedValue)) {
+        return true;
+    }
+    if (path.isAbsolute(value)) {
+        return normalizeForCompare(value) === normalizeForCompare(wrongResolvedPath);
+    }
+    return (normalizeForCompare(path.resolve(configBaseDir, value)) ===
+        normalizeForCompare(wrongResolvedPath));
+}
 function resolveLegacyPaths(repoRoot) {
     return {
         agentEngineEnvPath: path.join(repoRoot, "apps", "agent-engine", ".env"),
@@ -129,6 +251,13 @@ function normalizePath(value, pathApi) {
     const normalized = String(value ?? "").trim();
     return normalized ? pathApi.resolve(normalized) : "";
 }
+function normalizeForCompare(value) {
+    const normalized = String(value ?? "").trim();
+    if (!normalized) {
+        return "";
+    }
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
 function getPathApi(platform) {
     return platform === "win32" ? path.win32 : path.posix;
 }

package/scripts/dist/supervisor.mjs

@@ -307,6 +307,11 @@ function buildServiceEnvironment(service) {
         BOT_REGISTRY_FILE: service.botRegistryFilePath,
         SECRET_STORE_FILE: service.secretStoreFilePath,
         INSTANCE_LOCK_FILE: service.instanceLockFilePath,
+        ...(service.id === "control-plane"
+            ? {
+                HUB_DATA_DIR: path.join(service.dataDir, "copilot_hub"),
+            }
+            : {}),
     };
 }
 function printTail(filePath, lines) {

package/scripts/src/cli.mts

@@ -7,7 +7,11 @@ import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { spawnCodexSync } from "./codex-spawn.mjs";
 import { codexInstallPackageSpec } from "./codex-version.mjs";
-import { initializeCopilotHubLayout, resolveCopilotHubLayout } from "./install-layout.mjs";
+import {
+  initializeCopilotHubLayout,
+  resetCopilotHubConfig,
+  resolveCopilotHubLayout,
+} from "./install-layout.mjs";
 import {
   buildCodexCompatibilityError,
   buildCodexCompatibilityNotice,
@@ -35,6 +39,7 @@ const rawArgs = process.argv
   .filter(Boolean);
 const wantsVersion = rawArgs.includes("--version") || rawArgs.includes("-v");
 const wantsHelp = rawArgs.includes("--help") || rawArgs.includes("-h");
+const wantsYes = rawArgs.includes("--yes") || rawArgs.includes("-y");
 
 const action = String(rawArgs[0] ?? "start")
   .trim()
@@ -106,6 +111,13 @@ async function main() {
       runNode(["scripts/dist/configure.mjs"]);
       return;
     }
+    case "reset-config":
+    case "reset_config": {
+      await resetConfig({
+        force: wantsYes,
+      });
+      return;
+    }
     case "service": {
       const serviceAction = String(rawArgs[1] ?? "")
         .trim()
@@ -126,6 +138,56 @@ async function main() {
   }
 }
 
+async function resetConfig({ force }: { force: boolean }): Promise<void> {
+  if (!force) {
+    if (!process.stdin.isTTY) {
+      throw new Error(
+        "reset-config requires confirmation. Re-run with '--yes' in non-interactive mode.",
+      );
+    }
+
+    const rl = createInterface({ input, output });
+    try {
+      const confirmed = await askYesNo(
+        rl,
+        [
+          "Reset Copilot Hub config and runtime state?",
+          "This removes persisted config, bot registry, secrets, logs, and runtime state.",
+          "Agent workspaces are kept.",
+        ].join(" "),
+        false,
+      );
+      if (!confirmed) {
+        console.log("Reset canceled.");
+        return;
+      }
+    } finally {
+      rl.close();
+    }
+  }
+
+  if (isServiceAlreadyInstalled()) {
+    runNodeCapture(["scripts/dist/service.mjs", "stop"], "inherit");
+  } else {
+    runNodeCapture(["scripts/dist/supervisor.mjs", "down"], "inherit");
+  }
+
+  const reset = resetCopilotHubConfig({ layout });
+  initializeCopilotHubLayout({ repoRoot, layout });
+
+  console.log("Copilot Hub config reset completed.");
+  if (reset.removedPaths.length > 0) {
+    console.log("Removed:");
+    for (const removedPath of reset.removedPaths) {
+      console.log(`- ${removedPath}`);
+    }
+  }
+  console.log("Kept:");
+  console.log("- package installation");
+  console.log("- external workspaces (for example Desktop/copilot_workspaces)");
+  console.log("Next step: run 'copilot-hub configure' then 'copilot-hub start'.");
+}
+
 function runNode(scriptArgs) {
   const result = runNodeCapture(scriptArgs, "inherit");
   const code = Number.isInteger(result.status) ? result.status : 1;
@@ -577,6 +639,8 @@ function printUsage() {
   console.log(
     [
       "Usage: node scripts/dist/cli.mjs <start|stop|restart|status|logs|configure|service|version|help>",
+      "Reset persistent state:",
+      "  node scripts/dist/cli.mjs reset-config [--yes]",
       "Service management:",
       "  node scripts/dist/cli.mjs service <install|uninstall|status|start|stop|help>",
     ].join("\n"),