copilot-hub 0.1.0

package/scripts/configure.mjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+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";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, "..");
+
+const engineEnvPath = path.join(repoRoot, "apps", "agent-engine", ".env");
+const engineExamplePath = path.join(repoRoot, "apps", "agent-engine", ".env.example");
+const controlPlaneEnvPath = path.join(repoRoot, "apps", "control-plane", ".env");
+const controlPlaneExamplePath = path.join(repoRoot, "apps", "control-plane", ".env.example");
+
+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 rl = createInterface({ input, output });
+
+  try {
+    if (requiredOnly) {
+      await configureRequiredTokens({ rl, controlPlaneLines });
+    } else {
+      await configureAll({ rl, engineLines, controlPlaneLines });
+      console.log("\nSaved:");
+      console.log(`- ${relativeFromRepo(engineEnvPath)}`);
+      console.log(`- ${relativeFromRepo(controlPlaneEnvPath)}`);
+      console.log("\nNext step:");
+      console.log("1) npm run start");
+    }
+  } finally {
+    rl.close();
+  }
+
+  writeLines(engineEnvPath, engineLines);
+  writeLines(controlPlaneEnvPath, controlPlaneLines);
+}
+
+async function configureRequiredTokens({ rl, controlPlaneLines }) {
+  const controlPlaneMap = parseEnvMap(controlPlaneLines);
+
+  const controlPlaneTokenEnvName = nonEmpty(
+    controlPlaneMap.HUB_TELEGRAM_TOKEN_ENV,
+    "HUB_TELEGRAM_TOKEN",
+  );
+  setEnvValue(controlPlaneLines, "HUB_TELEGRAM_TOKEN_ENV", controlPlaneTokenEnvName);
+
+  const postControlPlaneMap = parseEnvMap(controlPlaneLines);
+
+  if (String(postControlPlaneMap[controlPlaneTokenEnvName] ?? "").trim()) {
+    console.log("Required tokens already configured.");
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      "Missing required tokens and no interactive terminal. Run 'npm run configure'.",
+    );
+  }
+
+  console.log("Missing required token. Please enter value:");
+  const value = await askRequired(
+    rl,
+    `Token value for ${controlPlaneTokenEnvName} (control-plane)`,
+  );
+  setEnvValue(controlPlaneLines, controlPlaneTokenEnvName, value);
+  console.log("Required token saved.");
+}
+
+async function configureAll({ rl, engineLines, controlPlaneLines }) {
+  const engineMap = parseEnvMap(engineLines);
+  const controlPlaneMap = parseEnvMap(controlPlaneLines);
+
+  console.log("\nCopilot Hub token configuration\n");
+
+  const controlPlaneTokenEnvDefault = nonEmpty(
+    controlPlaneMap.HUB_TELEGRAM_TOKEN_ENV,
+    "HUB_TELEGRAM_TOKEN",
+  );
+  const controlPlaneTokenEnvName = await ask(
+    rl,
+    "control-plane token variable",
+    controlPlaneTokenEnvDefault,
+  );
+  setEnvValue(controlPlaneLines, "HUB_TELEGRAM_TOKEN_ENV", controlPlaneTokenEnvName);
+  const currentControlPlaneToken = parseEnvMap(controlPlaneLines)[controlPlaneTokenEnvName] ?? "";
+  const newControlPlaneToken = await ask(
+    rl,
+    `Token value for ${controlPlaneTokenEnvName} (control-plane, Enter to keep current)`,
+    "",
+  );
+  if (newControlPlaneToken) {
+    setEnvValue(controlPlaneLines, controlPlaneTokenEnvName, newControlPlaneToken);
+  } else if (!currentControlPlaneToken) {
+    console.log(`- No value set for ${controlPlaneTokenEnvName} yet.`);
+  }
+
+  const configureAgentToken = await askYesNo(rl, "Configure TELEGRAM_TOKEN_AGENT_1 now?", true);
+  if (configureAgentToken) {
+    const currentAgentToken = engineMap.TELEGRAM_TOKEN_AGENT_1 ?? "";
+    const newAgentToken = await ask(
+      rl,
+      "Token value for TELEGRAM_TOKEN_AGENT_1 (agent-engine, Enter to keep current)",
+      "",
+    );
+    if (newAgentToken) {
+      setEnvValue(engineLines, "TELEGRAM_TOKEN_AGENT_1", newAgentToken);
+    } else if (!currentAgentToken) {
+      console.log("- No value set for TELEGRAM_TOKEN_AGENT_1 yet.");
+    }
+  }
+}
+
+function ensureEnvFile(envPath, examplePath) {
+  fs.mkdirSync(path.dirname(envPath), { recursive: true });
+  if (fs.existsSync(envPath)) {
+    return;
+  }
+
+  if (fs.existsSync(examplePath)) {
+    fs.copyFileSync(examplePath, envPath);
+    return;
+  }
+
+  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 ask(rl, label, fallback) {
+  const value = await rl.question(`${label}${fallback ? ` [${fallback}]` : ""}: `);
+  const normalized = String(value ?? "").trim();
+  if (!normalized) {
+    return String(fallback ?? "").trim();
+  }
+  return normalized;
+}
+
+async function askRequired(rl, label) {
+  while (true) {
+    const value = await rl.question(`${label}: `);
+    const normalized = String(value ?? "").trim();
+    if (normalized) {
+      return normalized;
+    }
+    console.log("Value is required.");
+  }
+}
+
+async function askYesNo(rl, label, defaultYes) {
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await rl.question(`${label} ${suffix}: `);
+  const value = String(answer ?? "")
+    .trim()
+    .toLowerCase();
+  if (!value) {
+    return defaultYes;
+  }
+  if (value === "y" || value === "yes") {
+    return true;
+  }
+  if (value === "n" || value === "no") {
+    return false;
+  }
+  return defaultYes;
+}
+
+function relativeFromRepo(filePath) {
+  const relative = path.relative(repoRoot, filePath);
+  return relative || filePath;
+}

package/scripts/ensure-shared-build.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+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 requiredOutputs = [
+  path.join(repoRoot, "packages", "core", "dist", "index.js"),
+  path.join(repoRoot, "packages", "core", "dist", "workspace-policy.js"),
+  path.join(repoRoot, "packages", "contracts", "dist", "index.js"),
+  path.join(repoRoot, "packages", "contracts", "dist", "control-plane.js"),
+  path.join(repoRoot, "apps", "agent-engine", "dist", "index.js"),
+  path.join(repoRoot, "apps", "control-plane", "dist", "copilot-hub.js"),
+];
+
+await main();
+
+async function main() {
+  if (requiredOutputs.every((entry) => fs.existsSync(entry))) {
+    return;
+  }
+
+  console.log("Shared package build artifacts are missing. Running 'npm run build'...");
+  const result = spawnNpm(["run", "build"], {
+    cwd: repoRoot,
+    stdio: "inherit",
+  });
+
+  const code = Number.isInteger(result.status) ? result.status : 1;
+  if (code !== 0) {
+    if (result.error) {
+      throw new Error(formatNpmSpawnError(result.error));
+    }
+
+    throw new Error(
+      [
+        "Failed to build shared packages.",
+        "Install project dependencies with 'npm install', then retry.",
+      ].join("\n"),
+    );
+  }
+
+  const missingAfterBuild = requiredOutputs.filter((entry) => !fs.existsSync(entry));
+  if (missingAfterBuild.length > 0) {
+    throw new Error(
+      [
+        "Shared package build completed but required artifacts are still missing:",
+        ...missingAfterBuild.map((entry) => `- ${path.relative(repoRoot, entry)}`),
+      ].join("\n"),
+    );
+  }
+}
+
+function formatNpmSpawnError(error) {
+  const code = String(error?.code ?? "")
+    .trim()
+    .toUpperCase();
+  if (code === "ENOENT") {
+    return "npm was not found. Install Node.js/npm, then retry.";
+  }
+  if (code === "EPERM") {
+    return "npm cannot be executed (EPERM). Check permissions.";
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return `Failed to execute 'npm run build': ${firstLine(message)}`;
+}
+
+function firstLine(value) {
+  return (
+    String(value ?? "")
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .find(Boolean) ?? ""
+  );
+}
+
+function spawnNpm(args, options) {
+  if (process.platform === "win32") {
+    const comspec = process.env.ComSpec || "cmd.exe";
+    const commandLine = ["npm", ...args].join(" ");
+    return spawnSync(comspec, ["/d", "/s", "/c", commandLine], {
+      ...options,
+      shell: false,
+    });
+  }
+
+  return spawnSync("npm", args, {
+    ...options,
+    shell: false,
+  });
+}

package/scripts/run-node-tests.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+
+const targetDirArg = String(process.argv[2] ?? "dist/test").trim() || "dist/test";
+const targetDir = path.resolve(process.cwd(), targetDirArg);
+
+if (!fs.existsSync(targetDir)) {
+  console.error(`Test directory not found: ${targetDir}`);
+  process.exit(1);
+}
+
+const testFiles = listTestFiles(targetDir);
+if (testFiles.length === 0) {
+  console.error(`No test files found under: ${targetDir}`);
+  process.exit(1);
+}
+
+const result = spawnSync(process.execPath, ["--test", ...testFiles], {
+  stdio: "inherit",
+  shell: false,
+});
+
+const code = Number.isInteger(result.status) ? result.status : 1;
+process.exit(code);
+
+function listTestFiles(rootDir) {
+  const out = [];
+  walk(rootDir, out);
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
+function walk(dirPath, out) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolutePath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      walk(absolutePath, out);
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!entry.name.endsWith(".test.js")) {
+      continue;
+    }
+    out.push(absolutePath);
+  }
+}