yolobox 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roger Garcia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,76 @@
+# 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.
+
+```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
+```
+
+---
+
+## Development
+
+### Setup
+
+```bash
+# Install dependencies
+npm install
+
+# Build the Docker image (only needed once, takes ~5 min)
+npm run docker:build
+
+# Link the CLI globally so you can use the `yolobox` command
+npm link
+```
+
+### Testing
+
+**End-to-end test:**
+
+```bash
+# In this repo (or any git repo)
+yolobox run --shell
+```
+
+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
+
+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)
+```
+
+Type `exit` to leave the container.
+
+**Quick verification without Docker:**
+
+```bash
+npm run build          # Compile TypeScript
+node bin/yolobox.js --help
+node bin/yolobox.js run --help
+npm test               # Run unit tests (18 tests)
+```
+
+### Build & Watch
+
+```bash
+npm run build          # One-shot build
+npm run dev            # Watch mode (rebuild on change)
+npm test               # Run tests
+```
+
+---
+
+## License
+
+MIT

package/bin/yolobox.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/index.js')

package/dist/index.js

@@ -0,0 +1,1210 @@
+// src/index.ts
+import { defineCommand as defineCommand7, runMain } from "citty";
+
+// src/commands/claude.ts
+import { defineCommand } from "citty";
+
+// src/lib/docker.ts
+import { execSync, spawnSync } from "child_process";
+function isDockerRunning() {
+  try {
+    execSync("docker info", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildDockerArgs(opts) {
+  const args = [
+    "run",
+    "-d",
+    "--name",
+    `yolobox-${opts.id}`,
+    "-v",
+    `${opts.worktreePath}:/workspace`,
+    "-v",
+    `${opts.gitDir}:/repo/.git`,
+    "-e",
+    `YOLOBOX_ID=${opts.id}`,
+    "--label",
+    "yolobox=true",
+    "--label",
+    `yolobox.path=${opts.repoPath}`
+  ];
+  if (opts.gitIdentity.name) {
+    args.push("-e", `GIT_AUTHOR_NAME=${opts.gitIdentity.name}`);
+    args.push("-e", `GIT_COMMITTER_NAME=${opts.gitIdentity.name}`);
+  }
+  if (opts.gitIdentity.email) {
+    args.push("-e", `GIT_AUTHOR_EMAIL=${opts.gitIdentity.email}`);
+    args.push("-e", `GIT_COMMITTER_EMAIL=${opts.gitIdentity.email}`);
+  }
+  args.push(opts.image);
+  args.push("sleep", "infinity");
+  return args;
+}
+function buildExecArgs(id, command) {
+  return ["exec", "-it", `yolobox-${id}`, ...command];
+}
+function startContainer(opts) {
+  const args = buildDockerArgs(opts);
+  const result = spawnSync("docker", args, { stdio: ["pipe", "pipe", "pipe"] });
+  return result.status === 0;
+}
+function execInContainer(id, command) {
+  const args = buildExecArgs(id, command);
+  const result = spawnSync("docker", args, { stdio: "inherit" });
+  return result.status ?? 1;
+}
+function timeAgo(dateStr) {
+  const date = new Date(dateStr);
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function listContainers() {
+  try {
+    const result = execSync(
+      'docker ps -a --filter "label=yolobox" --format "{{.Names}}	{{.Status}}	{{.CreatedAt}}	{{.Label \\"yolobox.path\\"}}"',
+      { encoding: "utf-8" }
+    );
+    return result.trim().split("\n").filter(Boolean).map((line) => {
+      const [name, status, created, path2] = line.split("	");
+      const id = name.replace(/^yolobox-/, "");
+      return {
+        id,
+        branch: id,
+        status: status.startsWith("Up") ? "running" : "stopped",
+        created: timeAgo(created),
+        path: path2 || ""
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function killContainer(id) {
+  const stop = spawnSync("docker", ["stop", `yolobox-${id}`], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (stop.status !== 0) return false;
+  const rm = spawnSync("docker", ["rm", `yolobox-${id}`], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return rm.status === 0;
+}
+
+// src/lib/git.ts
+import { execSync as execSync2 } from "child_process";
+function exec(cmd) {
+  return execSync2(cmd, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function isInsideGitRepo() {
+  try {
+    exec("git rev-parse --is-inside-work-tree");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRepoRoot() {
+  return exec("git rev-parse --show-toplevel");
+}
+function getGitDir() {
+  return exec("git rev-parse --git-dir");
+}
+function getBranches() {
+  const output = exec('git branch --list --format="%(refname:short)"');
+  return output.split("\n").filter(Boolean);
+}
+function initRepo() {
+  exec("git init");
+  createInitialCommit();
+}
+function hasCommits() {
+  try {
+    exec("git rev-parse HEAD");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createInitialCommit() {
+  exec('git commit --allow-empty -m "Initial commit"');
+}
+function getGitIdentity() {
+  try {
+    const name = exec("git config user.name");
+    const email = exec("git config user.email");
+    return { name, email };
+  } catch {
+    return { name: "", email: "" };
+  }
+}
+
+// src/lib/id.ts
+var ADJECTIVES = [
+  "able",
+  "adept",
+  "agile",
+  "alert",
+  "alive",
+  "ample",
+  "apt",
+  "avid",
+  "aware",
+  "azure",
+  "bare",
+  "basic",
+  "bliss",
+  "blunt",
+  "bold",
+  "brash",
+  "brave",
+  "brief",
+  "brisk",
+  "broad",
+  "busy",
+  "calm",
+  "civic",
+  "clean",
+  "clear",
+  "close",
+  "cool",
+  "core",
+  "cozy",
+  "crisp",
+  "curly",
+  "daily",
+  "dark",
+  "dear",
+  "deep",
+  "deft",
+  "dense",
+  "dizzy",
+  "dry",
+  "dual",
+  "eager",
+  "early",
+  "easy",
+  "edgy",
+  "elfin",
+  "elite",
+  "epic",
+  "equal",
+  "exact",
+  "extra",
+  "faint",
+  "fair",
+  "fancy",
+  "fast",
+  "feral",
+  "fierce",
+  "fiery",
+  "fine",
+  "firm",
+  "first",
+  "fit",
+  "fleet",
+  "fluid",
+  "flush",
+  "focal",
+  "fond",
+  "frank",
+  "free",
+  "fresh",
+  "full",
+  "fun",
+  "fuzzy",
+  "game",
+  "glad",
+  "gold",
+  "good",
+  "grand",
+  "great",
+  "green",
+  "grim",
+  "gross",
+  "grown",
+  "gusty",
+  "happy",
+  "hardy",
+  "hasty",
+  "hazel",
+  "hefty",
+  "high",
+  "home",
+  "hot",
+  "huge",
+  "human",
+  "icy",
+  "ideal",
+  "inner",
+  "ionic",
+  "iron",
+  "ivory",
+  "jade",
+  "jazzy",
+  "jolly",
+  "just",
+  "keen",
+  "kind",
+  "known",
+  "lanky",
+  "large",
+  "laser",
+  "late",
+  "leafy",
+  "lean",
+  "level",
+  "light",
+  "lithe",
+  "live",
+  "local",
+  "lone",
+  "long",
+  "loud",
+  "loyal",
+  "lucid",
+  "lucky",
+  "lunar",
+  "lusty",
+  "magic",
+  "main",
+  "major",
+  "maple",
+  "meek",
+  "merry",
+  "mild",
+  "mint",
+  "misty",
+  "mixed",
+  "modal",
+  "moist",
+  "moody",
+  "moral",
+  "muddy",
+  "muted",
+  "naive",
+  "naval",
+  "neat",
+  "new",
+  "next",
+  "nice",
+  "nimble",
+  "noble",
+  "noted",
+  "novel",
+  "oaken",
+  "odd",
+  "olive",
+  "only",
+  "open",
+  "opted",
+  "oral",
+  "other",
+  "outer",
+  "oval",
+  "own",
+  "pale",
+  "pasty",
+  "peak",
+  "perky",
+  "petty",
+  "pilot",
+  "pine",
+  "pink",
+  "plain",
+  "plumb",
+  "plump",
+  "plush",
+  "polar",
+  "polka",
+  "prime",
+  "prior",
+  "proud",
+  "pure",
+  "pushy",
+  "quick",
+  "quiet",
+  "rabid",
+  "rapid",
+  "rare",
+  "raspy",
+  "raw",
+  "ready",
+  "real",
+  "red",
+  "regal",
+  "rich",
+  "rigid",
+  "ripe",
+  "risen",
+  "risky",
+  "ritzy",
+  "rival",
+  "roast",
+  "rocky",
+  "roman",
+  "roomy",
+  "rosy",
+  "rough",
+  "round",
+  "royal",
+  "ruby",
+  "runic",
+  "rural",
+  "rusty",
+  "safe",
+  "sage",
+  "salty",
+  "same",
+  "sandy",
+  "sane",
+  "savvy",
+  "scaly",
+  "sharp",
+  "sheer",
+  "shiny",
+  "short",
+  "shy",
+  "silky",
+  "slim",
+  "slow",
+  "small",
+  "smart",
+  "smoky",
+  "snowy",
+  "snug",
+  "sober",
+  "soft",
+  "solar",
+  "solid",
+  "sonic",
+  "sorry",
+  "sound",
+  "south",
+  "spare",
+  "spicy",
+  "spry",
+  "squat",
+  "stale",
+  "stark",
+  "steel",
+  "steep",
+  "stern",
+  "stiff",
+  "still",
+  "stoic",
+  "stone",
+  "stout",
+  "suave",
+  "sunny",
+  "super",
+  "sure",
+  "sweet",
+  "swift",
+  "tall",
+  "tame",
+  "tan",
+  "tangy",
+  "tart",
+  "taut",
+  "teal",
+  "tepid",
+  "thick",
+  "thin",
+  "tidy",
+  "tight",
+  "tiny",
+  "token",
+  "top",
+  "total",
+  "tough",
+  "trim",
+  "true",
+  "tubby",
+  "twin",
+  "ultra",
+  "uncut",
+  "under",
+  "undue",
+  "unfit",
+  "upper",
+  "urban",
+  "used",
+  "usual",
+  "utter",
+  "vague",
+  "valid",
+  "vast",
+  "velvet",
+  "vivid",
+  "vocal",
+  "wacky",
+  "warm",
+  "wary",
+  "wavy",
+  "waxy",
+  "weak",
+  "weary",
+  "weird",
+  "west",
+  "wet",
+  "white",
+  "whole",
+  "wide",
+  "wild",
+  "wily",
+  "windy",
+  "wired",
+  "wise",
+  "witty",
+  "woke",
+  "woody",
+  "wry",
+  "young",
+  "zany",
+  "zappy",
+  "zeal",
+  "zen",
+  "zesty",
+  "zippy"
+];
+var NOUNS = [
+  "ace",
+  "acorn",
+  "agent",
+  "alder",
+  "alloy",
+  "amber",
+  "anvil",
+  "apex",
+  "arch",
+  "arrow",
+  "aspen",
+  "atlas",
+  "atom",
+  "axle",
+  "badge",
+  "basin",
+  "bass",
+  "beam",
+  "bench",
+  "birch",
+  "blade",
+  "blaze",
+  "bloom",
+  "bluff",
+  "board",
+  "bolt",
+  "bond",
+  "bower",
+  "brace",
+  "brand",
+  "brass",
+  "brick",
+  "brook",
+  "brush",
+  "bugle",
+  "cairn",
+  "canal",
+  "cape",
+  "cargo",
+  "cedar",
+  "chain",
+  "charm",
+  "chess",
+  "chime",
+  "chord",
+  "clamp",
+  "clay",
+  "cliff",
+  "clock",
+  "cloud",
+  "clove",
+  "coach",
+  "coast",
+  "comet",
+  "coral",
+  "core",
+  "crane",
+  "crate",
+  "creek",
+  "crest",
+  "cross",
+  "crown",
+  "crush",
+  "crypt",
+  "cube",
+  "curve",
+  "cycle",
+  "darts",
+  "dawn",
+  "delta",
+  "depot",
+  "dew",
+  "digit",
+  "dingo",
+  "disk",
+  "ditch",
+  "dock",
+  "dome",
+  "dove",
+  "draft",
+  "drake",
+  "drift",
+  "drone",
+  "drum",
+  "dune",
+  "dwarf",
+  "eagle",
+  "earth",
+  "easel",
+  "edge",
+  "elm",
+  "ember",
+  "facet",
+  "fawn",
+  "ferry",
+  "fiber",
+  "finch",
+  "fjord",
+  "flame",
+  "flask",
+  "flax",
+  "fleet",
+  "flint",
+  "flock",
+  "flora",
+  "flute",
+  "focus",
+  "forge",
+  "fort",
+  "frame",
+  "frost",
+  "fruit",
+  "gale",
+  "gauge",
+  "gavel",
+  "gecko",
+  "geyser",
+  "ghost",
+  "glade",
+  "gleam",
+  "glint",
+  "globe",
+  "glyph",
+  "gnome",
+  "goose",
+  "gorge",
+  "grain",
+  "grape",
+  "graph",
+  "grasp",
+  "grove",
+  "guild",
+  "gull",
+  "gusto",
+  "haven",
+  "hawk",
+  "hazel",
+  "heath",
+  "hedge",
+  "heron",
+  "hinge",
+  "holly",
+  "hound",
+  "hull",
+  "hyena",
+  "index",
+  "ingot",
+  "inlet",
+  "ivory",
+  "jay",
+  "jewel",
+  "joint",
+  "kelp",
+  "ketch",
+  "knack",
+  "knoll",
+  "knot",
+  "kraft",
+  "lance",
+  "larch",
+  "lark",
+  "latch",
+  "lathe",
+  "ledge",
+  "lever",
+  "light",
+  "lilac",
+  "linen",
+  "links",
+  "llama",
+  "lodge",
+  "loft",
+  "lotus",
+  "lunar",
+  "lynch",
+  "lynx",
+  "mango",
+  "manor",
+  "maple",
+  "marsh",
+  "mast",
+  "maxim",
+  "mesa",
+  "meter",
+  "mills",
+  "miner",
+  "mint",
+  "mirth",
+  "moat",
+  "model",
+  "molar",
+  "moose",
+  "morph",
+  "morse",
+  "motor",
+  "mound",
+  "mulch",
+  "mural",
+  "myrrh",
+  "nerve",
+  "nexus",
+  "niche",
+  "node",
+  "notch",
+  "novel",
+  "oak",
+  "oasis",
+  "ocean",
+  "olive",
+  "onset",
+  "onyx",
+  "opera",
+  "orbit",
+  "orca",
+  "osprey",
+  "otter",
+  "oxide",
+  "ozone",
+  "panda",
+  "panel",
+  "patch",
+  "path",
+  "pearl",
+  "pecan",
+  "perch",
+  "phase",
+  "pilot",
+  "pine",
+  "pixel",
+  "plank",
+  "plant",
+  "plaza",
+  "plume",
+  "point",
+  "polar",
+  "pond",
+  "poppy",
+  "port",
+  "pouch",
+  "press",
+  "prism",
+  "probe",
+  "prose",
+  "prowl",
+  "pulse",
+  "pylon",
+  "quail",
+  "quest",
+  "quill",
+  "quota",
+  "rafter",
+  "rail",
+  "range",
+  "raven",
+  "realm",
+  "reed",
+  "reef",
+  "reign",
+  "relay",
+  "ridge",
+  "rivet",
+  "robin",
+  "roost",
+  "rover",
+  "ruby",
+  "sage",
+  "sail",
+  "salon",
+  "scale",
+  "scone",
+  "scope",
+  "scout",
+  "seal",
+  "sedge",
+  "shade",
+  "shaft",
+  "shell",
+  "shelf",
+  "shoal",
+  "shore",
+  "shrew",
+  "shrub",
+  "sigma",
+  "siren",
+  "skimp",
+  "slate",
+  "sleet",
+  "slope",
+  "smith",
+  "snare",
+  "solar",
+  "sonic",
+  "spark",
+  "spear",
+  "spire",
+  "spoke",
+  "spore",
+  "spray",
+  "squid",
+  "staff",
+  "stage",
+  "stake",
+  "stalk",
+  "steam",
+  "steel",
+  "stern",
+  "stone",
+  "storm",
+  "stove",
+  "stump",
+  "surge",
+  "swamp",
+  "swift",
+  "thorn",
+  "tiger",
+  "tile",
+  "timer",
+  "token",
+  "torch",
+  "totem",
+  "tower",
+  "trace",
+  "trail",
+  "trend",
+  "tribe",
+  "trout",
+  "trunk",
+  "tulip",
+  "tundra",
+  "tuner",
+  "tweed",
+  "twig",
+  "umbra",
+  "union",
+  "valve",
+  "vapor",
+  "vault",
+  "venom",
+  "verge",
+  "verse",
+  "vigor",
+  "vine",
+  "viola",
+  "viper",
+  "visor",
+  "vivid",
+  "vortex",
+  "wafer",
+  "warden",
+  "watch",
+  "wedge",
+  "whale",
+  "wheat",
+  "wheel",
+  "whirl",
+  "wicker",
+  "willow",
+  "wing",
+  "wren",
+  "yacht",
+  "yew",
+  "yield",
+  "zebra",
+  "zinc",
+  "zone"
+];
+function randomElement(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function generateId(existingIds, maxRetries = 100) {
+  for (let i = 0; i < maxRetries; i++) {
+    const id = `${randomElement(ADJECTIVES)}-${randomElement(NOUNS)}`;
+    if (!existingIds.has(id)) return id;
+  }
+  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";
+import path from "path";
+function exec2(cmd, cwd) {
+  return execSync3(cmd, {
+    encoding: "utf-8",
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function createWorktree(repoRoot, id) {
+  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);
+  return worktreePath;
+}
+function ensureGitignore(repoRoot) {
+  const gitignorePath = path.join(repoRoot, ".gitignore");
+  const entry = ".yolobox/";
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, "utf-8");
+    if (content.includes(entry)) return;
+    const separator = content.endsWith("\n") ? "" : "\n";
+    fs.appendFileSync(gitignorePath, `${separator}${entry}
+`);
+  } else {
+    fs.writeFileSync(gitignorePath, `${entry}
+`);
+  }
+}
+function getExistingWorktreeIds(repoRoot) {
+  const yoloboxDir = path.join(repoRoot, ".yolobox");
+  if (!fs.existsSync(yoloboxDir)) return [];
+  return fs.readdirSync(yoloboxDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+}
+
+// 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.");
+    process.exit(1);
+  }
+  success("Docker is running");
+  if (!isInsideGitRepo()) {
+    const shouldInit = await p.confirm({
+      message: "No git repo found. Initialize one here?"
+    });
+    if (p.isCancel(shouldInit) || !shouldInit) {
+      error("yolobox needs a git repo for worktrees.");
+      process.exit(1);
+    }
+    initRepo();
+    success("Initialized git repo");
+  } else {
+    success("Git repo detected");
+  }
+  if (!hasCommits()) {
+    createInitialCommit();
+    success("Created initial commit");
+  }
+  const repoRoot = getRepoRoot();
+  const gitDir = getGitDir();
+  let id;
+  if (options.name) {
+    id = options.name;
+  } else {
+    const branches = new Set(getBranches());
+    const existingWorktrees = new Set(getExistingWorktreeIds(repoRoot));
+    const taken = /* @__PURE__ */ new Set([...branches, ...existingWorktrees]);
+    id = generateId(taken);
+  }
+  const worktreePath = createWorktree(repoRoot, id);
+  success(`Created worktree .yolobox/${id} (branch: ${id})`);
+  ensureGitignore(repoRoot);
+  const gitIdentity = getGitIdentity();
+  const started = startContainer({
+    id,
+    worktreePath,
+    gitDir,
+    gitIdentity,
+    image: DOCKER_IMAGE,
+    repoPath: repoRoot
+  });
+  if (!started) {
+    error("Failed to start container.");
+    process.exit(1);
+  }
+  return { id, repoRoot };
+}
+
+// src/commands/claude.ts
+var claude_default = defineCommand({
+  meta: {
+    name: "claude",
+    description: "Launch Claude Code with skip permissions"
+  },
+  args: {
+    prompt: {
+      type: "string",
+      alias: "p",
+      description: "Pass an initial prompt to Claude"
+    },
+    name: {
+      type: "string",
+      alias: "n",
+      description: "Use a specific name instead of random"
+    }
+  },
+  run: async ({ args }) => {
+    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);
+  }
+});
+
+// src/commands/help.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { defineCommand as defineCommand2 } from "citty";
+var help_default = defineCommand2({
+  meta: {
+    name: "help",
+    description: "Show help information"
+  },
+  run: async () => {
+    const result = spawnSync2(process.argv[0], [process.argv[1], "--help"], {
+      stdio: "inherit"
+    });
+    process.exit(result.status || 0);
+  }
+});
+
+// src/commands/kill.ts
+import { defineCommand as defineCommand3 } from "citty";
+var kill_default = defineCommand3({
+  meta: {
+    name: "kill",
+    description: "Stop and remove a running yolobox container"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "The yolobox ID to kill",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const id = args.id;
+    const killed = killContainer(id);
+    if (!killed) {
+      error(`Failed to kill yolobox-${id}. Is it running?`);
+      process.exit(1);
+    }
+    success(`Killed yolobox-${id}`);
+  }
+});
+
+// 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;
+  if (display.length <= maxLen) return display;
+  const parts = display.split("/");
+  let short = "";
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const candidate = parts.slice(i).join("/");
+    if (candidate.length > maxLen - 2) break;
+    short = candidate;
+  }
+  return short ? `\u2026/${short}` : `\u2026/${parts[parts.length - 1]}`;
+}
+var ls_default = defineCommand4({
+  meta: {
+    name: "ls",
+    description: "List running yolobox containers"
+  },
+  run: async () => {
+    if (!isDockerRunning()) {
+      error("Docker is not running.");
+      process.exit(1);
+    }
+    const containers = listContainers();
+    if (containers.length === 0) {
+      info("No yolobox containers found.");
+      return;
+    }
+    const paths = containers.map((c) => shortenPath(c.path));
+    const idW = Math.max(4, ...containers.map((c) => c.id.length)) + 2;
+    const branchW = Math.max(8, ...containers.map((c) => c.branch.length)) + 2;
+    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));
+    for (let i = 0; i < containers.length; i++) {
+      const c = containers[i];
+      const statusColor = c.status === "running" ? pc.green : pc.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])}`
+      );
+    }
+  }
+});
+
+// src/commands/nuke.ts
+import { defineCommand as defineCommand5 } from "citty";
+var nuke_default = defineCommand5({
+  meta: {
+    name: "nuke",
+    description: "Kill all yolobox containers from the current directory"
+  },
+  args: {
+    all: {
+      type: "boolean",
+      description: "Kill all yolobox containers from all directories",
+      default: false
+    }
+  },
+  run: async ({ args }) => {
+    intro2("yolobox nuke");
+    if (!isDockerRunning()) {
+      error("Docker is not running. Please start Docker and try again.");
+      process.exit(1);
+    }
+    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
+      );
+      locationDescription = `from ${currentPath}`;
+    }
+    if (matchingContainers.length === 0) {
+      const message = args.all ? "No yolobox containers found." : "No yolobox containers found from this directory.";
+      info(message);
+      process.exit(0);
+    }
+    console.log(
+      `
+Found ${matchingContainers.length} container${matchingContainers.length === 1 ? "" : "s"} ${locationDescription}:
+`
+    );
+    for (const container of matchingContainers) {
+      const pathDisplay = args.all ? ` [${container.path}]` : "";
+      console.log(
+        `  ${container.id} (${container.branch}) - ${container.status}${pathDisplay}`
+      );
+    }
+    console.log();
+    const confirmed = await p.confirm({
+      message: `Kill all ${matchingContainers.length} container${matchingContainers.length === 1 ? "" : "s"}?`,
+      initialValue: false
+    });
+    if (!confirmed || p.isCancel(confirmed)) {
+      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 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"}.`
+      );
+      process.exit(0);
+    } else {
+      error(
+        `Killed ${successCount} container${successCount === 1 ? "" : "s"}, but ${failureCount} failed.`
+      );
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/run.ts
+import { defineCommand as defineCommand6 } from "citty";
+var run_default = defineCommand6({
+  meta: {
+    name: "run",
+    description: "Launch a shell in a new yolobox"
+  },
+  args: {
+    name: {
+      type: "string",
+      alias: "n",
+      description: "Use a specific name instead of random"
+    }
+  },
+  run: async ({ args }) => {
+    const { id } = await setupContainer({ name: args.name });
+    outro2(`Launching shell in ${id}...`);
+    execInContainer(id, ["bash"]);
+  }
+});
+
+// src/index.ts
+var main = defineCommand7({
+  meta: {
+    name: "yolobox",
+    version: "0.0.1",
+    description: "Run Claude Code in Docker containers. YOLO safely."
+  },
+  subCommands: {
+    run: run_default,
+    claude: claude_default,
+    kill: kill_default,
+    ls: ls_default,
+    help: help_default,
+    nuke: nuke_default
+  }
+});
+runMain(main);

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "yolobox",
+  "version": "0.1.0",
+  "description": "Run Claude Code in a Docker container with --dangerously-skip-permissions. YOLO safely.",
+  "type": "module",
+  "bin": {
+    "yolobox": "./bin/yolobox.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "test": "vitest",
+    "docker:build": "docker build -t yolobox:local -f docker/Dockerfile docker/",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "citty": "^0.1.6",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/roginn/yolobox.git"
+  },
+  "keywords": [
+    "claude",
+    "code",
+    "sandbox",
+    "docker",
+    "container",
+    "cli"
+  ],
+  "author": "Roger Garcia <npm@rawrger.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/roginn/yolobox/issues"
+  },
+  "homepage": "https://github.com/roginn/yolobox#readme"
+}