copilot-hub 0.1.28 → 0.1.30

package/scripts/src/configure.mts

@@ -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);
@@ -18,7 +19,8 @@ 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");
@@ -29,8 +31,8 @@ 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 });
 
@@ -48,18 +50,12 @@ async function main() {
     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();
@@ -82,15 +78,9 @@ async function configureRequiredTokens({ rl, controlPlaneLines }) {
 }
 
 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();
@@ -106,6 +96,29 @@ async function configureAll({ rl, controlPlaneLines }) {
   }
 }
 
+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)) {
@@ -120,80 +133,11 @@ 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: Record<string, string> = {};
-  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/src/daemon.mts

@@ -600,6 +600,34 @@ function detectFatalStartupError(ensureResult) {
     };
   }
 
+  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;
 }
 

package/scripts/src/env-file-utils.mts

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+
+export function ensureEnvTextFile(filePath: string): void {
+  if (fs.existsSync(filePath)) {
+    return;
+  }
+  fs.mkdirSync(requireParentDir(filePath), { recursive: true });
+  fs.writeFileSync(filePath, "", "utf8");
+}
+
+export function readEnvLines(filePath: string): string[] {
+  const content = fs.readFileSync(filePath, "utf8");
+  return content.split(/\r?\n/);
+}
+
+export function writeEnvLines(filePath: string, lines: string[]): void {
+  const normalized = [...lines];
+  if (normalized.length === 0 || normalized[normalized.length - 1] !== "") {
+    normalized.push("");
+  }
+  fs.writeFileSync(filePath, normalized.join("\n"), "utf8");
+}
+
+export function parseEnvMap(lines: string[]): Record<string, string> {
+  const map: Record<string, string> = {};
+  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: string[], key: string, value: unknown): void {
+  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: string[], keys: readonly string[]): boolean {
+  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: unknown): string {
+  return String(value ?? "")
+    .replace(/[\r\n]/g, "")
+    .trim();
+}
+
+function unquote(value: string): string {
+  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: string): string {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function requireParentDir(filePath: string): string {
+  const parts = String(filePath ?? "").split(/[\\/]/);
+  if (parts.length <= 1) {
+    return ".";
+  }
+  parts.pop();
+  return parts.join("/") || ".";
+}

package/scripts/src/install-layout.mts

@@ -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 type CopilotHubLayout = {
   homeDir: string;
@@ -60,10 +62,44 @@ export function initializeCopilotHubLayout({
 }: {
   repoRoot: string;
   layout: CopilotHubLayout;
-}): { migratedPaths: string[] } {
+}): { migratedPaths: string[]; normalizedEnvPaths: string[] } {
   ensureCopilotHubLayout(layout);
   const migratedPaths = migrateLegacyLayout({ repoRoot, layout });
-  return { migratedPaths };
+  const normalizedEnvPaths = normalizePersistentEnvFiles(layout);
+  return { migratedPaths, normalizedEnvPaths };
+}
+
+export function resetCopilotHubConfig({ layout }: { layout: CopilotHubLayout }): {
+  removedPaths: string[];
+} {
+  const removedPaths: string[] = [];
+
+  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: CopilotHubLayout): void {
@@ -137,6 +173,132 @@ function migrateLegacyLayout({
   return migratedPaths;
 }
 
+function normalizePersistentEnvFiles(layout: CopilotHubLayout): string[] {
+  const normalizedPaths: string[] = [];
+
+  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: string,
+  rules: Array<{ key: string; legacyValues: string[]; wrongResolvedPath: string }>,
+): boolean {
+  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: string | undefined,
+  {
+    legacyValues,
+    wrongResolvedPath,
+    configBaseDir,
+  }: {
+    legacyValues: string[];
+    wrongResolvedPath: string;
+    configBaseDir: string;
+  },
+): boolean {
+  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: string): {
   agentEngineEnvPath: string;
   controlPlaneEnvPath: string;
@@ -195,6 +357,14 @@ function normalizePath(value: unknown, pathApi: typeof path.posix | typeof path.
   return normalized ? pathApi.resolve(normalized) : "";
 }
 
+function normalizeForCompare(value: unknown): string {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) {
+    return "";
+  }
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
 function getPathApi(platform: NodeJS.Platform): typeof path.posix | typeof path.win32 {
   return platform === "win32" ? path.win32 : path.posix;
 }

package/scripts/src/supervisor.mts

@@ -354,6 +354,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"),
+        }
+      : {}),
   };
 }
 

package/scripts/test/install-layout.test.mjs

@@ -5,6 +5,7 @@ import path from "node:path";
 import test from "node:test";
 import {
   initializeCopilotHubLayout,
+  resetCopilotHubConfig,
   resolveCopilotHubHomeDir,
   resolveCopilotHubLayout,
 } from "../dist/install-layout.mjs";
@@ -45,8 +46,16 @@ test("initializeCopilotHubLayout migrates legacy env and data files once", () =>
   fs.mkdirSync(path.dirname(legacyControlEnvPath), { recursive: true });
   fs.mkdirSync(path.dirname(legacyEngineDataFile), { recursive: true });
   fs.mkdirSync(path.dirname(legacyPromptStatePath), { recursive: true });
-  fs.writeFileSync(legacyEngineEnvPath, "TELEGRAM_TOKEN_AGENT_1=123:abc\n", "utf8");
-  fs.writeFileSync(legacyControlEnvPath, "HUB_TELEGRAM_TOKEN=456:def\n", "utf8");
+  fs.writeFileSync(
+    legacyEngineEnvPath,
+    ["TELEGRAM_TOKEN_AGENT_1=123:abc", "BOT_REGISTRY_FILE=./data/bot-registry.json", ""].join("\n"),
+    "utf8",
+  );
+  fs.writeFileSync(
+    legacyControlEnvPath,
+    ["HUB_TELEGRAM_TOKEN=456:def", "HUB_DATA_DIR=./data/copilot_hub", ""].join("\n"),
+    "utf8",
+  );
   fs.writeFileSync(legacyEngineDataFile, '{"ok":true}\n', "utf8");
   fs.writeFileSync(legacyEngineLockPath, "stale-lock\n", "utf8");
   fs.writeFileSync(legacyPromptStatePath, '{"decision":"accepted"}\n', "utf8");
@@ -79,4 +88,47 @@ test("initializeCopilotHubLayout migrates legacy env and data files once", () =>
 
   const secondPass = initializeCopilotHubLayout({ repoRoot, layout });
   assert.deepEqual(secondPass.migratedPaths, []);
+  assert.deepEqual(secondPass.normalizedEnvPaths, []);
+});
+
+test("resetCopilotHubConfig removes persisted state but keeps the layout shell", () => {
+  const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), "copilot-hub-reset-"));
+  const layout = resolveCopilotHubLayout({
+    repoRoot,
+    env: {
+      COPILOT_HUB_HOME_DIR: path.join(repoRoot, "user-home"),
+    },
+    homeDirectory: repoRoot,
+  });
+
+  initializeCopilotHubLayout({ repoRoot, layout });
+  fs.writeFileSync(layout.agentEngineEnvPath, "TELEGRAM_TOKEN_AGENT_1=123:abc\n", "utf8");
+  fs.mkdirSync(layout.agentEngineDataDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(layout.agentEngineDataDir, "bot-registry.json"),
+    '{"version":3}\n',
+    "utf8",
+  );
+  fs.mkdirSync(path.join(layout.runtimeDir, "pids"), { recursive: true });
+  fs.writeFileSync(path.join(layout.runtimeDir, "pids", "daemon.json"), '{"pid":1}\n', "utf8");
+  fs.writeFileSync(layout.servicePromptStatePath, '{"decision":"accepted"}\n', "utf8");
+  fs.writeFileSync(
+    path.join(layout.runtimeDir, "windows-daemon-launcher.vbs"),
+    "' launcher\n",
+    "utf8",
+  );
+
+  const reset = resetCopilotHubConfig({ layout });
+
+  assert.ok(reset.removedPaths.includes(layout.configDir));
+  assert.ok(reset.removedPaths.includes(layout.dataDir));
+  assert.ok(reset.removedPaths.includes(layout.logsDir));
+  assert.ok(fs.existsSync(layout.configDir));
+  assert.ok(fs.existsSync(layout.dataDir));
+  assert.ok(fs.existsSync(layout.logsDir));
+  assert.equal(fs.existsSync(layout.agentEngineEnvPath), false);
+  assert.equal(fs.existsSync(path.join(layout.agentEngineDataDir, "bot-registry.json")), false);
+  assert.equal(fs.existsSync(path.join(layout.runtimeDir, "pids")), false);
+  assert.equal(fs.existsSync(layout.servicePromptStatePath), false);
+  assert.equal(fs.existsSync(path.join(layout.runtimeDir, "windows-daemon-launcher.vbs")), true);
 });