yolobox 0.1.4 → 0.1.6

package/dist/index.js

@@ -7,12 +7,74 @@ import { defineCommand } from "citty";
 // src/lib/docker.ts
 import { execSync, spawn, spawnSync } from "child_process";
 import { existsSync } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/debug.ts
+import { appendFileSync, writeFileSync } from "fs";
 import { join } from "path";
+import pc from "picocolors";
+var _enabled = false;
+var _logPath = null;
+function enable() {
+  _enabled = true;
+  _logPath = join(process.cwd(), "yolobox-debug.log");
+  writeFileSync(
+    _logPath,
+    `yolobox debug log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
+${"=".repeat(60)}
+
+`
+  );
+  return _logPath;
+}
+function isEnabled() {
+  return _enabled;
+}
+function getLogPath() {
+  return _logPath;
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+}
+function log(message) {
+  if (!_enabled || !_logPath) return;
+  appendFileSync(_logPath, `[${timestamp()}] ${message}
+`);
+}
+function error(message) {
+  if (!_enabled || !_logPath) return;
+  const ts = timestamp();
+  appendFileSync(_logPath, `[${ts}] ERROR: ${message}
+`);
+  process.stderr.write(`${pc.dim(`[${ts}]`)} ${pc.red(message)}
+`);
+}
+function logCommand(cmd, args, result) {
+  if (!_enabled || !_logPath) return;
+  const lines = [`$ ${cmd} ${args.join(" ")}`, `exit code: ${result.status}`];
+  if (result.stdout.trim()) lines.push(`stdout:
+${result.stdout.trim()}`);
+  if (result.stderr.trim()) lines.push(`stderr:
+${result.stderr.trim()}`);
+  log(lines.join("\n"));
+  if (result.status !== 0) {
+    const errorOutput = result.stderr.trim() || result.stdout.trim();
+    if (errorOutput) {
+      process.stderr.write(`${pc.dim("[debug]")} ${pc.red(errorOutput)}
+`);
+    }
+  }
+}
+
+// src/lib/docker.ts
 function isDockerRunning() {
+  log("Checking Docker status...");
   try {
     execSync("docker info", { stdio: ["pipe", "pipe", "pipe"] });
+    log("Docker is running");
     return true;
   } catch {
+    error("Docker is not running or not installed");
     return false;
   }
 }
@@ -35,12 +97,15 @@ function resolveDockerImage(options) {
   };
 }
 function imageExists(imageName) {
+  log(`Checking if image exists: ${imageName}`);
   try {
     execSync(`docker image inspect ${imageName}`, {
       stdio: ["pipe", "pipe", "pipe"]
     });
+    log(`Image found: ${imageName}`);
     return true;
   } catch {
+    log(`Image not found locally: ${imageName}`);
     return false;
   }
 }
@@ -79,12 +144,42 @@ function pullImage(imageName, onProgress) {
     proc.stdout?.on("data", handleOutput);
     proc.stderr?.on("data", handleOutput);
     proc.on("close", (code) => {
+      log(
+        `Image pull ${code === 0 ? "succeeded" : "failed"}: ${imageName}`
+      );
       resolve(code === 0);
     });
   });
 }
 function isYoloboxDevRepo(repoRoot) {
-  return existsSync(join(repoRoot, "docker", "Dockerfile"));
+  return existsSync(join2(repoRoot, "docker", "Dockerfile"));
+}
+function canDockerAccessPath(hostFilePath, image) {
+  log(`Checking Docker file access for: ${hostFilePath}`);
+  try {
+    const result = spawnSync(
+      "docker",
+      [
+        "run",
+        "--rm",
+        "-v",
+        `${hostFilePath}:/test-file:ro`,
+        image,
+        "cat",
+        "/test-file"
+      ],
+      { stdio: ["pipe", "pipe", "pipe"], timeout: 1e4 }
+    );
+    const ok = result.status === 0;
+    if (!ok) {
+      log(
+        `Docker cannot access path: ${result.stderr?.toString().trim()}`
+      );
+    }
+    return ok;
+  } catch {
+    return false;
+  }
 }
 function buildDockerArgs(opts) {
   const args = [
@@ -123,20 +218,46 @@ function buildExecArgs(id, command) {
 }
 function startContainer(opts) {
   const args = buildDockerArgs(opts);
+  log(`Starting container yolobox-${opts.id}`);
   const result = spawnSync("docker", args, { stdio: ["pipe", "pipe", "pipe"] });
+  const stdout = result.stdout?.toString() || "";
+  const stderr = result.stderr?.toString() || "";
+  logCommand("docker", args, {
+    status: result.status,
+    stdout,
+    stderr
+  });
   return result.status === 0;
 }
 function restartContainer(id) {
-  const result = spawnSync("docker", ["start", `yolobox-${id}`], {
+  log(`Restarting container yolobox-${id}`);
+  const args = ["start", `yolobox-${id}`];
+  const result = spawnSync("docker", args, {
     stdio: ["pipe", "pipe", "pipe"]
   });
+  const stdout = result.stdout?.toString() || "";
+  const stderr = result.stderr?.toString() || "";
+  logCommand("docker", args, { status: result.status, stdout, stderr });
   return result.status === 0;
 }
 function execInContainer(id, command) {
   const args = buildExecArgs(id, command);
+  log(`Exec in container: docker ${args.join(" ")}`);
   const result = spawnSync("docker", args, { stdio: "inherit" });
+  log(`Exec exited with code ${result.status}`);
   return result.status ?? 1;
 }
+function execInContainerNonInteractive(id, command) {
+  const args = ["exec", `yolobox-${id}`, ...command];
+  log(`Exec (non-interactive) in container: docker ${args.join(" ")}`);
+  const result = spawnSync("docker", args, { stdio: ["pipe", "pipe", "pipe"] });
+  logCommand("docker", args, {
+    status: result.status,
+    stdout: result.stdout?.toString() || "",
+    stderr: result.stderr?.toString() || ""
+  });
+  return result.status === 0;
+}
 function timeAgo(dateStr) {
   const date = new Date(dateStr);
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
@@ -150,7 +271,7 @@ function timeAgo(dateStr) {
 }
 function getWorktreeBranch(repoPath, id) {
   try {
-    const worktreePath = join(repoPath, ".yolobox", id);
+    const worktreePath = join2(repoPath, ".yolobox", id);
     return execSync(`git -C "${worktreePath}" rev-parse --abbrev-ref HEAD`, {
       encoding: "utf-8"
     }).trim();
@@ -180,30 +301,43 @@ function listContainers() {
   }
 }
 function killContainer(id) {
-  const stop = spawnSync("docker", ["stop", `yolobox-${id}`], {
+  log(`Killing container yolobox-${id}`);
+  const stopArgs = ["stop", `yolobox-${id}`];
+  const stop = spawnSync("docker", stopArgs, {
     stdio: ["pipe", "pipe", "pipe"]
   });
+  logCommand("docker", stopArgs, {
+    status: stop.status,
+    stdout: stop.stdout?.toString() || "",
+    stderr: stop.stderr?.toString() || ""
+  });
   if (stop.status !== 0) return false;
-  const rm = spawnSync("docker", ["rm", `yolobox-${id}`], {
+  const rmArgs = ["rm", `yolobox-${id}`];
+  const rm = spawnSync("docker", rmArgs, {
     stdio: ["pipe", "pipe", "pipe"]
   });
+  logCommand("docker", rmArgs, {
+    status: rm.status,
+    stdout: rm.stdout?.toString() || "",
+    stderr: rm.stderr?.toString() || ""
+  });
   return rm.status === 0;
 }
 
 // src/lib/ui.ts
 import * as p from "@clack/prompts";
-import pc from "picocolors";
+import pc2 from "picocolors";
 function intro2() {
-  p.intro(pc.bgCyan(pc.black(` yolobox v${"0.1.4"} `)));
+  p.intro(pc2.bgCyan(pc2.black(` yolobox v${"0.1.6"} `)));
 }
 function success(message) {
   p.log.success(message);
 }
-function error(message) {
-  p.log.error(pc.red(message));
+function error2(message) {
+  p.log.error(pc2.red(message));
 }
 function warn(message) {
-  p.log.warn(pc.yellow(message));
+  p.log.warn(pc2.yellow(message));
 }
 function info(message) {
   p.log.info(message);
@@ -227,14 +361,14 @@ var attach_default = defineCommand({
   },
   run: async ({ args }) => {
     if (!isDockerRunning()) {
-      error("Docker is not running.");
+      error2("Docker is not running.");
       return process.exit(1);
     }
     let id = args.id;
     if (!id) {
       const containers = listContainers().filter((c) => c.status === "running");
       if (containers.length === 0) {
-        error("No running yolobox containers found.");
+        error2("No running yolobox containers found.");
         return process.exit(1);
       }
       if (containers.length === 1) {
@@ -255,13 +389,13 @@ var attach_default = defineCommand({
       const containers = listContainers();
       const match = containers.find((c) => c.id === id);
       if (!match) {
-        error(`No yolobox container found with ID "${id}".`);
+        error2(`No yolobox container found with ID "${id}".`);
         return process.exit(1);
       }
       if (match.status !== "running") {
         info(`Restarting stopped container "${id}"...`);
         if (!restartContainer(id)) {
-          error(`Failed to restart container "${id}".`);
+          error2(`Failed to restart container "${id}".`);
           return process.exit(1);
         }
       }
@@ -281,17 +415,17 @@ import {
   mkdirSync,
   readFileSync,
   unlinkSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var AUTH_DIR_NAME = ".yolobox";
 var AUTH_FILE_NAME = "auth.json";
 function getAuthDir() {
-  return join2(homedir(), AUTH_DIR_NAME);
+  return join3(homedir(), AUTH_DIR_NAME);
 }
 function getAuthFilePath() {
-  return join2(getAuthDir(), AUTH_FILE_NAME);
+  return join3(getAuthDir(), AUTH_FILE_NAME);
 }
 function saveToken(token) {
   const dir = getAuthDir();
@@ -299,7 +433,7 @@ function saveToken(token) {
     mkdirSync(dir, { mode: 448, recursive: true });
   }
   const data = JSON.stringify({ claudeOauthToken: token }, null, 2);
-  writeFileSync(getAuthFilePath(), `${data}
+  writeFileSync2(getAuthFilePath(), `${data}
 `, { mode: 384 });
 }
 function loadToken() {
@@ -380,7 +514,7 @@ var auth_default = defineCommand2({
     if (args.token) {
       const token = args.token;
       if (!isValidToken(token)) {
-        error(
+        error2(
           'Invalid token. Expected a token starting with "sk-ant-".\nRun `claude setup-token` to generate a valid token.'
         );
         process.exit(1);
@@ -393,7 +527,7 @@ var auth_default = defineCommand2({
     const envToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
     if (envToken) {
       if (!isValidToken(envToken)) {
-        error(
+        error2(
           "CLAUDE_CODE_OAUTH_TOKEN is set but does not look like a valid token."
         );
         process.exit(1);
@@ -446,10 +580,11 @@ function showStatus() {
 import { defineCommand as defineCommand3 } from "citty";
 
 // src/lib/container-setup.ts
+import fs2 from "fs";
 import path2 from "path";
 
 // src/lib/git.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync2, spawnSync as spawnSync2 } from "child_process";
 function exec(cmd) {
   return execSync2(cmd, {
     encoding: "utf-8",
@@ -468,7 +603,7 @@ function getRepoRoot() {
   return exec("git rev-parse --show-toplevel");
 }
 function getGitDir() {
-  return exec("git rev-parse --git-dir");
+  return exec("git rev-parse --absolute-git-dir");
 }
 function getBranches() {
   const output = exec('git branch --list --format="%(refname:short)"');
@@ -514,6 +649,28 @@ function getGitIdentity() {
     return { name: "", email: "" };
   }
 }
+function listUntrackedFiles(repoRoot, pathspec) {
+  const result = spawnSync2(
+    "git",
+    [
+      "-C",
+      repoRoot,
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "--",
+      pathspec
+    ],
+    {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }
+  );
+  if (result.status !== 0) return [];
+  const output = result.stdout?.trim() ?? "";
+  if (!output) return [];
+  return output.split("\n").filter(Boolean);
+}
 
 // src/lib/id.ts
 var ADJECTIVES = [
@@ -1285,10 +1442,51 @@ function getExistingWorktreeIds(repoRoot) {
 }
 
 // src/lib/container-setup.ts
+function copyUntrackedFilesFromCwd(options) {
+  const { repoRoot, worktreePath, cwd } = options;
+  const relativeCwd = path2.relative(repoRoot, cwd);
+  if (relativeCwd.startsWith("..") || path2.isAbsolute(relativeCwd)) {
+    log(`Skipping untracked copy: cwd outside repo (${cwd})`);
+    return 0;
+  }
+  if (relativeCwd.split(path2.sep).includes(".yolobox")) {
+    log(`Skipping untracked copy: cwd inside .yolobox (${cwd})`);
+    return 0;
+  }
+  const pathspec = relativeCwd === "" ? "." : relativeCwd;
+  const files = listUntrackedFiles(repoRoot, pathspec);
+  if (files.length === 0) return 0;
+  let copied = 0;
+  for (const file of files) {
+    const src = path2.join(repoRoot, file);
+    const dest = path2.join(worktreePath, file);
+    try {
+      if (fs2.existsSync(dest)) continue;
+      fs2.mkdirSync(path2.dirname(dest), { recursive: true });
+      const stat = fs2.lstatSync(src);
+      if (stat.isSymbolicLink()) {
+        const target = fs2.readlinkSync(src);
+        fs2.symlinkSync(target, dest);
+      } else if (stat.isDirectory()) {
+        fs2.mkdirSync(dest, { recursive: true });
+      } else {
+        fs2.copyFileSync(src, dest);
+      }
+      copied++;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log(`Failed to copy untracked file "${file}": ${message}`);
+    }
+  }
+  return copied;
+}
 async function setupContainer(options = {}) {
   intro2();
+  if (isEnabled()) {
+    info(`Debug log: ${getLogPath()}`);
+  }
   if (!isDockerRunning()) {
-    error("Docker is not running. Start Docker and try again.");
+    error2("Docker is not running. Start Docker and try again.");
     process.exit(1);
   }
   if (!isInsideGitRepo()) {
@@ -1296,7 +1494,7 @@ async function setupContainer(options = {}) {
       message: "No git repo found. Initialize one here?"
     });
     if (p.isCancel(shouldInit) || !shouldInit) {
-      error("yolobox needs a git repo for worktrees.");
+      error2("yolobox needs a git repo for worktrees.");
       process.exit(1);
     }
     initRepo();
@@ -1308,6 +1506,8 @@ async function setupContainer(options = {}) {
   }
   const repoRoot = getRepoRoot();
   const gitDir = getGitDir();
+  log(`Repo root: ${repoRoot}`);
+  log(`Git dir: ${gitDir}`);
   let id;
   if (options.name) {
     id = options.name;
@@ -1321,7 +1521,7 @@ async function setupContainer(options = {}) {
     const containers = listContainers();
     const existing = containers.find((c) => c.id === id);
     if (existing && existing.status === "running") {
-      error(
+      error2(
         `Container "${id}" is already running. Use "yolobox attach ${id}" to connect.`
       );
       process.exit(1);
@@ -1343,10 +1543,26 @@ async function setupContainer(options = {}) {
     success(`Created worktree .yolobox/${id} (branch: yolo/${id})`);
   }
   ensureGitignore(repoRoot);
+  if (!worktreeAlreadyExists && !branchAlreadyExists) {
+    const copied = copyUntrackedFilesFromCwd({
+      repoRoot,
+      worktreePath,
+      cwd: process.cwd()
+    });
+    if (copied > 0) {
+      const cwdRel = path2.relative(repoRoot, process.cwd()) || ".";
+      const label = copied === 1 ? "file" : "files";
+      info(`Copied ${copied} untracked ${label} from ${cwdRel}`);
+    }
+  }
   const gitIdentity = getGitIdentity();
+  log("Resolving Docker image...");
   const imageResolution = resolveDockerImage({
     envImage: process.env.YOLOBOX_IMAGE
   });
+  log(
+    `Resolved image: ${imageResolution.image} (source: ${imageResolution.source})`
+  );
   if (imageResolution.source === "env") {
     info(`Using custom Docker image: ${imageResolution.image}`);
   } else if (imageResolution.source === "local") {
@@ -1366,17 +1582,35 @@ async function setupContainer(options = {}) {
     );
     if (!pulled) {
       spinner.stop("Failed to pull image", 1);
-      error("Failed to pull Docker image.");
+      error2("Failed to pull Docker image.");
       process.exit(1);
     }
     spinner.stop("Docker image pulled");
   }
+  const testFile = path2.join(gitDir, "HEAD");
+  if (!canDockerAccessPath(testFile, imageResolution.image)) {
+    error2("Docker cannot access files in this directory.");
+    if (process.platform === "darwin" && repoRoot.includes("/Library/Mobile Documents/")) {
+      error2(
+        'This repo is in iCloud Drive. Docker Desktop needs "Full Disk Access" to read these files.\n  \u2192 Open System Settings > Privacy & Security > Full Disk Access\n  \u2192 Enable Docker Desktop, then restart Docker.'
+      );
+    } else if (process.platform === "darwin") {
+      error2(
+        'Docker Desktop may need "Full Disk Access" to read files in this location.\n  \u2192 Open System Settings > Privacy & Security > Full Disk Access\n  \u2192 Enable Docker Desktop, then restart Docker.'
+      );
+    }
+    process.exit(1);
+  }
   const claudeOauthToken = resolveToken();
   if (claudeOauthToken) {
     success("Claude auth token configured");
   } else {
     warn('No Claude auth token. Run "yolobox auth" to set up.');
   }
+  log(`Starting container with id=${id}, image=${imageResolution.image}`);
+  log(`Worktree path: ${worktreePath}`);
+  log(`Git identity: ${gitIdentity.name} <${gitIdentity.email}>`);
+  log(`Claude token: ${claudeOauthToken ? "set" : "not set"}`);
   const started = startContainer({
     id,
     worktreePath,
@@ -1387,9 +1621,26 @@ async function setupContainer(options = {}) {
     claudeOauthToken: claudeOauthToken ?? void 0
   });
   if (!started) {
-    error("Failed to start container.");
+    if (isEnabled()) {
+      error2(
+        `Failed to start container. Check ${getLogPath()} for details.`
+      );
+    } else {
+      error2("Failed to start container. Run with --debug for details.");
+    }
     process.exit(1);
   }
+  const safeDirOk = execInContainerNonInteractive(id, [
+    "git",
+    "config",
+    "--global",
+    "--add",
+    "safe.directory",
+    "/workspace"
+  ]);
+  if (!safeDirOk) {
+    log("Failed to mark /workspace as a safe git directory");
+  }
   return { id, repoRoot };
 }
 
@@ -1422,7 +1673,7 @@ var claude_default = defineCommand3({
 });
 
 // src/commands/help.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { defineCommand as defineCommand4 } from "citty";
 var help_default = defineCommand4({
   meta: {
@@ -1430,7 +1681,7 @@ var help_default = defineCommand4({
     description: "Show help information"
   },
   run: async () => {
-    const result = spawnSync2(process.argv[0], [process.argv[1], "--help"], {
+    const result = spawnSync3(process.argv[0], [process.argv[1], "--help"], {
       stdio: "inherit"
     });
     process.exit(result.status || 0);
@@ -1453,14 +1704,14 @@ var kill_default = defineCommand5({
   },
   run: async ({ args }) => {
     if (!isDockerRunning()) {
-      error("Docker is not running.");
+      error2("Docker is not running.");
       return process.exit(1);
     }
     let id = args.id;
     if (!id) {
       const containers = listContainers();
       if (containers.length === 0) {
-        error("No yolobox containers found.");
+        error2("No yolobox containers found.");
         return process.exit(1);
       }
       const selected = await p.select({
@@ -1486,13 +1737,13 @@ var kill_default = defineCommand5({
       const containers = listContainers();
       const match = containers.find((c) => c.id === id);
       if (!match) {
-        error(`No yolobox container found with ID "${id}".`);
+        error2(`No yolobox container found with ID "${id}".`);
         return process.exit(1);
       }
     }
     const killed = killContainer(id);
     if (!killed) {
-      error(`Failed to kill yolobox-${id}. Is it running?`);
+      error2(`Failed to kill yolobox-${id}. Is it running?`);
       process.exit(1);
     }
     success(`Killed yolobox-${id}`);
@@ -1522,7 +1773,7 @@ var ls_default = defineCommand6({
   },
   run: async () => {
     if (!isDockerRunning()) {
-      error("Docker is not running.");
+      error2("Docker is not running.");
       process.exit(1);
     }
     const containers = listContainers();
@@ -1536,12 +1787,12 @@ var ls_default = defineCommand6({
     const statusW = Math.max(8, ...containers.map((c) => c.status.length)) + 2;
     const createdW = Math.max(9, ...containers.map((c) => c.created.length)) + 2;
     const header = `${"ID".padEnd(idW)}${"BRANCH".padEnd(branchW)}${"STATUS".padEnd(statusW)}${"CREATED".padEnd(createdW)}PATH`;
-    console.log(pc.dim(header));
+    console.log(pc2.dim(header));
     for (let i = 0; i < containers.length; i++) {
       const c = containers[i];
-      const statusColor = c.status === "running" ? pc.green : pc.yellow;
+      const statusColor = c.status === "running" ? pc2.green : pc2.yellow;
       console.log(
-        `${c.id.padEnd(idW)}${c.branch.padEnd(branchW)}${statusColor(c.status.padEnd(statusW))}${pc.dim(c.created.padEnd(createdW))}${pc.dim(paths[i])}`
+        `${c.id.padEnd(idW)}${c.branch.padEnd(branchW)}${statusColor(c.status.padEnd(statusW))}${pc2.dim(c.created.padEnd(createdW))}${pc2.dim(paths[i])}`
       );
     }
   }
@@ -1604,7 +1855,7 @@ var nuke_default = defineCommand7({
     const targets = [...targetMap.values()];
     if (targets.length === 0) {
       if (!dockerRunning) {
-        error(
+        error2(
           "Docker is not running and no local branches or worktrees found."
         );
       } else {
@@ -1622,18 +1873,18 @@ Found ${targets.length} yolobox resource${targets.length === 1 ? "" : "s"}:
     for (const target of targets) {
       const parts = [];
       if (target.container) {
-        const statusColor = target.container.status === "running" ? pc.green : pc.dim;
+        const statusColor = target.container.status === "running" ? pc2.green : pc2.dim;
         parts.push(`container ${statusColor(target.container.status)}`);
       }
       if (target.hasBranch) {
-        parts.push(`branch ${pc.cyan(`yolo/${target.id}`)}`);
+        parts.push(`branch ${pc2.cyan(`yolo/${target.id}`)}`);
       }
       if (target.hasWorktree) {
         parts.push("worktree");
       }
-      const pathSuffix = args.all && target.container ? `  ${pc.dim(target.container.path)}` : "";
+      const pathSuffix = args.all && target.container ? `  ${pc2.dim(target.container.path)}` : "";
       console.log(
-        `  ${pc.bold(target.id)}  ${parts.join(pc.dim("  \xB7  "))}${pathSuffix}`
+        `  ${pc2.bold(target.id)}  ${parts.join(pc2.dim("  \xB7  "))}${pathSuffix}`
       );
     }
     console.log();
@@ -1676,10 +1927,10 @@ Found ${targets.length} yolobox resource${targets.length === 1 ? "" : "s"}:
         if (!target.container) continue;
         const success2 = killContainer(target.id);
         if (success2) {
-          success(`Killed container ${pc.bold(target.id)}`);
+          success(`Killed container ${pc2.bold(target.id)}`);
           containersKilled++;
         } else {
-          error(`Failed to kill container ${target.id}`);
+          error2(`Failed to kill container ${target.id}`);
           killFailures++;
         }
       }
@@ -1692,7 +1943,7 @@ Found ${targets.length} yolobox resource${targets.length === 1 ? "" : "s"}:
           const removed = removeWorktree(repoRoot, target.id);
           if (removed) {
             success(
-              `Removed worktree ${pc.bold(`.yolobox/${target.id}`)}`
+              `Removed worktree ${pc2.bold(`.yolobox/${target.id}`)}`
             );
             worktreesRemoved++;
           } else {
@@ -1703,7 +1954,7 @@ Found ${targets.length} yolobox resource${targets.length === 1 ? "" : "s"}:
           const branchName = `yolo/${target.id}`;
           const deleted = deleteBranch(branchName);
           if (deleted) {
-            success(`Deleted branch ${pc.bold(branchName)}`);
+            success(`Deleted branch ${pc2.bold(branchName)}`);
             branchesDeleted++;
           } else {
             warn(`Could not delete branch ${branchName}`);
@@ -1733,7 +1984,7 @@ Found ${targets.length} yolobox resource${targets.length === 1 ? "" : "s"}:
       summaryParts.push(
         `${killFailures} container${s(killFailures)} failed to stop`
       );
-      error(`${summaryParts.join(", ")}.`);
+      error2(`${summaryParts.join(", ")}.`);
       process.exit(1);
     } else {
       const msg = summaryParts.join(", ");
@@ -1759,7 +2010,7 @@ var rm_default = defineCommand8({
   },
   run: async ({ args }) => {
     if (!isDockerRunning()) {
-      error("Docker is not running.");
+      error2("Docker is not running.");
       return process.exit(1);
     }
     const repoRoot = getRepoRoot();
@@ -1767,7 +2018,7 @@ var rm_default = defineCommand8({
     if (!id) {
       const containers = listContainers();
       if (containers.length === 0) {
-        error("No yolobox containers found.");
+        error2("No yolobox containers found.");
         return process.exit(1);
       }
       const selected = await p.select({
@@ -1794,7 +2045,7 @@ var rm_default = defineCommand8({
       const hasWorktree = getExistingWorktreeIds(repoRoot).includes(id);
       const hasBranch = getBranches().includes(`yolo/${id}`);
       if (!hasContainer && !hasWorktree && !hasBranch) {
-        error(`No yolobox found with ID "${id}".`);
+        error2(`No yolobox found with ID "${id}".`);
         return process.exit(1);
       }
     }
@@ -1831,7 +2082,7 @@ var start_default = defineCommand9({
   run: async ({ args }) => {
     if (args.name) {
       if (!isDockerRunning()) {
-        error("Docker is not running.");
+        error2("Docker is not running.");
         return process.exit(1);
       }
       const containers = listContainers();
@@ -1844,7 +2095,9 @@ var start_default = defineCommand9({
         }
         info(`Restarting stopped container "${args.name}"...`);
         if (!restartContainer(args.name)) {
-          error(`Failed to restart container "${args.name}".`);
+          error2(
+            `Failed to restart container "${args.name}". Run with --debug for details.`
+          );
           return process.exit(1);
         }
         outro2(`Launching shell in ${args.name}...`);
@@ -1861,10 +2114,21 @@ var start_default = defineCommand9({
 });
 
 // src/index.ts
+var debugIndex = process.argv.indexOf("--debug");
+if (debugIndex !== -1) {
+  process.argv.splice(debugIndex, 1);
+  const logPath = enable();
+  log(`yolobox v${"0.1.6"}`);
+  log(`args: ${process.argv.slice(2).join(" ")}`);
+  log(`cwd: ${process.cwd()}`);
+  log(`node: ${process.version}`);
+  log(`platform: ${process.platform} ${process.arch}`);
+  log(`log file: ${logPath}`);
+}
 var main = defineCommand10({
   meta: {
     name: "yolobox",
-    version: "0.1.4",
+    version: "0.1.6",
     description: "Run Claude Code in Docker containers. YOLO safely."
   },
   subCommands: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yolobox",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Run Claude Code in a Docker container with --dangerously-skip-permissions. YOLO safely.",
   "type": "module",
   "bin": {