yolobox 0.1.0 → 0.1.2

package/README.md

@@ -1,75 +1,179 @@
 # yolobox
 
-Run Claude Code in Docker containers with `--dangerously-skip-permissions`. Each yolobox gets its own git worktree and branch, so multiple AI agents can work on the same repo simultaneously without conflicts.
+Run [Claude Code](https://docs.anthropic.com/en/docs/claude-code) with `--dangerously-skip-permissions` in disposable Docker containers. Spin up as many as you want, let them run wild, merge the results.
 
 ```bash
-yolobox run                          # Interactive Claude session
-yolobox run -p "fix the login bug"   # Start Claude with a prompt
-yolobox run --shell                  # Drop into bash instead of Claude
-yolobox run --name cool-tiger        # Use a specific ID instead of random
+yolobox claude                           # Launch Claude with --dangerously-skip-permissions
+yolobox claude -p "fix the login bug"    # Launch with a prompt
+yolobox start                            # Drop into a shell instead
+yolobox ls                               # List running boxes
+yolobox attach                           # Reattach to a running box
+yolobox kill                             # Stop a box (keeps branch)
+yolobox rm                               # Remove box + branch + worktree
+yolobox nuke                             # Scorched earth — remove everything
 ```
 
----
+## Install
 
-## Development
+```bash
+npm install -g yolobox
+```
+
+Requires Docker and Node.js 18+.
+
+## What's a yolobox?
+
+A yolobox is three things, created together as a single unit:
+
+- **Docker container** — Claude can install packages, delete files, run arbitrary commands. Your host machine doesn't feel a thing.
+- **Git worktree** — an isolated copy of your codebase at `.yolobox/<id>`, separate from your working directory and from every other box.
+- **Git branch** — a `yolo/<id>` branch forked from HEAD. Every change is tracked and easy to review, merge, or throw away.
+
+Create a box, get all three. Remove a box, all three are cleaned up.
 
-### Setup
+`--dangerously-skip-permissions` makes Claude Code dramatically more productive, but running it on your actual machine requires a level of trust that borders on spiritual. And running *multiple* instances on the same repo? They'd all be editing the same files and tripping over each other.
+
+yolobox gives each Claude instance its own container (safety) and its own worktree (isolation). Open a few terminals, fire off parallel agents, and review the branches when they're done. Keep what works, toss what doesn't.
+
+## Commands
+
+### `yolobox claude [name] [-p <prompt>]`
+
+The main event. Spins up a fresh yolobox and drops you straight into Claude Code with `--dangerously-skip-permissions`. Full send.
 
 ```bash
-# Install dependencies
-npm install
+yolobox claude                           # Interactive Claude session
+yolobox claude -p "refactor auth to JWT" # Give Claude a prompt and watch it go
+yolobox claude my-feature                # Use a custom name instead of a random one
+```
+
+### `yolobox start [name]`
 
-# Build the Docker image (only needed once, takes ~5 min)
-npm run docker:build
+Same container setup as `claude`, but drops you into a bash shell instead. For when you want to poke around, run tests, or do your own yoloing.
 
-# Link the CLI globally so you can use the `yolobox` command
-npm link
+```bash
+yolobox start                            # Shell in a new yolobox
+yolobox start my-feature                 # Named yolobox — reattaches if already running
 ```
 
-### Testing
+If you give it a name that already exists, it'll reattach to the existing container instead of creating a new one. No wasted containers, just vibes.
+
+### `yolobox attach [id]`
 
-**End-to-end test:**
+Jump back into a running yolobox. If you don't specify an ID, you get a slick interactive picker. If the container was stopped, it'll restart it for you automatically — because who has time to babysit Docker.
 
 ```bash
-# In this repo (or any git repo)
-yolobox run --shell
+yolobox attach                           # Pick from running containers
+yolobox attach swift-falcon              # Attach to a specific one
 ```
 
-This will:
-- ✓ Check Docker is running
-- ✓ Check you're in a git repo
-- ✓ Generate a random ID (e.g., `swift-falcon`)
-- ✓ Create `.yolobox/swift-falcon/` worktree
-- ✓ Launch you into a bash shell inside the container
+### `yolobox ls`
+
+See what's running. Shows ID, branch, status, age, and which repo each container belongs to.
 
-Once inside the container, verify:
 ```bash
-pwd                    # Should be /workspace
-git branch             # Should show your yolobox branch
-git config user.name   # Should show your host identity
-ssh-add -l             # Should show your SSH keys (on macOS)
+yolobox ls
+```
+
+```
+ID              BRANCH              STATUS    CREATED     PATH
+swift-falcon    yolo/swift-falcon   running   5 min ago   ~/code/myproject
+bold-otter      yolo/bold-otter     stopped   2h ago      ~/code/myproject
 ```
 
-Type `exit` to leave the container.
+### `yolobox kill [id]`
 
-**Quick verification without Docker:**
+Stop and remove a container. The worktree and branch stick around so you can still see what happened.
 
 ```bash
-npm run build          # Compile TypeScript
-node bin/yolobox.js --help
-node bin/yolobox.js run --help
-npm test               # Run unit tests (18 tests)
+yolobox kill                             # Pick one to kill
+yolobox kill swift-falcon                # Kill a specific container
 ```
 
-### Build & Watch
+### `yolobox rm [id]`
+
+The full cleanup. Kills the container, removes the git worktree, and deletes the `yolo/<id>` branch. Like it never happened.
+
+```bash
+yolobox rm                               # Pick one to remove
+yolobox rm swift-falcon                  # Remove everything for swift-falcon
+```
+
+### `yolobox nuke [--all]`
+
+For when you want to start completely fresh. Shows you everything that exists (containers, branches, worktrees) and lets you choose between killing just containers or going full scorched-earth. No questions asked. (*)
+
+```bash
+yolobox nuke                             # Nuke everything in the current repo
+yolobox nuke --all                       # Nuke yolobox containers from ALL repos
+```
+
+(*) Actually we do ask for confirmation.
+
+## Under the hood
+
+When you create a yolobox, the CLI:
+
+1. **Creates a git worktree** at `.yolobox/<id>` on a new `yolo/<id>` branch forked from HEAD
+2. **Launches a Docker container** that mounts the worktree as `/workspace` and shares your repo's `.git` directory
+3. **Forwards your git identity** so commits show up as you
+4. **Injects your Claude auth token** so there's no login prompt
+
+## Authentication
+
+Each container needs Claude Code authentication, but you only need to configure your token once — yolobox automatically injects it into every new container:
+
+```bash
+# Step 1: Generate a long-lived token
+claude setup-token
+
+# Step 2: Store it in yolobox
+yolobox auth <token>
+```
+
+Or if you have the `CLAUDE_CODE_OAUTH_TOKEN` env var set:
+
+```bash
+yolobox auth    # Automatically picks up the env var
+```
+
+```bash
+yolobox auth --status   # Check current auth status
+yolobox auth --remove   # Remove stored token
+```
+
+The token is saved to `~/.yolobox/auth.json` and automatically injected into every new container.
+
+
+
+
+
+
+
+## Development
+
+```bash
+npm install                    # Install dependencies
+npm run docker:build           # Build the Docker image locally (~5 min, one-time)
+npm link                       # Link the CLI globally
+
+npm run build                  # One-shot TypeScript build
+npm run dev                    # Watch mode
+npm test                       # Run tests
+```
+
+### Custom Docker image
+
+Want to bring your own container? Set the `YOLOBOX_IMAGE` env var:
 
 ```bash
-npm run build          # One-shot build
-npm run dev            # Watch mode (rebuild on change)
-npm test               # Run tests
+YOLOBOX_IMAGE=my-custom-image:latest yolobox claude
 ```
 
----
+Image resolution order:
+1. `YOLOBOX_IMAGE` env var (if set)
+2. `yolobox:local` (if you've built it locally)
+3. `ghcr.io/roginn/yolobox:latest` (default)
 
 ## License
 

package/dist/index.js

@@ -1,11 +1,13 @@
 // src/index.ts
-import { defineCommand as defineCommand7, runMain } from "citty";
+import { defineCommand as defineCommand10, runMain } from "citty";
 
-// src/commands/claude.ts
+// src/commands/attach.ts
 import { defineCommand } from "citty";
 
 // src/lib/docker.ts
 import { execSync, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
 function isDockerRunning() {
   try {
     execSync("docker info", { stdio: ["pipe", "pipe", "pipe"] });
@@ -14,6 +16,37 @@ function isDockerRunning() {
     return false;
   }
 }
+function resolveDockerImage(options) {
+  if (options.envImage) {
+    return {
+      image: options.envImage,
+      source: "env"
+    };
+  }
+  if (options.checkLocalImage !== false && imageExists("yolobox:local")) {
+    return {
+      image: "yolobox:local",
+      source: "local"
+    };
+  }
+  return {
+    image: "ghcr.io/roginn/yolobox:latest",
+    source: "ghcr"
+  };
+}
+function imageExists(imageName) {
+  try {
+    execSync(`docker image inspect ${imageName}`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isYoloboxDevRepo(repoRoot) {
+  return existsSync(join(repoRoot, "docker", "Dockerfile"));
+}
 function buildDockerArgs(opts) {
   const args = [
     "run",
@@ -39,6 +72,9 @@ function buildDockerArgs(opts) {
     args.push("-e", `GIT_AUTHOR_EMAIL=${opts.gitIdentity.email}`);
     args.push("-e", `GIT_COMMITTER_EMAIL=${opts.gitIdentity.email}`);
   }
+  if (opts.claudeOauthToken) {
+    args.push("-e", `CLAUDE_CODE_OAUTH_TOKEN=${opts.claudeOauthToken}`);
+  }
   args.push(opts.image);
   args.push("sleep", "infinity");
   return args;
@@ -51,6 +87,12 @@ function startContainer(opts) {
   const result = spawnSync("docker", args, { stdio: ["pipe", "pipe", "pipe"] });
   return result.status === 0;
 }
+function restartContainer(id) {
+  const result = spawnSync("docker", ["start", `yolobox-${id}`], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return result.status === 0;
+}
 function execInContainer(id, command) {
   const args = buildExecArgs(id, command);
   const result = spawnSync("docker", args, { stdio: "inherit" });
@@ -67,6 +109,16 @@ function timeAgo(dateStr) {
   const days = Math.floor(hours / 24);
   return `${days}d ago`;
 }
+function getWorktreeBranch(repoPath, id) {
+  try {
+    const worktreePath = join(repoPath, ".yolobox", id);
+    return execSync(`git -C "${worktreePath}" rev-parse --abbrev-ref HEAD`, {
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return `yolo/${id}`;
+  }
+}
 function listContainers() {
   try {
     const result = execSync(
@@ -74,14 +126,14 @@ function listContainers() {
       { encoding: "utf-8" }
     );
     return result.trim().split("\n").filter(Boolean).map((line) => {
-      const [name, status, created, path2] = line.split("	");
+      const [name, status, created, path3] = line.split("	");
       const id = name.replace(/^yolobox-/, "");
       return {
         id,
-        branch: id,
+        branch: getWorktreeBranch(path3, id),
         status: status.startsWith("Up") ? "running" : "stopped",
         created: timeAgo(created),
-        path: path2 || ""
+        path: path3 || ""
       };
     });
   } catch {
@@ -99,6 +151,264 @@ function killContainer(id) {
   return rm.status === 0;
 }
 
+// src/lib/ui.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function intro2() {
+  p.intro(pc.bgCyan(pc.black(` yolobox v${"0.1.2"} `)));
+}
+function success(message) {
+  p.log.success(message);
+}
+function error(message) {
+  p.log.error(pc.red(message));
+}
+function warn(message) {
+  p.log.warn(pc.yellow(message));
+}
+function info(message) {
+  p.log.info(message);
+}
+function outro2(message) {
+  p.outro(message);
+}
+
+// src/commands/attach.ts
+var attach_default = defineCommand({
+  meta: {
+    name: "attach",
+    description: "Attach a shell to a running yolobox container"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "The yolobox ID to attach to (interactive picker if omitted)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    if (!isDockerRunning()) {
+      error("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.");
+        return process.exit(1);
+      }
+      if (containers.length === 1) {
+        id = containers[0].id;
+      } else {
+        const selected = await p.select({
+          message: "Pick a container to attach to",
+          options: containers.map((c) => ({
+            value: c.id,
+            label: c.id,
+            hint: c.path
+          }))
+        });
+        if (p.isCancel(selected)) return process.exit(0);
+        id = selected;
+      }
+    } else {
+      const containers = listContainers();
+      const match = containers.find((c) => c.id === id);
+      if (!match) {
+        error(`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}".`);
+          return process.exit(1);
+        }
+      }
+    }
+    outro2(`Attaching to ${id}...`);
+    const exitCode = execInContainer(id, ["bash"]);
+    process.exit(exitCode);
+  }
+});
+
+// src/commands/auth.ts
+import { defineCommand as defineCommand2 } from "citty";
+
+// src/lib/auth.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var AUTH_DIR_NAME = ".yolobox";
+var AUTH_FILE_NAME = "auth.json";
+function getAuthDir() {
+  return join2(homedir(), AUTH_DIR_NAME);
+}
+function getAuthFilePath() {
+  return join2(getAuthDir(), AUTH_FILE_NAME);
+}
+function saveToken(token) {
+  const dir = getAuthDir();
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { mode: 448, recursive: true });
+  }
+  const data = JSON.stringify({ claudeOauthToken: token }, null, 2);
+  writeFileSync(getAuthFilePath(), `${data}
+`, { mode: 384 });
+}
+function loadToken() {
+  const filePath = getAuthFilePath();
+  if (!existsSync2(filePath)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(readFileSync(filePath, "utf-8"));
+    return data.claudeOauthToken || null;
+  } catch {
+    return null;
+  }
+}
+function removeToken() {
+  const filePath = getAuthFilePath();
+  if (!existsSync2(filePath)) {
+    return false;
+  }
+  unlinkSync(filePath);
+  return true;
+}
+function resolveToken() {
+  const envToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  if (envToken) {
+    return envToken;
+  }
+  return loadToken();
+}
+function isValidToken(token) {
+  return token.startsWith("sk-ant-");
+}
+function maskToken(token) {
+  if (token.length <= 12) {
+    return "***";
+  }
+  return `${token.slice(0, 10)}...${token.slice(-4)}`;
+}
+
+// src/commands/auth.ts
+var auth_default = defineCommand2({
+  meta: {
+    name: "auth",
+    description: "Configure Claude Code authentication for containers"
+  },
+  args: {
+    token: {
+      type: "positional",
+      description: "OAuth token from `claude setup-token`",
+      required: false
+    },
+    remove: {
+      type: "boolean",
+      description: "Remove stored token",
+      default: false
+    },
+    status: {
+      type: "boolean",
+      description: "Show current auth status",
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    intro2();
+    if (args.status) {
+      showStatus();
+      return;
+    }
+    if (args.remove) {
+      const removed = removeToken();
+      if (removed) {
+        success("Auth token removed.");
+      } else {
+        warn("No stored token found.");
+      }
+      return;
+    }
+    if (args.token) {
+      const token = args.token;
+      if (!isValidToken(token)) {
+        error(
+          'Invalid token. Expected a token starting with "sk-ant-".\nRun `claude setup-token` to generate a valid token.'
+        );
+        process.exit(1);
+      }
+      saveToken(token);
+      success(`Token saved. (${maskToken(token)})`);
+      info("Claude will authenticate automatically in new containers.");
+      return;
+    }
+    const envToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    if (envToken) {
+      if (!isValidToken(envToken)) {
+        error(
+          "CLAUDE_CODE_OAUTH_TOKEN is set but does not look like a valid token."
+        );
+        process.exit(1);
+      }
+      saveToken(envToken);
+      success(
+        `Token captured from CLAUDE_CODE_OAUTH_TOKEN. (${maskToken(envToken)})`
+      );
+      info("Claude will authenticate automatically in new containers.");
+      return;
+    }
+    const existing = loadToken();
+    if (existing) {
+      success(`Already authenticated. (${maskToken(existing)})`);
+      info(
+        "Run `yolobox auth --status` for details or `yolobox auth --remove` to clear."
+      );
+      return;
+    }
+    info("Set up Claude Code authentication for yolobox containers.\n");
+    info("Step 1: Generate a token on your host machine:");
+    info("  $ claude setup-token\n");
+    info("Step 2: Pass the token to yolobox:");
+    info("  $ yolobox auth <token>\n");
+    info("Or set the CLAUDE_CODE_OAUTH_TOKEN env var and run:");
+    info("  $ export CLAUDE_CODE_OAUTH_TOKEN=<token>");
+    info("  $ yolobox auth");
+  }
+});
+function showStatus() {
+  const envToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  const storedToken = loadToken();
+  const activeToken = resolveToken();
+  if (!activeToken) {
+    warn("Not authenticated. Run `yolobox auth` for setup instructions.");
+    return;
+  }
+  success(`Authenticated. (${maskToken(activeToken)})`);
+  if (envToken) {
+    info("Source: CLAUDE_CODE_OAUTH_TOKEN environment variable");
+  }
+  if (storedToken) {
+    info(
+      envToken ? `Stored token also available (${maskToken(storedToken)})` : "Source: ~/.yolobox/auth.json"
+    );
+  }
+}
+
+// src/commands/claude.ts
+import { defineCommand as defineCommand3 } from "citty";
+
+// src/lib/container-setup.ts
+import path2 from "path";
+
 // src/lib/git.ts
 import { execSync as execSync2 } from "child_process";
 function exec(cmd) {
@@ -140,6 +450,22 @@ function hasCommits() {
 function createInitialCommit() {
   exec('git commit --allow-empty -m "Initial commit"');
 }
+function branchExists(branch) {
+  try {
+    exec(`git rev-parse --verify "refs/heads/${branch}"`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteBranch(branch) {
+  try {
+    exec(`git branch -D "${branch}"`);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function getGitIdentity() {
   try {
     const name = exec("git config user.name");
@@ -857,25 +1183,6 @@ function generateId(existingIds, maxRetries = 100) {
   throw new Error("Could not generate a unique ID after 100 attempts");
 }
 
-// src/lib/ui.ts
-import * as p from "@clack/prompts";
-import pc from "picocolors";
-function intro2() {
-  p.intro(pc.bgCyan(pc.black(" yolobox v0.0.1 ")));
-}
-function success(message) {
-  p.log.success(message);
-}
-function error(message) {
-  p.log.error(pc.red(message));
-}
-function info(message) {
-  p.log.info(message);
-}
-function outro2(message) {
-  p.outro(message);
-}
-
 // src/lib/worktree.ts
 import { execSync as execSync3 } from "child_process";
 import fs from "fs";
@@ -887,11 +1194,19 @@ function exec2(cmd, cwd) {
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
 }
-function createWorktree(repoRoot, id) {
+function worktreeExists(repoRoot, id) {
+  const worktreePath = path.join(repoRoot, ".yolobox", id);
+  return fs.existsSync(worktreePath);
+}
+function createWorktree(repoRoot, id, options) {
   const yoloboxDir = path.join(repoRoot, ".yolobox");
   fs.mkdirSync(yoloboxDir, { recursive: true });
   const worktreePath = path.join(yoloboxDir, id);
-  exec2(`git worktree add "${worktreePath}" -b "yolo/${id}"`, repoRoot);
+  if (options?.branchExists) {
+    exec2(`git worktree add "${worktreePath}" "yolo/${id}"`, repoRoot);
+  } else {
+    exec2(`git worktree add "${worktreePath}" -b "yolo/${id}"`, repoRoot);
+  }
   return worktreePath;
 }
 function ensureGitignore(repoRoot) {
@@ -908,6 +1223,22 @@ function ensureGitignore(repoRoot) {
 `);
   }
 }
+function removeWorktree(repoRoot, id) {
+  const worktreePath = path.join(repoRoot, ".yolobox", id);
+  try {
+    exec2(`git worktree remove --force "${worktreePath}"`, repoRoot);
+    return true;
+  } catch {
+    try {
+      exec2("git worktree prune", repoRoot);
+    } catch {
+    }
+    if (fs.existsSync(worktreePath)) {
+      fs.rmSync(worktreePath, { recursive: true, force: true });
+    }
+    return true;
+  }
+}
 function getExistingWorktreeIds(repoRoot) {
   const yoloboxDir = path.join(repoRoot, ".yolobox");
   if (!fs.existsSync(yoloboxDir)) return [];
@@ -915,14 +1246,12 @@ function getExistingWorktreeIds(repoRoot) {
 }
 
 // src/lib/container-setup.ts
-var DOCKER_IMAGE = process.env.YOLOBOX_IMAGE || "yolobox:local";
 async function setupContainer(options = {}) {
   intro2();
   if (!isDockerRunning()) {
-    error("Docker is not running. Start Docker Desktop and try again.");
+    error("Docker is not running. Start Docker and try again.");
     process.exit(1);
   }
-  success("Docker is running");
   if (!isInsideGitRepo()) {
     const shouldInit = await p.confirm({
       message: "No git repo found. Initialize one here?"
@@ -933,8 +1262,6 @@ async function setupContainer(options = {}) {
     }
     initRepo();
     success("Initialized git repo");
-  } else {
-    success("Git repo detected");
   }
   if (!hasCommits()) {
     createInitialCommit();
@@ -951,17 +1278,60 @@ async function setupContainer(options = {}) {
     const taken = /* @__PURE__ */ new Set([...branches, ...existingWorktrees]);
     id = generateId(taken);
   }
-  const worktreePath = createWorktree(repoRoot, id);
-  success(`Created worktree .yolobox/${id} (branch: ${id})`);
+  if (options.name) {
+    const containers = listContainers();
+    const existing = containers.find((c) => c.id === id);
+    if (existing && existing.status === "running") {
+      error(
+        `Container "${id}" is already running. Use "yolobox attach ${id}" to connect.`
+      );
+      process.exit(1);
+    }
+    if (existing) {
+      killContainer(id);
+    }
+  }
+  let worktreePath;
+  const worktreeAlreadyExists = worktreeExists(repoRoot, id);
+  const branchAlreadyExists = branchExists(`yolo/${id}`);
+  if (worktreeAlreadyExists) {
+    worktreePath = path2.join(repoRoot, ".yolobox", id);
+    success(`Reusing worktree .yolobox/${id} (branch: yolo/${id})`);
+  } else {
+    worktreePath = createWorktree(repoRoot, id, {
+      branchExists: branchAlreadyExists
+    });
+    success(`Created worktree .yolobox/${id} (branch: yolo/${id})`);
+  }
   ensureGitignore(repoRoot);
   const gitIdentity = getGitIdentity();
+  const imageResolution = resolveDockerImage({
+    envImage: process.env.YOLOBOX_IMAGE
+  });
+  if (imageResolution.source === "env") {
+    info(`Using custom Docker image: ${imageResolution.image}`);
+  } else if (imageResolution.source === "local") {
+    info("Using local Docker image: yolobox:local");
+  } else {
+    info("Using Docker image: ghcr.io/roginn/yolobox:latest");
+    if (isYoloboxDevRepo(repoRoot)) {
+      info("Tip: Run 'npm run docker:build' to use local builds");
+    }
+  }
+  const claudeOauthToken = resolveToken();
+  if (claudeOauthToken) {
+    success("Claude auth token configured");
+  } else {
+    warn('No Claude auth token. Run "yolobox auth" to set up.');
+  }
   const started = startContainer({
     id,
     worktreePath,
     gitDir,
     gitIdentity,
-    image: DOCKER_IMAGE,
-    repoPath: repoRoot
+    image: imageResolution.image,
+    repoPath: repoRoot,
+    claudeOauthToken: claudeOauthToken ?? void 0
   });
   if (!started) {
     error("Failed to start container.");
@@ -971,7 +1341,7 @@ async function setupContainer(options = {}) {
 }
 
 // src/commands/claude.ts
-var claude_default = defineCommand({
+var claude_default = defineCommand3({
   meta: {
     name: "claude",
     description: "Launch Claude Code with skip permissions"
@@ -983,13 +1353,15 @@ var claude_default = defineCommand({
       description: "Pass an initial prompt to Claude"
     },
     name: {
-      type: "string",
-      alias: "n",
-      description: "Use a specific name instead of random"
+      type: "positional",
+      description: "Use a specific name instead of random",
+      required: false
     }
   },
   run: async ({ args }) => {
-    const { id } = await setupContainer({ name: args.name });
+    const { id } = await setupContainer({
+      name: args.name
+    });
     const command = args.prompt ? ["claude", "--dangerously-skip-permissions", "-p", args.prompt] : ["claude", "--dangerously-skip-permissions"];
     outro2(`Launching Claude in ${id}...`);
     execInContainer(id, command);
@@ -998,8 +1370,8 @@ var claude_default = defineCommand({
 
 // src/commands/help.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { defineCommand as defineCommand2 } from "citty";
-var help_default = defineCommand2({
+import { defineCommand as defineCommand4 } from "citty";
+var help_default = defineCommand4({
   meta: {
     name: "help",
     description: "Show help information"
@@ -1013,8 +1385,8 @@ var help_default = defineCommand2({
 });
 
 // src/commands/kill.ts
-import { defineCommand as defineCommand3 } from "citty";
-var kill_default = defineCommand3({
+import { defineCommand as defineCommand5 } from "citty";
+var kill_default = defineCommand5({
   meta: {
     name: "kill",
     description: "Stop and remove a running yolobox container"
@@ -1022,12 +1394,49 @@ var kill_default = defineCommand3({
   args: {
     id: {
       type: "positional",
-      description: "The yolobox ID to kill",
-      required: true
+      description: "The yolobox ID to kill (interactive picker if omitted)",
+      required: false
     }
   },
   run: async ({ args }) => {
-    const id = args.id;
+    if (!isDockerRunning()) {
+      error("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.");
+        return process.exit(1);
+      }
+      const selected = await p.select({
+        message: "Pick a container to kill",
+        options: [
+          ...containers.map((c) => ({
+            value: c.id,
+            label: c.id,
+            hint: `${c.status} \u2022 ${c.path}`
+          })),
+          {
+            value: "__cancel__",
+            label: "Cancel",
+            hint: "Exit without killing"
+          }
+        ]
+      });
+      if (p.isCancel(selected) || selected === "__cancel__") {
+        return process.exit(0);
+      }
+      id = selected;
+    } else {
+      const containers = listContainers();
+      const match = containers.find((c) => c.id === id);
+      if (!match) {
+        error(`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?`);
@@ -1038,11 +1447,11 @@ var kill_default = defineCommand3({
 });
 
 // src/commands/ls.ts
-import { homedir } from "os";
-import { defineCommand as defineCommand4 } from "citty";
-function shortenPath(path2, maxLen = 40) {
-  const home = homedir();
-  const display = path2.startsWith(home) ? `~${path2.slice(home.length)}` : path2;
+import { homedir as homedir2 } from "os";
+import { defineCommand as defineCommand6 } from "citty";
+function shortenPath(path3, maxLen = 40) {
+  const home = homedir2();
+  const display = path3.startsWith(home) ? `~${path3.slice(home.length)}` : path3;
   if (display.length <= maxLen) return display;
   const parts = display.split("/");
   let short = "";
@@ -1053,7 +1462,7 @@ function shortenPath(path2, maxLen = 40) {
   }
   return short ? `\u2026/${short}` : `\u2026/${parts[parts.length - 1]}`;
 }
-var ls_default = defineCommand4({
+var ls_default = defineCommand6({
   meta: {
     name: "ls",
     description: "List running yolobox containers"
@@ -1086,11 +1495,11 @@ var ls_default = defineCommand4({
 });
 
 // src/commands/nuke.ts
-import { defineCommand as defineCommand5 } from "citty";
-var nuke_default = defineCommand5({
+import { defineCommand as defineCommand7 } from "citty";
+var nuke_default = defineCommand7({
   meta: {
     name: "nuke",
-    description: "Kill all yolobox containers from the current directory"
+    description: "Kill all yolobox containers, branches, and worktrees"
   },
   args: {
     all: {
@@ -1100,111 +1509,321 @@ var nuke_default = defineCommand5({
     }
   },
   run: async ({ args }) => {
-    intro2("yolobox nuke");
-    if (!isDockerRunning()) {
-      error("Docker is not running. Please start Docker and try again.");
-      process.exit(1);
+    intro2();
+    const inGitRepo = isInsideGitRepo();
+    const repoRoot = inGitRepo ? getRepoRoot() : null;
+    const dockerRunning = isDockerRunning();
+    let containers = [];
+    if (dockerRunning) {
+      const allContainers = listContainers();
+      if (args.all) {
+        containers = allContainers;
+      } else if (repoRoot) {
+        containers = allContainers.filter((c) => c.path === repoRoot);
+      }
     }
-    const allContainers = listContainers();
-    let matchingContainers;
-    let locationDescription;
-    if (args.all) {
-      matchingContainers = allContainers;
-      locationDescription = "across all directories";
-    } else {
-      const currentPath = isInsideGitRepo() ? getRepoRoot() : process.cwd();
-      matchingContainers = allContainers.filter(
-        (container) => container.path === currentPath
+    let yoloBranchIds = /* @__PURE__ */ new Set();
+    let worktreeIds = /* @__PURE__ */ new Set();
+    if (repoRoot) {
+      yoloBranchIds = new Set(
+        getBranches().filter((b) => b.startsWith("yolo/")).map((b) => b.slice("yolo/".length))
       );
-      locationDescription = `from ${currentPath}`;
+      worktreeIds = new Set(getExistingWorktreeIds(repoRoot));
+    }
+    const targetMap = /* @__PURE__ */ new Map();
+    for (const c of containers) {
+      targetMap.set(c.id, {
+        id: c.id,
+        container: { status: c.status, path: c.path },
+        hasBranch: yoloBranchIds.has(c.id),
+        hasWorktree: worktreeIds.has(c.id)
+      });
+    }
+    for (const id of /* @__PURE__ */ new Set([...yoloBranchIds, ...worktreeIds])) {
+      if (!targetMap.has(id)) {
+        targetMap.set(id, {
+          id,
+          hasBranch: yoloBranchIds.has(id),
+          hasWorktree: worktreeIds.has(id)
+        });
+      }
     }
-    if (matchingContainers.length === 0) {
-      const message = args.all ? "No yolobox containers found." : "No yolobox containers found from this directory.";
-      info(message);
+    const targets = [...targetMap.values()];
+    if (targets.length === 0) {
+      if (!dockerRunning) {
+        error(
+          "Docker is not running and no local branches or worktrees found."
+        );
+      } else {
+        info(
+          args.all ? "Nothing to clean up." : "No yolobox resources found for this directory."
+        );
+      }
       process.exit(0);
     }
     console.log(
       `
-Found ${matchingContainers.length} container${matchingContainers.length === 1 ? "" : "s"} ${locationDescription}:
+Found ${targets.length} yolobox resource${targets.length === 1 ? "" : "s"}:
 `
     );
-    for (const container of matchingContainers) {
-      const pathDisplay = args.all ? ` [${container.path}]` : "";
+    for (const target of targets) {
+      const parts = [];
+      if (target.container) {
+        const statusColor = target.container.status === "running" ? pc.green : pc.dim;
+        parts.push(`container ${statusColor(target.container.status)}`);
+      }
+      if (target.hasBranch) {
+        parts.push(`branch ${pc.cyan(`yolo/${target.id}`)}`);
+      }
+      if (target.hasWorktree) {
+        parts.push("worktree");
+      }
+      const pathSuffix = args.all && target.container ? `  ${pc.dim(target.container.path)}` : "";
       console.log(
-        `  ${container.id} (${container.branch}) - ${container.status}${pathDisplay}`
+        `  ${pc.bold(target.id)}  ${parts.join(pc.dim("  \xB7  "))}${pathSuffix}`
       );
     }
     console.log();
-    const confirmed = await p.confirm({
-      message: `Kill all ${matchingContainers.length} container${matchingContainers.length === 1 ? "" : "s"}?`,
-      initialValue: false
+    const hasContainers = targets.some((t) => t.container);
+    const hasGitResources = targets.some((t) => t.hasBranch || t.hasWorktree);
+    const options = [
+      { value: "cancel", label: "Cancel" }
+    ];
+    if (hasContainers && hasGitResources) {
+      options.push(
+        { value: "kill", label: "Kill containers only" },
+        {
+          value: "full",
+          label: "Nuke all (containers + branches + worktrees)"
+        }
+      );
+    } else if (hasContainers) {
+      options.push({ value: "kill", label: "Kill containers" });
+    } else {
+      options.push({
+        value: "full",
+        label: "Delete all branches and worktrees"
+      });
+    }
+    const action = await p.select({
+      message: "What would you like to do?",
+      options,
+      initialValue: "cancel"
     });
-    if (!confirmed || p.isCancel(confirmed)) {
+    if (action === "cancel" || p.isCancel(action)) {
       info("Cancelled.");
       process.exit(0);
     }
-    const results = [];
-    for (const container of matchingContainers) {
-      const success2 = killContainer(container.id);
-      results.push({ id: container.id, success: success2 });
-      if (success2) {
-        success(`Killed container ${container.id}`);
-      } else {
-        error(`Failed to kill container ${container.id}`);
+    const shouldKill = action === "kill" || action === "full";
+    const shouldCleanGit = action === "full";
+    let containersKilled = 0;
+    let killFailures = 0;
+    if (shouldKill) {
+      for (const target of targets) {
+        if (!target.container) continue;
+        const success2 = killContainer(target.id);
+        if (success2) {
+          success(`Killed container ${pc.bold(target.id)}`);
+          containersKilled++;
+        } else {
+          error(`Failed to kill container ${target.id}`);
+          killFailures++;
+        }
+      }
+    }
+    let worktreesRemoved = 0;
+    let branchesDeleted = 0;
+    if (shouldCleanGit && repoRoot) {
+      for (const target of targets) {
+        if (target.hasWorktree) {
+          const removed = removeWorktree(repoRoot, target.id);
+          if (removed) {
+            success(
+              `Removed worktree ${pc.bold(`.yolobox/${target.id}`)}`
+            );
+            worktreesRemoved++;
+          } else {
+            warn(`Could not remove worktree for ${target.id}`);
+          }
+        }
+        if (target.hasBranch) {
+          const branchName = `yolo/${target.id}`;
+          const deleted = deleteBranch(branchName);
+          if (deleted) {
+            success(`Deleted branch ${pc.bold(branchName)}`);
+            branchesDeleted++;
+          } else {
+            warn(`Could not delete branch ${branchName}`);
+          }
+        }
       }
     }
-    const successCount = results.filter((r) => r.success).length;
-    const failureCount = results.length - successCount;
     console.log();
-    if (failureCount === 0) {
-      success(
-        `Successfully killed all ${successCount} container${successCount === 1 ? "" : "s"}.`
+    const s = (n) => n === 1 ? "" : "s";
+    const summaryParts = [];
+    if (containersKilled > 0) {
+      summaryParts.push(
+        `killed ${containersKilled} container${s(containersKilled)}`
       );
-      process.exit(0);
-    } else {
-      error(
-        `Killed ${successCount} container${successCount === 1 ? "" : "s"}, but ${failureCount} failed.`
+    }
+    if (branchesDeleted > 0) {
+      summaryParts.push(
+        `deleted ${branchesDeleted} branch${branchesDeleted === 1 ? "" : "es"}`
+      );
+    }
+    if (worktreesRemoved > 0) {
+      summaryParts.push(
+        `removed ${worktreesRemoved} worktree${s(worktreesRemoved)}`
+      );
+    }
+    if (killFailures > 0) {
+      summaryParts.push(
+        `${killFailures} container${s(killFailures)} failed to stop`
       );
+      error(`${summaryParts.join(", ")}.`);
       process.exit(1);
+    } else {
+      const msg = summaryParts.join(", ");
+      success(`${msg.charAt(0).toUpperCase() + msg.slice(1)}.`);
+      process.exit(0);
     }
   }
 });
 
-// src/commands/run.ts
-import { defineCommand as defineCommand6 } from "citty";
-var run_default = defineCommand6({
+// src/commands/rm.ts
+import { defineCommand as defineCommand8 } from "citty";
+var rm_default = defineCommand8({
+  meta: {
+    name: "rm",
+    description: "Remove a yolobox: kill container, delete worktree, and delete branch"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "The yolobox ID to remove (interactive picker if omitted)",
+      required: false
+    }
+  },
+  run: async ({ args }) => {
+    if (!isDockerRunning()) {
+      error("Docker is not running.");
+      return process.exit(1);
+    }
+    const repoRoot = getRepoRoot();
+    let id = args.id;
+    if (!id) {
+      const containers = listContainers();
+      if (containers.length === 0) {
+        error("No yolobox containers found.");
+        return process.exit(1);
+      }
+      const selected = await p.select({
+        message: "Pick a container to remove",
+        options: [
+          ...containers.map((c) => ({
+            value: c.id,
+            label: c.id,
+            hint: `${c.status} \u2022 ${c.path}`
+          })),
+          {
+            value: "__cancel__",
+            label: "Cancel",
+            hint: "Exit without removing"
+          }
+        ]
+      });
+      if (p.isCancel(selected) || selected === "__cancel__") {
+        return process.exit(0);
+      }
+      id = selected;
+    } else {
+      const hasContainer = listContainers().some((c) => c.id === id);
+      const hasWorktree = getExistingWorktreeIds(repoRoot).includes(id);
+      const hasBranch = getBranches().includes(`yolo/${id}`);
+      if (!hasContainer && !hasWorktree && !hasBranch) {
+        error(`No yolobox found with ID "${id}".`);
+        return process.exit(1);
+      }
+    }
+    const killed = killContainer(id);
+    if (killed) {
+      success(`Killed container yolobox-${id}`);
+    }
+    const removedWorktree = removeWorktree(repoRoot, id);
+    if (removedWorktree) {
+      success(`Removed worktree .yolobox/${id}`);
+    }
+    const branch = `yolo/${id}`;
+    const deletedBranch = deleteBranch(branch);
+    if (deletedBranch) {
+      success(`Deleted branch ${branch}`);
+    }
+  }
+});
+
+// src/commands/start.ts
+import { defineCommand as defineCommand9 } from "citty";
+var start_default = defineCommand9({
   meta: {
-    name: "run",
+    name: "start",
     description: "Launch a shell in a new yolobox"
   },
   args: {
     name: {
-      type: "string",
-      alias: "n",
-      description: "Use a specific name instead of random"
+      type: "positional",
+      description: "Use a specific name instead of random",
+      required: false
     }
   },
   run: async ({ args }) => {
-    const { id } = await setupContainer({ name: args.name });
+    if (args.name) {
+      if (!isDockerRunning()) {
+        error("Docker is not running.");
+        return process.exit(1);
+      }
+      const containers = listContainers();
+      const existing = containers.find((c) => c.id === args.name);
+      if (existing) {
+        if (existing.status === "running") {
+          info(`Container "${args.name}" is already running. Attaching...`);
+          const exitCode2 = execInContainer(args.name, ["bash"]);
+          return process.exit(exitCode2);
+        }
+        info(`Restarting stopped container "${args.name}"...`);
+        if (!restartContainer(args.name)) {
+          error(`Failed to restart container "${args.name}".`);
+          return process.exit(1);
+        }
+        outro2(`Launching shell in ${args.name}...`);
+        const exitCode = execInContainer(args.name, ["bash"]);
+        return process.exit(exitCode);
+      }
+    }
+    const { id } = await setupContainer({
+      name: args.name
+    });
     outro2(`Launching shell in ${id}...`);
     execInContainer(id, ["bash"]);
   }
 });
 
 // src/index.ts
-var main = defineCommand7({
+var main = defineCommand10({
   meta: {
     name: "yolobox",
-    version: "0.0.1",
+    version: "0.1.2",
     description: "Run Claude Code in Docker containers. YOLO safely."
   },
   subCommands: {
-    run: run_default,
+    auth: auth_default,
+    start: start_default,
     claude: claude_default,
+    attach: attach_default,
     kill: kill_default,
     ls: ls_default,
     help: help_default,
-    nuke: nuke_default
+    nuke: nuke_default,
+    rm: rm_default
   }
 });
 runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yolobox",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Run Claude Code in a Docker container with --dangerously-skip-permissions. YOLO safely.",
   "type": "module",
   "bin": {
@@ -20,7 +20,8 @@
     "lint:fix": "biome check --write .",
     "test": "vitest",
     "docker:build": "docker build -t yolobox:local -f docker/Dockerfile docker/",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "prepare": "lefthook install"
   },
   "dependencies": {
     "@clack/prompts": "^0.9.1",
@@ -30,6 +31,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.3.14",
     "@types/node": "^22.0.0",
+    "lefthook": "^2.1.0",
     "tsup": "^8.3.0",
     "typescript": "^5.7.0",
     "vitest": "^2.1.0"