bopodev 0.1.27 → 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,10 +491,82 @@ 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";
-import { join as join3, resolve as resolve3 } from "path";
+import { basename, dirname, join as join3, resolve as resolve3 } 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";
@@ -460,6 +577,8 @@ var DEFAULT_AGENT_MODEL_ENV = "BOPO_DEFAULT_AGENT_MODEL";
 var DEFAULT_TEMPLATE_ENV = "BOPO_DEFAULT_TEMPLATE_ID";
 var DEFAULT_DEPLOYMENT_MODE_ENV = "BOPO_DEPLOYMENT_MODE";
 var DEFAULT_ENV_TEMPLATE = "NEXT_PUBLIC_API_URL=http://localhost:4020\n";
+var DB_INIT_TIMEOUT_MS = 12e4;
+var ONBOARD_SEED_TIMEOUT_MS = 6e4;
 var CLI_ONBOARD_VISIBLE_PROVIDERS = [
   { value: "codex", label: "Codex" },
   { value: "claude_code", label: "Claude Code" },
@@ -483,6 +602,7 @@ var defaultDeps = {
   initializeDatabase: async (workspaceRoot, dbPath) => {
     const result = await runCommandCapture("pnpm", ["--filter", "bopodev-api", "db:init"], {
       cwd: workspaceRoot,
+      timeoutMs: DB_INIT_TIMEOUT_MS,
       env: {
         ...process.env,
         ...dbPath ? { BOPO_DB_PATH: dbPath } : {}
@@ -496,6 +616,7 @@ var defaultDeps = {
   seedOnboardingDatabase: async (workspaceRoot, input) => {
     const result = await runCommandCapture("pnpm", ["--filter", "bopodev-api", "onboard:seed"], {
       cwd: workspaceRoot,
+      timeoutMs: ONBOARD_SEED_TIMEOUT_MS,
       env: {
         ...process.env,
         [DEFAULT_COMPANY_NAME_ENV]: input.companyName,
@@ -624,23 +745,19 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   } else {
     printCheck("ok", "Dependencies", "Already installed");
   }
+  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) : {};
-  const doctorSpin = spinner();
-  doctorSpin.start("Running doctor checks");
-  const checks = await deps.runDoctor(workspaceRoot);
-  doctorSpin.stop("Doctor checks complete");
-  const runtimeAvailability = deriveAvailableAgentProviders(checks);
-  const passed = checks.filter((check) => check.ok).length;
-  const warnings = checks.length - passed;
-  printCheck("ok", "Doctor", "checks complete");
-  printCheck("ok", "Doctor summary", `${passed} passed, ${warnings} warning${warnings === 1 ? "" : "s"}`);
-  if (warnings === 0) {
-    printCheck("ok", "Doctor status", "All checks passed");
-  }
-  for (const check of checks) {
-    printCheck(check.ok ? "ok" : "warn", check.label, check.details);
-  }
   let companyName = preEnvValues[DEFAULT_COMPANY_NAME_ENV]?.trim() ?? "";
   if (companyName.length > 0) {
     printCheck("ok", "Default company", companyName);
@@ -648,7 +765,7 @@ async function runOnboardFlow(options, deps = defaultDeps) {
     companyName = await deps.promptForCompanyName();
     printCheck("ok", "Default company", companyName);
   }
-  const selectableProviders = runtimeAvailability.length > 0 ? runtimeAvailability : CLI_ONBOARD_VISIBLE_PROVIDERS.map((entry) => entry.value);
+  const selectableProviders = CLI_ONBOARD_VISIBLE_PROVIDERS.map((entry) => entry.value);
   const configuredProvider = parseAgentProvider(preEnvValues[DEFAULT_AGENT_PROVIDER_ENV]);
   let agentProvider = configuredProvider ?? selectableProviders[0] ?? "codex";
   const canReuseProvider = Boolean(configuredProvider && selectableProviders.includes(configuredProvider));
@@ -709,7 +826,14 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   }
   dotenv.config({ path: envPath, quiet: true });
   const envValues = await readEnvValues(envPath);
-  const configuredDbPath = normalizeOptionalEnvValue(envValues.BOPO_DB_PATH);
+  const configuredDbPathInfo = await normalizeConfiguredDbPathForOnboarding(normalizeOptionalEnvValue(envValues.BOPO_DB_PATH));
+  const configuredDbPath = configuredDbPathInfo.path;
+  if (configuredDbPathInfo.rewrittenFrom && configuredDbPath) {
+    await updateEnvFile(envPath, {
+      BOPO_DB_PATH: configuredDbPath
+    });
+    printCheck("warn", "Database path", `Updated legacy local DB path to ${configuredDbPath}`);
+  }
   if (configuredDbPath) {
     process.env.BOPO_DB_PATH = configuredDbPath;
   } else {
@@ -780,11 +904,23 @@ async function runOnboardFlow(options, deps = defaultDeps) {
       seedResult.templateApplied ? `Applied ${seedResult.templateId ?? requestedTemplateId}` : `Template not applied (${requestedTemplateId})`
     );
   }
+  if (!options.start) {
+    printCheck("ok", "Doctor", "checks complete");
+    printCheck("ok", "Doctor summary", `${passed} passed, ${warnings} warning${warnings === 1 ? "" : "s"}`);
+    if (warnings === 0) {
+      printCheck("ok", "Doctor status", "All checks passed");
+    }
+    for (const check of checks) {
+      printCheck(check.ok ? "ok" : "warn", check.label, check.details);
+    }
+  } else {
+    printCheck("ok", "Doctor", "Available on demand with `pnpm doctor`.");
+  }
   const dbPathSummary = resolveDbPathSummary(configuredDbPath);
   printSummaryCard([
     `Mode    ${padSummaryValue("local")}`,
     `Deploy  ${padSummaryValue("local_mac")}`,
-    `Doctor  ${padSummaryValue(`${passed} passed, ${warnings} warning${warnings === 1 ? "" : "s"}`)}`,
+    `Doctor  ${padSummaryValue(options.start ? "On demand" : `${passed} passed, ${warnings} warning${warnings === 1 ? "" : "s"}`)}`,
     `Company ${padSummaryValue(`${seedResult.companyName} (${seedResult.companyId})`)}`,
     `Agent   ${padSummaryValue(formatAgentProvider(seedResult.ceoProviderType))}`,
     `Model   ${padSummaryValue(seedResult.ceoRuntimeModel ?? selectedAgentModel ?? "provider default")}`,
@@ -870,6 +1006,28 @@ async function sanitizeBlankDbPathEnvEntry(envPath) {
   await writeFile(envPath, nextContent.endsWith("\n") ? nextContent : `${nextContent}
 `, "utf8");
 }
+async function normalizeConfiguredDbPathForOnboarding(rawValue) {
+  const configuredPath = normalizeOptionalEnvValue(rawValue);
+  if (!configuredPath || !looksLikeLegacyDbFilePath(configuredPath)) {
+    return {
+      path: configuredPath,
+      rewrittenFrom: void 0
+    };
+  }
+  const resolvedPath = resolve3(expandHomePrefix3(configuredPath));
+  const postgresMarker = join3(resolvedPath, "PG_VERSION");
+  if (await fileExists2(postgresMarker)) {
+    return {
+      path: resolvedPath,
+      rewrittenFrom: void 0
+    };
+  }
+  const normalizedPath = join3(dirname(resolvedPath), "postgres");
+  return {
+    path: normalizedPath,
+    rewrittenFrom: configuredPath
+  };
+}
 async function removeEnvKeys(envPath, keys) {
   if (keys.length === 0) {
     return;
@@ -887,34 +1045,13 @@ function normalizeOptionalEnvValue(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
-function deriveAvailableAgentProviders(checks) {
-  const providers = [];
-  for (const check of checks) {
-    if (!check.ok) {
-      continue;
-    }
-    if (check.label === "Codex runtime") {
-      providers.push("codex");
-    }
-    if (check.label === "Claude Code runtime") {
-      providers.push("claude_code");
-    }
-    if (check.label === "Gemini runtime") {
-      providers.push("gemini_cli");
-    }
-    if (check.label === "OpenCode runtime") {
-      providers.push("opencode");
-    }
-  }
-  return Array.from(new Set(providers));
-}
 function resolveDbPathSummary(configuredDbPath) {
   if (configuredDbPath) {
     return resolve3(expandHomePrefix3(configuredDbPath));
   }
   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");
+  return resolve3(home, "instances", instanceId, "db", "postgres");
 }
 function expandHomePrefix3(value) {
   if (value === "~") {
@@ -925,6 +1062,10 @@ function expandHomePrefix3(value) {
   }
   return value;
 }
+function looksLikeLegacyDbFilePath(value) {
+  const name = basename(value).toLowerCase();
+  return name.endsWith(".db");
+}
 function padSummaryValue(value) {
   return `| ${value}`;
 }
@@ -1056,6 +1197,96 @@ async function runStartCommand(cwd, options) {
   }
 }
 
+// src/commands/upgrade.ts
+import { readFile as readFile2 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join as join4, resolve as resolve4 } from "path";
+import dotenv2 from "dotenv";
+var UPGRADE_TIMEOUT_MS = 12e4;
+var UNSTICK_TIMEOUT_MS = 3e4;
+async function runUpgradeCommand(cwd, options) {
+  const workspaceRoot = await resolveWorkspaceRootOrManaged(cwd);
+  if (!workspaceRoot) {
+    throw new Error("Could not find a Bopodev workspace root. Run `bopodev onboard` first.");
+  }
+  printBanner();
+  printSection("bopodev upgrade");
+  printLine(`Workspace: ${workspaceRoot}`);
+  printDivider();
+  const envPath = join4(workspaceRoot, ".env");
+  const envValues = await readEnvValues2(envPath);
+  const configuredDbPath = normalizeOptionalEnvValue2(envValues.BOPO_DB_PATH);
+  const dbPathSummary = resolveDbPathSummary2(configuredDbPath);
+  printCheck("warn", "Backup", `Back up local data before major upgrades if needed: ${dbPathSummary}`);
+  const stopResult = await runCommandCapture("pnpm", ["unstick"], {
+    cwd: workspaceRoot,
+    timeoutMs: UNSTICK_TIMEOUT_MS
+  });
+  if (!stopResult.ok) {
+    throw new Error(renderCommandFailure("pnpm unstick", stopResult.stderr, stopResult.stdout, stopResult.code));
+  }
+  printCheck("ok", "Runtime", "Stopped active local processes");
+  const migrateResult = await runCommandCapture("pnpm", ["db:migrate"], {
+    cwd: workspaceRoot,
+    env: {
+      ...process.env,
+      ...configuredDbPath ? { BOPO_DB_PATH: configuredDbPath } : {}
+    },
+    timeoutMs: UPGRADE_TIMEOUT_MS
+  });
+  if (!migrateResult.ok) {
+    throw new Error(renderCommandFailure("pnpm db:migrate", migrateResult.stderr, migrateResult.stdout, migrateResult.code));
+  }
+  printCheck("ok", "Database", "Migrations applied and schema verified");
+  printSummaryCard([
+    `Mode    | local upgrade`,
+    `DB      | ${dbPathSummary}`,
+    `Status  | migrated`
+  ]);
+  if (options?.start === false) {
+    printSection("Next commands");
+    printLine("- Run: pnpm start:quiet");
+    printLine("- Diagnose: pnpm doctor");
+    return;
+  }
+  printLine("Restarting services after upgrade...");
+  printDivider();
+  await runStartCommand(workspaceRoot, { quiet: options?.quiet !== false });
+}
+async function readEnvValues2(path) {
+  try {
+    const content = await readFile2(path, "utf8");
+    return dotenv2.parse(content);
+  } catch {
+    return {};
+  }
+}
+function normalizeOptionalEnvValue2(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function resolveDbPathSummary2(configuredDbPath) {
+  if (configuredDbPath) {
+    return resolve4(expandHomePrefix4(configuredDbPath));
+  }
+  const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix4(process.env.BOPO_HOME.trim()) : join4(homedir4(), ".bopodev");
+  const instanceId = process.env.BOPO_INSTANCE_ID?.trim() || "default";
+  return resolve4(home, "instances", instanceId, "db", "postgres");
+}
+function expandHomePrefix4(value) {
+  if (value === "~") {
+    return homedir4();
+  }
+  if (value.startsWith("~/")) {
+    return resolve4(homedir4(), value.slice(2));
+  }
+  return value;
+}
+function renderCommandFailure(command, stderr, stdout, code) {
+  const details = [stderr, stdout].filter((value) => value.trim().length > 0).join("\n").trim();
+  return details.length > 0 ? details : `${command} failed with exit code ${String(code)}`;
+}
+
 // src/index.ts
 var program = new Command();
 program.name("bopodev").description("Bopodev CLI");
@@ -1093,4 +1324,39 @@ 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(), {
+      start: options.start,
+      quiet: !options.fullLogs
+    });
+    if (!options.start) {
+      outro("Upgrade finished.");
+    }
+  } catch (error) {
+    cancel(String(error));
+    process.exitCode = 1;
+  }
+});
 void program.parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bopodev",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -26,7 +26,7 @@
     "typescript": "^5.9.2"
   },
   "scripts": {
-    "cli:dev": "tsx src/index.ts",
+    "cli:dev": "node --import 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"