bopodev 0.1.28 → 0.1.29

package/dist/index.js

@@ -20,19 +20,41 @@ async function commandExists(command) {
 }
 async function runCommandCapture(command, args, options) {
   return new Promise((resolvePromise) => {
+    const supportsProcessGroups = process.platform !== "win32";
     const child = spawn(command, args, {
       cwd: options?.cwd ?? process.cwd(),
       env: options?.env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"],
-      shell: false
+      shell: false,
+      detached: supportsProcessGroups
     });
     let stdout = "";
     let stderr = "";
+    let settled = false;
+    let timedOut = false;
     const timeoutMs = Math.max(0, Math.floor(options?.timeoutMs ?? 1e4));
+    let killHandle = null;
+    const terminate = (signal) => {
+      if (child.killed || child.exitCode !== null) {
+        return;
+      }
+      try {
+        if (supportsProcessGroups && child.pid) {
+          process.kill(-child.pid, signal);
+        } else {
+          child.kill(signal);
+        }
+      } catch {
+      }
+    };
     const timeoutHandle = timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
       stderr = `${stderr}
 Command '${command}' timed out after ${timeoutMs}ms.`.trim();
-      child.kill("SIGTERM");
+      terminate("SIGTERM");
+      killHandle = setTimeout(() => {
+        terminate("SIGKILL");
+      }, 5e3);
     }, timeoutMs) : null;
     child.stdout.on("data", (chunk) => {
       stdout += String(chunk);
@@ -41,9 +63,16 @@ Command '${command}' timed out after ${timeoutMs}ms.`.trim();
       stderr += String(chunk);
     });
     child.on("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
       if (timeoutHandle) {
         clearTimeout(timeoutHandle);
       }
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
       resolvePromise({
         ok: false,
         code: null,
@@ -53,11 +82,18 @@ ${String(error)}`.trim()
       });
     });
     child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
       if (timeoutHandle) {
         clearTimeout(timeoutHandle);
       }
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
       resolvePromise({
-        ok: code === 0,
+        ok: code === 0 && !timedOut,
         code,
         stdout,
         stderr
@@ -175,41 +211,43 @@ async function runDoctorChecks(options) {
     ok: nodeMajor >= 20,
     details: `Detected ${process.versions.node}; requires >= 20`
   });
-  const pnpmAvailable = await commandExists("pnpm");
+  const codexCommand = process.env.BOPO_CODEX_COMMAND?.trim() || "codex";
+  const openCodeCommand = process.env.BOPO_OPENCODE_COMMAND?.trim() || "opencode";
+  const claudeCommand = process.env.BOPO_CLAUDE_COMMAND?.trim() || "claude";
+  const geminiCommand = process.env.BOPO_GEMINI_COMMAND?.trim() || "gemini";
+  const [pnpmAvailable, gitRuntime, codex, openCode, claude, gemini] = await Promise.all([
+    commandExists("pnpm"),
+    checkRuntimeCommandHealth("git", options?.workspaceRoot),
+    checkRuntimeCommandHealth(codexCommand, options?.workspaceRoot),
+    checkRuntimeCommandHealth(openCodeCommand, options?.workspaceRoot),
+    checkRuntimeCommandHealth(claudeCommand, options?.workspaceRoot),
+    checkRuntimeCommandHealth(geminiCommand, options?.workspaceRoot)
+  ]);
   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 gitRuntime = await checkRuntimeCommandHealth("git", options?.workspaceRoot);
   checks.push({
     label: "Git runtime",
     ok: gitRuntime.available && gitRuntime.exitCode === 0,
     details: gitRuntime.available && gitRuntime.exitCode === 0 ? "Command 'git' is available (required for repo bootstrap/worktree execution)" : gitRuntime.error ?? "Command 'git' is not available"
   });
-  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)}`
   });
-  const openCodeCommand = process.env.BOPO_OPENCODE_COMMAND?.trim() || "opencode";
-  const openCode = await checkRuntimeCommandHealth(openCodeCommand, options?.workspaceRoot);
   checks.push({
     label: "OpenCode runtime",
     ok: openCode.available && openCode.exitCode === 0,
     details: openCode.available && openCode.exitCode === 0 ? `Command '${openCodeCommand}' is available` : openCode.error ?? `Command '${openCodeCommand}' exited with ${String(openCode.exitCode)}`
   });
-  const claudeCommand = process.env.BOPO_CLAUDE_COMMAND?.trim() || "claude";
-  const claude = await checkRuntimeCommandHealth(claudeCommand, options?.workspaceRoot);
   checks.push({
     label: "Claude Code runtime",
     ok: claude.available && claude.exitCode === 0,
     details: claude.available && claude.exitCode === 0 ? `Command '${claudeCommand}' is available` : claude.error ?? `Command '${claudeCommand}' exited with ${String(claude.exitCode)}`
   });
-  const geminiCommand = process.env.BOPO_GEMINI_COMMAND?.trim() || "gemini";
-  const gemini = await checkRuntimeCommandHealth(geminiCommand, options?.workspaceRoot);
   checks.push({
     label: "Gemini runtime",
     ok: gemini.available && gemini.exitCode === 0,
@@ -219,19 +257,24 @@ async function runDoctorChecks(options) {
     const instanceRoot = resolveInstanceRoot2();
     const storageRoot = join2(instanceRoot, "data", "storage");
     const workspaceRoot = join2(instanceRoot, "workspaces");
+    const [instanceRootWritable, workspaceRootWritable, storageRootWritable] = await Promise.all([
+      ensureWritableDirectory(instanceRoot),
+      ensureWritableDirectory(workspaceRoot),
+      ensureWritableDirectory(storageRoot)
+    ]);
     checks.push({
       label: "Instance root writable",
-      ok: await ensureWritableDirectory(instanceRoot),
+      ok: instanceRootWritable,
       details: instanceRoot
     });
     checks.push({
       label: "Workspace root writable",
-      ok: await ensureWritableDirectory(workspaceRoot),
+      ok: workspaceRootWritable,
       details: workspaceRoot
     });
     checks.push({
       label: "Storage root writable",
-      ok: await ensureWritableDirectory(storageRoot),
+      ok: storageRootWritable,
       details: storageRoot
     });
   } catch (error) {
@@ -242,9 +285,11 @@ async function runDoctorChecks(options) {
     });
   }
   if (options?.workspaceRoot) {
-    const driftCheck = await runWorkspacePathDriftCheck(options.workspaceRoot);
+    const [driftCheck, backfillCheck] = await Promise.all([
+      runWorkspacePathDriftCheck(options.workspaceRoot),
+      runWorkspaceBackfillDryRunCheck(options.workspaceRoot)
+    ]);
     checks.push(driftCheck);
-    const backfillCheck = await runWorkspaceBackfillDryRunCheck(options.workspaceRoot);
     checks.push(backfillCheck);
   }
   return checks;
@@ -446,6 +491,78 @@ async function runDoctorCommand(cwd) {
   printSummaryCard([`Summary: ${passed} passed, ${failed} warnings`]);
 }
 
+// src/commands/issue-shell-env.ts
+import process2 from "process";
+function readEnv(name, fallback = "") {
+  return (process2.env[name] ?? fallback).trim();
+}
+function buildActorHeaders() {
+  const token = readEnv("BOPO_ACTOR_TOKEN") || readEnv("BOPODEV_ACTOR_TOKEN");
+  if (token) {
+    return { authorization: `Bearer ${token}` };
+  }
+  return {
+    "x-actor-type": "board",
+    "x-actor-id": "bopodev-cli",
+    "x-actor-companies": "",
+    "x-actor-permissions": ""
+  };
+}
+async function runIssueShellEnvCommand(issueId, options) {
+  const base = options.apiUrl.replace(/\/$/, "");
+  const headers = {
+    "x-company-id": options.companyId,
+    ...buildActorHeaders()
+  };
+  const issueRes = await fetch(`${base}/issues/${encodeURIComponent(issueId)}`, { headers });
+  const issueRaw = await issueRes.json();
+  if (!issueRes.ok || !issueRaw.ok) {
+    throw new Error(
+      !issueRaw.ok && "error" in issueRaw ? String(issueRaw.error) : `Failed to load issue (${issueRes.status})`
+    );
+  }
+  const issue = issueRaw.data;
+  const wsRes = await fetch(`${base}/projects/${encodeURIComponent(issue.projectId)}/workspaces`, { headers });
+  const wsRaw = await wsRes.json();
+  if (!wsRes.ok || !wsRaw.ok) {
+    throw new Error(
+      !wsRaw.ok && "error" in wsRaw ? String(wsRaw.error) : `Failed to load workspaces (${wsRes.status})`
+    );
+  }
+  const workspaces = wsRaw.data;
+  const primary = workspaces.find((w) => w.isPrimary) ?? workspaces[0];
+  const cwd = primary?.cwd?.trim() || "";
+  const env = {
+    BOPODEV_API_BASE_URL: base,
+    BOPODEV_COMPANY_ID: options.companyId,
+    BOPODEV_ISSUE_ID: issue.id,
+    BOPODEV_PROJECT_ID: issue.projectId
+  };
+  if (options.json) {
+    console.log(JSON.stringify({ ...env, suggestedCwd: cwd || null, issueTitle: issue.title }, null, 2));
+    return;
+  }
+  const lines = [
+    `# Issue: ${issue.title}`,
+    `export BOPODEV_API_BASE_URL=${shellQuote(base)}`,
+    `export BOPODEV_COMPANY_ID=${shellQuote(options.companyId)}`,
+    `export BOPODEV_ISSUE_ID=${shellQuote(issue.id)}`,
+    `export BOPODEV_PROJECT_ID=${shellQuote(issue.projectId)}`
+  ];
+  if (cwd) {
+    lines.push(`cd ${shellQuote(cwd)}`);
+  } else {
+    lines.push("# No primary workspace cwd set for this project; set cwd in project workspaces in the UI.");
+  }
+  console.log(lines.join("\n"));
+}
+function shellQuote(value) {
+  if (!/[\s'"\\$`!]/.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
 // src/commands/onboard.ts
 import { access as access3, copyFile, readFile, writeFile } from "fs/promises";
 import { homedir as homedir3 } from "os";
@@ -628,11 +745,19 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   } else {
     printCheck("ok", "Dependencies", "Already installed");
   }
-  const envPath = join3(workspaceRoot, ".env");
-  const preEnvValues = await fileExists2(envPath) ? await readEnvValues(envPath) : {};
   let checks = [];
   let passed = 0;
   let warnings = 0;
+  if (!options.start) {
+    const doctorSpin = spinner();
+    doctorSpin.start("Running doctor checks");
+    checks = await deps.runDoctor(workspaceRoot);
+    doctorSpin.stop("Doctor checks complete");
+    passed = checks.filter((check) => check.ok).length;
+    warnings = checks.length - passed;
+  }
+  const envPath = join3(workspaceRoot, ".env");
+  const preEnvValues = await fileExists2(envPath) ? await readEnvValues(envPath) : {};
   let companyName = preEnvValues[DEFAULT_COMPANY_NAME_ENV]?.trim() ?? "";
   if (companyName.length > 0) {
     printCheck("ok", "Default company", companyName);
@@ -780,12 +905,6 @@ async function runOnboardFlow(options, deps = defaultDeps) {
     );
   }
   if (!options.start) {
-    const doctorSpin = spinner();
-    doctorSpin.start("Running doctor checks");
-    checks = await deps.runDoctor(workspaceRoot);
-    doctorSpin.stop("Doctor checks complete");
-    passed = checks.filter((check) => check.ok).length;
-    warnings = checks.length - passed;
     printCheck("ok", "Doctor", "checks complete");
     printCheck("ok", "Doctor summary", `${passed} passed, ${warnings} warning${warnings === 1 ? "" : "s"}`);
     if (warnings === 0) {
@@ -1205,6 +1324,27 @@ program.command("doctor").description("Run local preflight checks").action(async
     process.exitCode = 1;
   }
 });
+var issueCommand = program.command("issue").description("Issue helpers for terminal workflows");
+issueCommand.command("shell-env <issueId>").description("Print shell exports for BOPODEV_* and cd to the project primary workspace cwd when set").option("--api-url <url>", "API base URL", process.env.BOPODEV_API_URL ?? "http://localhost:4020").option("--company-id <id>", "Company id (default: BOPODEV_COMPANY_ID)").option("--json", "Print JSON instead of shell exports", false).action(
+  async (issueId, opts) => {
+    try {
+      const companyId = (opts.companyId ?? process.env.BOPODEV_COMPANY_ID ?? "").trim();
+      if (!companyId) {
+        cancel("Set --company-id or BOPODEV_COMPANY_ID.");
+        process.exitCode = 1;
+        return;
+      }
+      await runIssueShellEnvCommand(issueId, {
+        apiUrl: opts.apiUrl,
+        companyId,
+        json: opts.json
+      });
+    } catch (error) {
+      cancel(String(error));
+      process.exitCode = 1;
+    }
+  }
+);
 program.command("upgrade").description("Stop local services, apply migrations, verify schema, and optionally restart").option("--no-start", "Only migrate and verify without restarting services").option("--full-logs", "Use full startup logs instead of quiet mode when restarting", false).action(async (options) => {
   try {
     await runUpgradeCommand(process.cwd(), {

package/package.json

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