bopodev 0.1.0

package/dist/index.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { cancel, outro } from "@clack/prompts";
+
+// src/lib/process.ts
+import { spawn } from "child_process";
+import { access } from "fs/promises";
+import { join, resolve } from "path";
+async function commandExists(command) {
+  const result = await runCommandCapture(command, ["--version"]);
+  return result.ok;
+}
+async function runCommandCapture(command, args, options) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, args, {
+      cwd: options?.cwd ?? process.cwd(),
+      env: options?.env ?? process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      resolvePromise({
+        ok: false,
+        code: null,
+        stdout,
+        stderr: `${stderr}
+${String(error)}`.trim()
+      });
+    });
+    child.on("close", (code) => {
+      resolvePromise({
+        ok: code === 0,
+        code,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+async function runCommandStreaming(command, args, options) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd: options?.cwd ?? process.cwd(),
+      env: options?.env ?? process.env,
+      stdio: "inherit",
+      shell: false
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolvePromise(code));
+  });
+}
+async function resolveWorkspaceRoot(startDir) {
+  let cursor = resolve(startDir);
+  while (true) {
+    const workspaceFile = join(cursor, "pnpm-workspace.yaml");
+    const packageFile = join(cursor, "package.json");
+    if (await fileExists(workspaceFile) && await fileExists(packageFile)) {
+      return cursor;
+    }
+    const parent = resolve(cursor, "..");
+    if (parent === cursor) {
+      return null;
+    }
+    cursor = parent;
+  }
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/checks.ts
+async function runDoctorChecks(options) {
+  const checks = [];
+  const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+  checks.push({
+    label: "Node.js",
+    ok: nodeMajor >= 20,
+    details: `Detected ${process.versions.node}; requires >= 20`
+  });
+  const pnpmAvailable = await commandExists("pnpm");
+  checks.push({
+    label: "pnpm",
+    ok: pnpmAvailable,
+    details: pnpmAvailable ? "pnpm is available" : "pnpm is not installed or not in PATH"
+  });
+  const codexCommand = process.env.BOPO_CODEX_COMMAND?.trim() || "codex";
+  const codex = await checkRuntimeCommandHealth(codexCommand, options?.workspaceRoot);
+  checks.push({
+    label: "Codex runtime",
+    ok: codex.available && codex.exitCode === 0,
+    details: codex.available && codex.exitCode === 0 ? `Command '${codexCommand}' is available` : codex.error ?? `Command '${codexCommand}' exited with ${String(codex.exitCode)}`
+  });
+  return checks;
+}
+async function checkRuntimeCommandHealth(command, cwd) {
+  const result = await runCommandCapture(command, ["--version"], { cwd });
+  return {
+    available: result.code !== null,
+    exitCode: result.code,
+    error: result.ok ? void 0 : result.stderr || `Command '${command}' is not available`
+  };
+}
+
+// src/lib/ui.ts
+import color from "picocolors";
+function printBanner() {
+  const lines = [
+    "",
+    " ____   ___   ____   ___  ",
+    "| __ ) / _ \\ |  _ \\ / _ \\ ",
+    "|  _ \\| | | || |_) | | | |",
+    "| |_) | |_| ||  __/| |_| |",
+    "|____/ \\___/ |_|    \\___/ ",
+    ""
+  ];
+  for (const line of lines) {
+    process.stdout.write(`${color.cyan(line)}
+`);
+  }
+  process.stdout.write(`${color.dim("Open-source orchestration for autonomous companies")}
+
+`);
+}
+function printSection(title) {
+  process.stdout.write(`${color.bold(title)}
+`);
+}
+function printLine(text) {
+  process.stdout.write(`${text}
+`);
+}
+function printDivider() {
+  process.stdout.write(`${color.dim("----------------------------------------")}
+`);
+}
+function printCheck(state, label, details) {
+  const icon = state === "ok" ? color.green("[ok]") : state === "warn" ? color.yellow("[..]") : color.red("[x]");
+  process.stdout.write(`${icon} ${color.bold(label)}: ${details}
+`);
+}
+function printSummaryCard(lines) {
+  const width = Math.max(...lines.map((line) => line.length), 10) + 2;
+  const top = `+${"-".repeat(width)}+`;
+  process.stdout.write(`${color.dim(top)}
+`);
+  for (const line of lines) {
+    process.stdout.write(`${color.dim("|")} ${line.padEnd(width - 1)}${color.dim("|")}
+`);
+  }
+  process.stdout.write(`${color.dim(top)}
+`);
+}
+
+// src/commands/doctor.ts
+async function runDoctorCommand(cwd) {
+  const workspaceRoot = await resolveWorkspaceRoot(cwd);
+  if (!workspaceRoot) {
+    throw new Error("Could not find a pnpm workspace root. Run this command from inside the BopoHQ repo.");
+  }
+  printBanner();
+  printSection("bopo doctor");
+  printLine(`Workspace: ${workspaceRoot}`);
+  printDivider();
+  const checks = await runDoctorChecks({ workspaceRoot });
+  for (const check of checks) {
+    printCheck(check.ok ? "ok" : "warn", check.label, check.details);
+  }
+  const passed = checks.filter((check) => check.ok).length;
+  const failed = checks.length - passed;
+  printLine("");
+  printSummaryCard([`Summary: ${passed} passed, ${failed} warnings`]);
+}
+
+// src/commands/onboard.ts
+import { access as access2, copyFile } from "fs/promises";
+import { join as join2 } from "path";
+import { confirm, isCancel, log, spinner } from "@clack/prompts";
+import dotenv from "dotenv";
+var defaultDeps = {
+  installDependencies: async (workspaceRoot) => {
+    const code = await runCommandStreaming("pnpm", ["install"], { cwd: workspaceRoot });
+    if (code !== 0) {
+      throw new Error(`pnpm install failed with exit code ${String(code)}`);
+    }
+  },
+  runDoctor: (workspaceRoot) => runDoctorChecks({ workspaceRoot }),
+  initializeDatabase: async (workspaceRoot, dbPath) => {
+    const code = await runCommandStreaming("pnpm", ["--filter", "@bopo/api", "db:init"], {
+      cwd: workspaceRoot,
+      env: {
+        ...process.env,
+        ...dbPath ? { BOPO_DB_PATH: dbPath } : {}
+      }
+    });
+    if (code !== 0) {
+      throw new Error(`db:init failed with exit code ${String(code)}`);
+    }
+  },
+  startServices: (workspaceRoot) => runCommandStreaming("pnpm", ["start"], { cwd: workspaceRoot })
+};
+async function runOnboardFlow(options, deps = defaultDeps) {
+  const workspaceRoot = await resolveWorkspaceRoot(options.cwd);
+  if (!workspaceRoot) {
+    throw new Error("Could not find a pnpm workspace root. Run this command from inside the BopoHQ repo.");
+  }
+  printBanner();
+  printSection("bopo onboard");
+  printLine(`Workspace: ${workspaceRoot}`);
+  printDivider();
+  if (!options.yes) {
+    const answer = await confirm({
+      message: "Run onboarding now?",
+      initialValue: true
+    });
+    if (isCancel(answer) || !answer) {
+      throw new Error("Onboarding cancelled.");
+    }
+  } else {
+    log.step("`--yes` enabled: using non-interactive defaults.");
+  }
+  const shouldInstall = options.forceInstall || !await hasExistingInstall(workspaceRoot);
+  if (shouldInstall) {
+    const installSpin = spinner();
+    installSpin.start("Installing dependencies");
+    await deps.installDependencies(workspaceRoot);
+    installSpin.stop("Dependencies installed");
+  } else {
+    log.step("Dependencies already present. Skipping install (use --force-install to reinstall).");
+  }
+  const envSpin = spinner();
+  envSpin.start("Ensuring .env exists");
+  const envCreated = await ensureEnvFile(workspaceRoot);
+  envSpin.stop(envCreated ? "Created .env from .env.example" : ".env already present");
+  dotenv.config({ path: join2(workspaceRoot, ".env") });
+  const dbSpin = spinner();
+  dbSpin.start("Initializing local database");
+  await deps.initializeDatabase(workspaceRoot, process.env.BOPO_DB_PATH);
+  dbSpin.stop("Database initialized");
+  const doctorSpin = spinner();
+  doctorSpin.start("Running doctor checks");
+  const checks = await deps.runDoctor(workspaceRoot);
+  doctorSpin.stop("Doctor checks complete");
+  printDivider();
+  printSection("Doctor");
+  for (const check of checks) {
+    printCheck(check.ok ? "ok" : "warn", check.label, check.details);
+  }
+  const passed = checks.filter((check) => check.ok).length;
+  const failed = checks.length - passed;
+  printLine("");
+  printSummaryCard([
+    `Summary: ${passed} passed, ${failed} warnings`,
+    `Web URL: http://127.0.0.1:4010`,
+    `API URL: http://127.0.0.1:4020`
+  ]);
+  printLine("");
+  if (options.start) {
+    printSection("Starting services");
+    printLine("Running `pnpm start` (production mode)...");
+    printDivider();
+    await deps.startServices(workspaceRoot);
+  } else {
+    printSection("Next commands");
+    printLine("- Run: pnpm start");
+    printLine("- Diagnose: bopo doctor");
+  }
+  return {
+    workspaceRoot,
+    envCreated,
+    dbInitialized: true,
+    checks
+  };
+}
+async function ensureEnvFile(workspaceRoot) {
+  const envPath = join2(workspaceRoot, ".env");
+  const envExamplePath = join2(workspaceRoot, ".env.example");
+  const envExists = await fileExists2(envPath);
+  if (envExists) {
+    return false;
+  }
+  const envExampleExists = await fileExists2(envExamplePath);
+  if (!envExampleExists) {
+    throw new Error("Missing .env.example in workspace root.");
+  }
+  await copyFile(envExamplePath, envPath);
+  return true;
+}
+async function fileExists2(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasExistingInstall(workspaceRoot) {
+  const pnpmModulesFile = join2(workspaceRoot, "node_modules", ".modules.yaml");
+  const packageLockfile = join2(workspaceRoot, "pnpm-lock.yaml");
+  return await fileExists2(pnpmModulesFile) && await fileExists2(packageLockfile);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("bopo").description("BopoHQ CLI");
+program.command("onboard").description("Install, configure, and start BopoHQ locally").option("--yes", "Run non-interactively using defaults", false).option("--force-install", "Force reinstall dependencies even if already installed", false).option("--no-start", "Run setup and doctor checks without starting services").action(async (options) => {
+  try {
+    await runOnboardFlow({
+      cwd: process.cwd(),
+      yes: options.yes,
+      start: options.start,
+      forceInstall: options.forceInstall
+    });
+    if (!options.start) {
+      outro("Onboarding finished.");
+    }
+  } catch (error) {
+    cancel(String(error));
+    process.exitCode = 1;
+  }
+});
+program.command("doctor").description("Run local preflight checks").action(async () => {
+  try {
+    await runDoctorCommand(process.cwd());
+    outro("Doctor finished.");
+  } catch (error) {
+    cancel(String(error));
+    process.exitCode = 1;
+  }
+});
+void program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "bopodev",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "bopodev": "./dist/index.js",
+    "bopo": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "cli:dev": "tsx src/index.ts",
+    "build": "tsup src/index.ts --format esm --platform node --target node20 --out-dir dist",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "commander": "^13.1.0",
+    "dotenv": "^17.0.1",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  }
+}