bopodev 0.1.22 → 0.1.23

package/dist/index.js

@@ -6,12 +6,13 @@ import { cancel, outro } from "@clack/prompts";
 
 // src/lib/checks.ts
 import { access as access2, constants, stat } from "fs/promises";
-import { homedir } from "os";
+import { homedir as homedir2 } 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";
+import { access, mkdir } from "fs/promises";
+import { homedir } from "os";
 import { join, resolve } from "path";
 async function commandExists(command) {
   const result = await runCommandCapture(command, ["--version"]);
@@ -91,6 +92,70 @@ async function resolveWorkspaceRoot(startDir) {
     cursor = parent;
   }
 }
+async function resolveWorkspaceRootOrManaged(startDir, options) {
+  const directWorkspace = await resolveWorkspaceRoot(startDir);
+  if (directWorkspace) {
+    return directWorkspace;
+  }
+  const managedWorkspace = resolveManagedWorkspacePath();
+  const managedResolved = await resolveWorkspaceRoot(managedWorkspace);
+  if (managedResolved) {
+    return managedResolved;
+  }
+  if (!options?.bootstrapIfMissing) {
+    return null;
+  }
+  await bootstrapManagedWorkspace(managedWorkspace);
+  return await resolveWorkspaceRoot(managedWorkspace);
+}
+function resolveManagedWorkspacePath() {
+  if (process.env.BOPO_CLI_WORKSPACE_ROOT?.trim()) {
+    return resolve(expandHomePrefix(process.env.BOPO_CLI_WORKSPACE_ROOT.trim()));
+  }
+  const instanceRoot = resolveInstanceRoot();
+  return join(instanceRoot, "workspace", "bopodev");
+}
+async function bootstrapManagedWorkspace(workspacePath) {
+  const parent = resolve(workspacePath, "..");
+  await mkdir(parent, { recursive: true });
+  if (await fileExists(workspacePath)) {
+    const managedResolved = await resolveWorkspaceRoot(workspacePath);
+    if (managedResolved) {
+      return;
+    }
+    throw new Error(
+      `Managed workspace path exists but is not a valid Bopodev workspace: ${workspacePath}
+Set BOPO_CLI_WORKSPACE_ROOT to another empty path or remove the existing directory and rerun onboarding.`
+    );
+  }
+  const repository = process.env.BOPO_REPO_URL?.trim() || "https://github.com/dkrusenstrahle/bopodev.git";
+  const requestedRef = process.env.BOPO_REPO_REF?.trim();
+  const cloneArgs = requestedRef ? ["clone", "--depth", "1", "--branch", requestedRef, repository, workspacePath] : ["clone", "--depth", "1", repository, workspacePath];
+  const cloneResult = await runCommandCapture("git", cloneArgs, { timeoutMs: 18e4 });
+  if (!cloneResult.ok) {
+    const details = [cloneResult.stderr, cloneResult.stdout].filter((value) => value.trim().length > 0).join("\n").trim();
+    throw new Error(
+      details.length > 0 ? details : `Failed to bootstrap managed workspace from ${repository} (exit code: ${String(cloneResult.code)}).`
+    );
+  }
+}
+function resolveInstanceRoot() {
+  if (process.env.BOPO_INSTANCE_ROOT?.trim()) {
+    return resolve(expandHomePrefix(process.env.BOPO_INSTANCE_ROOT.trim()));
+  }
+  const bopoHome = process.env.BOPO_HOME?.trim() ? expandHomePrefix(process.env.BOPO_HOME.trim()) : join(homedir(), ".bopodev");
+  const instanceId = process.env.BOPO_INSTANCE_ID?.trim() || "default";
+  return resolve(bopoHome, "instances", instanceId);
+}
+function expandHomePrefix(value) {
+  if (value === "~") {
+    return homedir();
+  }
+  if (value.startsWith("~/")) {
+    return resolve(homedir(), value.slice(2));
+  }
+  return value;
+}
 async function fileExists(path) {
   try {
     await access(path);
@@ -151,7 +216,7 @@ async function runDoctorChecks(options) {
     details: gemini.available && gemini.exitCode === 0 ? `Command '${geminiCommand}' is available` : gemini.error ?? `Command '${geminiCommand}' exited with ${String(gemini.exitCode)}`
   });
   try {
-    const instanceRoot = resolveInstanceRoot();
+    const instanceRoot = resolveInstanceRoot2();
     const storageRoot = join2(instanceRoot, "data", "storage");
     const workspaceRoot = join2(instanceRoot, "workspaces");
     checks.push({
@@ -200,24 +265,24 @@ async function ensureWritableDirectory(path) {
     return false;
   }
 }
-function resolveInstanceRoot() {
+function resolveInstanceRoot2() {
   const explicit = process.env.BOPO_INSTANCE_ROOT?.trim();
   if (explicit) {
-    return resolve2(expandHomePrefix(explicit));
+    return resolve2(expandHomePrefix2(explicit));
   }
-  const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix(process.env.BOPO_HOME.trim()) : join2(homedir(), ".bopodev");
+  const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix2(process.env.BOPO_HOME.trim()) : join2(homedir2(), ".bopodev");
   const instanceId = process.env.BOPO_INSTANCE_ID?.trim() || "default";
   if (!SAFE_PATH_SEGMENT_RE.test(instanceId)) {
     throw new Error(`Invalid BOPO_INSTANCE_ID '${instanceId}'.`);
   }
   return resolve2(home, "instances", instanceId);
 }
-function expandHomePrefix(value) {
+function expandHomePrefix2(value) {
   if (value === "~") {
-    return homedir();
+    return homedir2();
   }
   if (value.startsWith("~/")) {
-    return resolve2(homedir(), value.slice(2));
+    return resolve2(homedir2(), value.slice(2));
   }
   return value;
 }
@@ -265,7 +330,7 @@ async function runWorkspaceBackfillDryRunCheck(workspaceRoot) {
   }
 }
 async function runWorkspacePathDriftCheck(workspaceRoot) {
-  const instanceRoot = resolveInstanceRoot();
+  const instanceRoot = resolveInstanceRoot2();
   const suspiciousEntries = await detectSuspiciousWorkspaceDirectories(workspaceRoot);
   if (suspiciousEntries.length === 0) {
     return {
@@ -363,9 +428,9 @@ function printSummaryCard(lines) {
 
 // src/commands/doctor.ts
 async function runDoctorCommand(cwd) {
-  const workspaceRoot = await resolveWorkspaceRoot(cwd);
+  const workspaceRoot = await resolveWorkspaceRootOrManaged(cwd);
   if (!workspaceRoot) {
-    throw new Error("Could not find a pnpm workspace root. Run this command from inside the Bopodev repo.");
+    throw new Error("Could not find a Bopodev workspace root. Run `bopodev onboard` first.");
   }
   printBanner();
   printSection("bopodev doctor");
@@ -383,7 +448,7 @@ async function runDoctorCommand(cwd) {
 
 // src/commands/onboard.ts
 import { access as access3, copyFile, readFile, writeFile } from "fs/promises";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 import { join as join3, resolve as resolve3 } from "path";
 import { confirm, isCancel, log, select, spinner, text } from "@clack/prompts";
 import dotenv from "dotenv";
@@ -531,9 +596,9 @@ var defaultDeps = {
   }
 };
 async function runOnboardFlow(options, deps = defaultDeps) {
-  const workspaceRoot = await resolveWorkspaceRoot(options.cwd);
+  const workspaceRoot = await resolveWorkspaceRootOrManaged(options.cwd, { bootstrapIfMissing: true });
   if (!workspaceRoot) {
-    throw new Error("Could not find a pnpm workspace root. Run this command from inside the Bopodev repo.");
+    throw new Error("Could not find or bootstrap a Bopodev workspace root.");
   }
   printBanner();
   printSection("bopodev onboard");
@@ -845,18 +910,18 @@ function deriveAvailableAgentProviders(checks) {
 }
 function resolveDbPathSummary(configuredDbPath) {
   if (configuredDbPath) {
-    return resolve3(expandHomePrefix2(configuredDbPath));
+    return resolve3(expandHomePrefix3(configuredDbPath));
   }
-  const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix2(process.env.BOPO_HOME.trim()) : join3(homedir2(), ".bopodev");
+  const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix3(process.env.BOPO_HOME.trim()) : join3(homedir3(), ".bopodev");
   const instanceId = process.env.BOPO_INSTANCE_ID?.trim() || "default";
   return resolve3(home, "instances", instanceId, "db", "bopodev.db");
 }
-function expandHomePrefix2(value) {
+function expandHomePrefix3(value) {
   if (value === "~") {
-    return homedir2();
+    return homedir3();
   }
   if (value.startsWith("~/")) {
-    return resolve3(homedir2(), value.slice(2));
+    return resolve3(homedir3(), value.slice(2));
   }
   return value;
 }
@@ -980,9 +1045,9 @@ async function hasExistingInstall(workspaceRoot) {
 
 // src/commands/start.ts
 async function runStartCommand(cwd, options) {
-  const workspaceRoot = await resolveWorkspaceRoot(cwd);
+  const workspaceRoot = await resolveWorkspaceRootOrManaged(cwd);
   if (!workspaceRoot) {
-    throw new Error("Could not find a pnpm workspace root. Run this command from inside the Bopodev repo.");
+    throw new Error("Could not find a Bopodev workspace root. Run `bopodev onboard` first.");
   }
   const script = options?.quiet === false ? "start" : "start:quiet";
   const code = await runCommandStreaming("pnpm", [script], { cwd: workspaceRoot });

package/package.json

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