bopodev 0.1.8 → 0.1.9

package/dist/index.js

@@ -4,6 +4,11 @@
 import { Command } from "commander";
 import { cancel, outro } from "@clack/prompts";
 
+// src/lib/checks.ts
+import { access as access2, constants, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+
 // src/lib/process.ts
 import { spawn } from "child_process";
 import { access } from "fs/promises";
@@ -105,6 +110,28 @@ async function runDoctorChecks(options) {
     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)}`
   });
+  const instanceRoot = resolveInstanceRoot();
+  const storageRoot = join2(instanceRoot, "data", "storage");
+  const workspaceRoot = join2(instanceRoot, "workspaces");
+  checks.push({
+    label: "Instance root writable",
+    ok: await ensureWritableDirectory(instanceRoot),
+    details: instanceRoot
+  });
+  checks.push({
+    label: "Workspace root writable",
+    ok: await ensureWritableDirectory(workspaceRoot),
+    details: workspaceRoot
+  });
+  checks.push({
+    label: "Storage root writable",
+    ok: await ensureWritableDirectory(storageRoot),
+    details: storageRoot
+  });
+  if (options?.workspaceRoot) {
+    const backfillCheck = await runWorkspaceBackfillDryRunCheck(options.workspaceRoot);
+    checks.push(backfillCheck);
+  }
   return checks;
 }
 async function checkRuntimeCommandHealth(command, cwd) {
@@ -115,6 +142,76 @@ async function checkRuntimeCommandHealth(command, cwd) {
     error: result.ok ? void 0 : result.stderr || `Command '${command}' is not available`
   };
 }
+async function ensureWritableDirectory(path) {
+  try {
+    await mkdir(path, { recursive: true });
+    await access2(path, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveInstanceRoot() {
+  const explicit = process.env.BOPO_INSTANCE_ROOT?.trim();
+  if (explicit) {
+    return resolve2(expandHomePrefix(explicit));
+  }
+  const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix(process.env.BOPO_HOME.trim()) : join2(homedir(), ".bopodev");
+  const instanceId = process.env.BOPO_INSTANCE_ID?.trim() || "default";
+  return resolve2(home, "instances", instanceId);
+}
+function expandHomePrefix(value) {
+  if (value === "~") {
+    return homedir();
+  }
+  if (value.startsWith("~/")) {
+    return resolve2(homedir(), value.slice(2));
+  }
+  return value;
+}
+async function runWorkspaceBackfillDryRunCheck(workspaceRoot) {
+  const result = await runCommandCapture("pnpm", ["--filter", "bopodev-api", "workspaces:backfill"], {
+    cwd: workspaceRoot,
+    env: {
+      ...process.env,
+      BOPO_BACKFILL_DRY_RUN: "1"
+    }
+  });
+  if (!result.ok) {
+    return {
+      label: "Project workspace coverage",
+      ok: false,
+      details: result.stderr.trim() || "Failed to run workspace coverage check."
+    };
+  }
+  const lines = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  const lastLine = lines[lines.length - 1];
+  if (!lastLine) {
+    return {
+      label: "Project workspace coverage",
+      ok: false,
+      details: "Workspace coverage check produced no output."
+    };
+  }
+  try {
+    const parsed = JSON.parse(lastLine);
+    const missing = Number(parsed.missingWorkspaceLocalPath ?? 0);
+    const relative = Number(parsed.relativeWorkspaceLocalPath ?? 0);
+    const scanned = Number(parsed.scannedProjects ?? 0);
+    const ok = missing === 0 && relative === 0;
+    return {
+      label: "Project workspace coverage",
+      ok,
+      details: ok ? `${scanned} projects scanned; all have absolute workspace paths` : `${scanned} projects scanned; ${missing} missing and ${relative} relative workspace path(s)`
+    };
+  } catch {
+    return {
+      label: "Project workspace coverage",
+      ok: false,
+      details: "Workspace coverage check returned invalid JSON."
+    };
+  }
+}
 
 // src/lib/ui.ts
 import color from "picocolors";
@@ -146,8 +243,8 @@ function printSection(title) {
   process.stdout.write(`${color.bold(title)}
 `);
 }
-function printLine(text) {
-  process.stdout.write(`${text}
+function printLine(text2) {
+  process.stdout.write(`${text2}
 `);
 }
 function printDivider() {
@@ -193,10 +290,14 @@ async function runDoctorCommand(cwd) {
 }
 
 // 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 { access as access3, copyFile, readFile, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+import { confirm, isCancel, log, select, spinner, text } from "@clack/prompts";
 import dotenv from "dotenv";
+var DEFAULT_COMPANY_NAME_ENV = "BOPO_DEFAULT_COMPANY_NAME";
+var DEFAULT_COMPANY_ID_ENV = "BOPO_DEFAULT_COMPANY_ID";
+var DEFAULT_PUBLIC_COMPANY_ID_ENV = "NEXT_PUBLIC_DEFAULT_COMPANY_ID";
+var DEFAULT_AGENT_PROVIDER_ENV = "BOPO_DEFAULT_AGENT_PROVIDER";
 var defaultDeps = {
   installDependencies: async (workspaceRoot) => {
     const code = await runCommandStreaming("pnpm", ["install"], { cwd: workspaceRoot });
@@ -217,7 +318,54 @@ var defaultDeps = {
       throw new Error(`db:init failed with exit code ${String(code)}`);
     }
   },
-  startServices: (workspaceRoot) => runCommandStreaming("pnpm", ["start:quiet"], { cwd: workspaceRoot })
+  seedOnboardingDatabase: async (workspaceRoot, input) => {
+    const result = await runCommandCapture("pnpm", ["--filter", "bopodev-api", "onboard:seed"], {
+      cwd: workspaceRoot,
+      env: {
+        ...process.env,
+        [DEFAULT_COMPANY_NAME_ENV]: input.companyName,
+        [DEFAULT_AGENT_PROVIDER_ENV]: input.agentProvider,
+        ...input.companyId ? { [DEFAULT_COMPANY_ID_ENV]: input.companyId } : {},
+        ...input.dbPath ? { BOPO_DB_PATH: input.dbPath } : {}
+      }
+    });
+    if (!result.ok) {
+      const details = [result.stderr, result.stdout].filter((value) => value.trim().length > 0).join("\n").trim();
+      throw new Error(details.length > 0 ? details : `onboard:seed failed with exit code ${String(result.code)}`);
+    }
+    return parseSeedResult(result.stdout);
+  },
+  startServices: (workspaceRoot) => runCommandStreaming("pnpm", ["start:quiet"], { cwd: workspaceRoot }),
+  promptForCompanyName: async () => {
+    const answer = await text({
+      message: "Default company name",
+      placeholder: "Acme AI",
+      validate: (value) => value.trim().length > 0 ? void 0 : "Company name is required."
+    });
+    if (isCancel(answer)) {
+      throw new Error("Onboarding cancelled.");
+    }
+    return answer.trim();
+  },
+  promptForAgentProvider: async () => {
+    const answer = await select({
+      message: "Primary agent framework",
+      initialValue: "codex",
+      options: [
+        { value: "codex", label: "Codex" },
+        { value: "claude_code", label: "Claude Code" },
+        { value: "shell", label: "Shell Runtime" }
+      ]
+    });
+    if (isCancel(answer)) {
+      throw new Error("Onboarding cancelled.");
+    }
+    const provider = parseAgentProvider(answer);
+    if (!provider) {
+      throw new Error("Invalid primary agent framework selected.");
+    }
+    return provider;
+  }
 };
 async function runOnboardFlow(options, deps = defaultDeps) {
   const workspaceRoot = await resolveWorkspaceRoot(options.cwd);
@@ -237,7 +385,7 @@ async function runOnboardFlow(options, deps = defaultDeps) {
       throw new Error("Onboarding cancelled.");
     }
   } else {
-    log.step("`--yes` enabled: using non-interactive defaults.");
+    log.step("`--yes` enabled: using defaults for optional onboarding steps.");
   }
   const shouldInstall = options.forceInstall || !await hasExistingInstall(workspaceRoot);
   if (shouldInstall) {
@@ -252,11 +400,56 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   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 envPath = join3(workspaceRoot, ".env");
+  dotenv.config({ path: envPath });
+  const envValues = await readEnvValues(envPath);
+  let companyName = envValues[DEFAULT_COMPANY_NAME_ENV]?.trim() ?? "";
+  if (companyName.length > 0) {
+    printCheck("ok", "Default company", companyName);
+  } else {
+    companyName = await deps.promptForCompanyName();
+    await updateEnvFile(envPath, { [DEFAULT_COMPANY_NAME_ENV]: companyName });
+    process.env[DEFAULT_COMPANY_NAME_ENV] = companyName;
+    printCheck("ok", "Default company", companyName);
+  }
+  let agentProvider = parseAgentProvider(envValues[DEFAULT_AGENT_PROVIDER_ENV]);
+  if (agentProvider) {
+    printCheck("ok", "Primary agent framework", formatAgentProvider(agentProvider));
+  } else {
+    agentProvider = await deps.promptForAgentProvider();
+    await updateEnvFile(envPath, { [DEFAULT_AGENT_PROVIDER_ENV]: agentProvider });
+    process.env[DEFAULT_AGENT_PROVIDER_ENV] = agentProvider;
+    printCheck("ok", "Primary agent framework", formatAgentProvider(agentProvider));
+  }
   const dbSpin = spinner();
   dbSpin.start("Initializing local database");
   await deps.initializeDatabase(workspaceRoot, process.env.BOPO_DB_PATH);
   dbSpin.stop("Database initialized");
+  const seedSpin = spinner();
+  seedSpin.start("Ensuring default company and CEO agent");
+  const seedResult = await deps.seedOnboardingDatabase(workspaceRoot, {
+    dbPath: process.env.BOPO_DB_PATH,
+    companyName,
+    companyId: envValues[DEFAULT_COMPANY_ID_ENV]?.trim() || void 0,
+    agentProvider
+  });
+  seedSpin.stop("Default company and CEO ready");
+  await updateEnvFile(envPath, {
+    [DEFAULT_COMPANY_NAME_ENV]: seedResult.companyName,
+    [DEFAULT_COMPANY_ID_ENV]: seedResult.companyId,
+    [DEFAULT_PUBLIC_COMPANY_ID_ENV]: seedResult.companyId,
+    [DEFAULT_AGENT_PROVIDER_ENV]: seedResult.ceoProviderType
+  });
+  process.env[DEFAULT_COMPANY_NAME_ENV] = seedResult.companyName;
+  process.env[DEFAULT_COMPANY_ID_ENV] = seedResult.companyId;
+  process.env[DEFAULT_PUBLIC_COMPANY_ID_ENV] = seedResult.companyId;
+  process.env[DEFAULT_AGENT_PROVIDER_ENV] = seedResult.ceoProviderType;
+  printCheck("ok", "Configured company", `${seedResult.companyName}${seedResult.companyCreated ? " (created)" : ""}`);
+  printCheck(
+    "ok",
+    "CEO agent",
+    `${seedResult.ceoCreated ? "Created CEO" : seedResult.ceoMigrated ? "Migrated existing CEO" : "CEO already present"} (${formatAgentProvider(seedResult.ceoProviderType)})`
+  );
   const doctorSpin = spinner();
   doctorSpin.start("Running doctor checks");
   const checks = await deps.runDoctor(workspaceRoot);
@@ -295,8 +488,8 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   };
 }
 async function ensureEnvFile(workspaceRoot) {
-  const envPath = join2(workspaceRoot, ".env");
-  const envExamplePath = join2(workspaceRoot, ".env.example");
+  const envPath = join3(workspaceRoot, ".env");
+  const envExamplePath = join3(workspaceRoot, ".env.example");
   const envExists = await fileExists2(envPath);
   if (envExists) {
     return false;
@@ -308,34 +501,87 @@ async function ensureEnvFile(workspaceRoot) {
   await copyFile(envExamplePath, envPath);
   return true;
 }
+async function readEnvValues(envPath) {
+  const envContent = await readFile(envPath, "utf8");
+  return dotenv.parse(envContent);
+}
+async function updateEnvFile(envPath, updates) {
+  const existingContent = await readFile(envPath, "utf8");
+  const lines = existingContent.split(/\r?\n/);
+  const nextLines = [...lines];
+  for (const [key, value] of Object.entries(updates)) {
+    const serialized = `${key}=${serializeEnvValue(value)}`;
+    const existingIndex = nextLines.findIndex((line) => line.startsWith(`${key}=`));
+    if (existingIndex >= 0) {
+      nextLines[existingIndex] = serialized;
+    } else {
+      const insertionIndex = nextLines.length > 0 && nextLines[nextLines.length - 1] === "" ? nextLines.length - 1 : nextLines.length;
+      nextLines.splice(insertionIndex, 0, serialized);
+    }
+  }
+  const nextContent = nextLines.join("\n");
+  await writeFile(envPath, nextContent.endsWith("\n") ? nextContent : `${nextContent}
+`, "utf8");
+}
+function serializeEnvValue(value) {
+  return /[\s#"'`]/.test(value) ? JSON.stringify(value) : value;
+}
+function parseSeedResult(stdout) {
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  const lastLine = lines[lines.length - 1];
+  if (!lastLine) {
+    throw new Error("onboard:seed did not return a result.");
+  }
+  const parsed = JSON.parse(lastLine);
+  if (typeof parsed.companyId !== "string" || typeof parsed.companyName !== "string" || typeof parsed.companyCreated !== "boolean" || typeof parsed.ceoCreated !== "boolean" || typeof parsed.ceoMigrated !== "boolean" || !parseAgentProvider(parsed.ceoProviderType)) {
+    throw new Error("onboard:seed returned an invalid result.");
+  }
+  return {
+    companyId: parsed.companyId,
+    companyName: parsed.companyName,
+    companyCreated: parsed.companyCreated,
+    ceoCreated: parsed.ceoCreated,
+    ceoProviderType: parseAgentProvider(parsed.ceoProviderType) ?? "shell",
+    ceoMigrated: parsed.ceoMigrated
+  };
+}
+function parseAgentProvider(value) {
+  if (value === "codex" || value === "claude_code" || value === "shell") {
+    return value;
+  }
+  return null;
+}
+function formatAgentProvider(provider) {
+  if (provider === "codex") {
+    return "Codex";
+  }
+  if (provider === "claude_code") {
+    return "Claude Code";
+  }
+  return "Shell Runtime";
+}
 async function fileExists2(path) {
   try {
-    await access2(path);
+    await access3(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");
+  const pnpmModulesFile = join3(workspaceRoot, "node_modules", ".modules.yaml");
+  const packageLockfile = join3(workspaceRoot, "pnpm-lock.yaml");
   return await fileExists2(pnpmModulesFile) && await fileExists2(packageLockfile);
 }
 
 // src/commands/start.ts
-var defaultDeps2 = {
-  resolveWorkspaceRoot,
-  runCommandStreaming,
-  printBanner
-};
-async function runStartCommand(cwd, options, deps = defaultDeps2) {
-  const workspaceRoot = await deps.resolveWorkspaceRoot(cwd);
+async function runStartCommand(cwd, options) {
+  const workspaceRoot = await resolveWorkspaceRoot(cwd);
   if (!workspaceRoot) {
     throw new Error("Could not find a pnpm workspace root. Run this command from inside the Bopodev repo.");
   }
-  deps.printBanner();
   const script = options?.quiet === false ? "start" : "start:quiet";
-  const code = await deps.runCommandStreaming("pnpm", [script], { cwd: workspaceRoot });
+  const code = await runCommandStreaming("pnpm", [script], { cwd: workspaceRoot });
   if (code !== 0) {
     throw new Error(`pnpm ${script} failed with exit code ${String(code)}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bopodev",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "license": "MIT",
   "type": "module",
   "bin": {