kanibako-cli 1.5.0.dev14__py3-none-any.whl

kanibako/bun_sea.py

@@ -0,0 +1,144 @@
+"""Extract embedded modules from Bun SEA (Single Executable Application) binaries.
+
+Bun SEA format (ELF/Mach-O/PE):
+
+    [native binary][bun data...][OFFSETS (32 bytes)]["\\n---- Bun! ----\\n"][u64 totalByteCount]
+
+OFFSETS struct (32 bytes):
+    u64 byteCount          — size of the data blob
+    u32 modulesPtr.offset  — module table offset from data start
+    u32 modulesPtr.length  — module table size in bytes
+    u32 entryPointId       — index of the entry module
+    u32 compileExecArgvPtr.offset
+    u32 compileExecArgvPtr.length
+    u32 flags
+
+Module struct (52 bytes, Bun >= 1.3.7):
+    StringPointer name      (offset u32, length u32)
+    StringPointer contents  (offset u32, length u32)
+    StringPointer sourcemap (offset u32, length u32)
+    StringPointer bytecode  (offset u32, length u32)
+    StringPointer moduleInfo (offset u32, length u32)
+    StringPointer bytecodeOriginPath (offset u32, length u32)
+    4 bytes enum/flags
+
+All offsets are relative to data_start.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+
+_BUN_MARKER = b"\n---- Bun! ----\n"
+_OFFSETS_SIZE = 32
+_MODULE_STRUCT_SIZE = 52
+
+
+class BunSEAError(Exception):
+    """Error parsing a Bun SEA binary."""
+
+
+@dataclass
+class BunModule:
+    """A module embedded in a Bun SEA binary."""
+
+    name: str
+    content_offset: int  # absolute file offset
+    content_length: int
+
+
+def _parse_header(f) -> tuple[int, int, int]:
+    """Parse the Bun SEA trailer and return (data_start, modules_offset, modules_length).
+
+    All returned offsets are absolute file positions.
+    """
+    f.seek(0, 2)
+    size = f.tell()
+    trailer_size = 8 + len(_BUN_MARKER) + _OFFSETS_SIZE
+    if size < trailer_size:
+        raise BunSEAError("File too small to be a Bun SEA binary")
+
+    # Read marker
+    f.seek(-(8 + len(_BUN_MARKER)), 2)
+    marker = f.read(len(_BUN_MARKER))
+    if marker != _BUN_MARKER:
+        raise BunSEAError("Bun SEA marker not found")
+
+    # Read OFFSETS
+    f.seek(-(8 + len(_BUN_MARKER) + _OFFSETS_SIZE), 2)
+    offsets = f.read(_OFFSETS_SIZE)
+    byte_count = struct.unpack("<Q", offsets[0:8])[0]
+    mod_off = struct.unpack("<I", offsets[8:12])[0]
+    mod_len = struct.unpack("<I", offsets[12:16])[0]
+
+    marker_abs = size - 8 - len(_BUN_MARKER)
+    data_start = marker_abs - _OFFSETS_SIZE - byte_count
+    if data_start < 0:
+        raise BunSEAError(
+            f"Invalid data_start ({data_start}): byteCount={byte_count} exceeds file size"
+        )
+
+    return data_start, data_start + mod_off, mod_len
+
+
+def list_modules(binary_path: Path) -> list[BunModule]:
+    """List all modules embedded in a Bun SEA binary."""
+    with open(binary_path, "rb") as f:
+        data_start, modules_abs, modules_len = _parse_header(f)
+
+        if modules_len % _MODULE_STRUCT_SIZE != 0:
+            raise BunSEAError(
+                f"Module table size {modules_len} not divisible by {_MODULE_STRUCT_SIZE}"
+            )
+        n_modules = modules_len // _MODULE_STRUCT_SIZE
+
+        f.seek(modules_abs)
+        table = f.read(modules_len)
+
+        modules: list[BunModule] = []
+        for i in range(n_modules):
+            base = i * _MODULE_STRUCT_SIZE
+            name_off = struct.unpack("<I", table[base : base + 4])[0]
+            name_len = struct.unpack("<I", table[base + 4 : base + 8])[0]
+            c_off = struct.unpack("<I", table[base + 8 : base + 12])[0]
+            c_len = struct.unpack("<I", table[base + 12 : base + 16])[0]
+
+            f.seek(data_start + name_off)
+            name = f.read(name_len).decode("utf-8", errors="replace")
+
+            modules.append(BunModule(
+                name=name,
+                content_offset=data_start + c_off,
+                content_length=c_len,
+            ))
+
+        return modules
+
+
+def extract_module(binary_path: Path, name_suffix: str = "cli.js") -> bytes:
+    """Extract a module's content by name suffix (default: cli.js)."""
+    modules = list_modules(binary_path)
+    for mod in modules:
+        if mod.name.endswith(name_suffix):
+            with open(binary_path, "rb") as f:
+                f.seek(mod.content_offset)
+                return f.read(mod.content_length)
+    available = [m.name for m in modules]
+    raise BunSEAError(
+        f"Module ending with '{name_suffix}' not found. "
+        f"Available: {available}"
+    )
+
+
+def extract_cli_js(binary_path: Path) -> bytes:
+    """Extract the cli.js bundle from a Bun SEA binary."""
+    return extract_module(binary_path, "cli.js")
+
+
+def cli_js_hash(binary_path: Path) -> str:
+    """Return the SHA-256 hex digest of the cli.js content."""
+    content = extract_cli_js(binary_path)
+    return hashlib.sha256(content).hexdigest()

kanibako/cli.py

@@ -0,0 +1,344 @@
+"""Full argparse tree with subparsers, dispatcher, and main() entry point."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+
+from kanibako import __version__
+from kanibako.errors import KanibakoError, UserCancelled
+
+
+class _Formatter(argparse.RawDescriptionHelpFormatter):
+    """Wider action column so subcommand help text stays on one line."""
+
+    def __init__(self, prog: str, **kwargs: Any) -> None:
+        kwargs.setdefault("max_help_position", 30)
+        super().__init__(prog, **kwargs)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="kanibako",
+        description="Safe, persistent workspaces for AI coding agents.",
+        epilog=(
+            "COMMANDS\n"
+            "    rig         Manage box rigs (images)\n"
+            "    box         Project lifecycle commands for boxes (containers)\n"
+            "    crab        Crab (agent) management, authentication, and settings\n"
+            "    workset     Project grouping\n"
+            "    system      Global configuration, upgrades, and system information\n"
+            "\n"
+            "SHORTCUTS (equivalent to 'box <command>'):\n"
+            "    create      Create a new project box\n"
+            "    list        List active and/or inactive boxes\n"
+            "    ps          List active (running) boxes\n"
+            "    rm          Remove a box\n"
+            "\n"
+            "    start       Start a box session (default)\n"
+            "    stop        Stop a running box session\n"
+            "    shell       Open a shell in a box\n"
+            "\n"
+            "ALIASES:\n"
+            "    agent       → crab\n"
+            "    container   → box\n"
+            "    image       → rig\n"
+            "\n"
+            "common switches (for 'start' command):\n"
+            "  -N, --new           start a new conversation\n"
+            "  -C, --continue      continue the most recent conversation (default)\n"
+            "  -R, --resume        resume with conversation picker\n"
+            "  -A, --autonomous    run with full permissions (default)\n"
+            "  -S, --secure        run without --dangerously-skip-permissions\n"
+            "  -M, --model MODEL   override the agent model for this run\n"
+            "  -v, --verbose       show debug output (target detection, container cmd)\n"
+            "\n"
+            "run 'kanibako COMMAND --help' for subcommand-specific options"
+        ),
+        formatter_class=_Formatter,
+        add_help=False,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", metavar="COMMAND")
+
+    # Import and register all subcommand parsers.
+    from kanibako.commands.start import (
+        add_shell_parser,
+        add_start_parser,
+    )
+    from kanibako.commands.image import add_parser as add_rig_parser
+    from kanibako.commands.box import add_parser as add_box_parser
+    from kanibako.commands.box._parser import run_create, run_list as run_list_fn, run_ps, run_rm
+    from kanibako.commands.stop import add_parser as add_stop_parser
+    from kanibako.commands.workset_cmd import add_parser as add_workset_parser
+    from kanibako.commands.crab_cmd import add_parser as add_crab_parser
+    from kanibako.commands.system_cmd import add_parser as add_system_parser
+
+    # Setup wizard (before management commands, works pre-init).
+    from kanibako.commands.setup_cmd import run_setup
+    setup_p = subparsers.add_parser("setup", help="Run the setup wizard")
+    setup_p.set_defaults(func=run_setup)
+
+    # Top-level aliases (start, shell, stop already have their own parsers).
+    add_start_parser(subparsers)
+    add_shell_parser(subparsers)
+    add_stop_parser(subparsers)
+
+    # list — top-level shortcut for box list
+    list_p = subparsers.add_parser("list", help="List active and/or inactive boxes")
+    list_p.add_argument(
+        "--active", action="store_true",
+        help="Show only active (running) boxes",
+    )
+    list_p.add_argument(
+        "--all", "-a", action="store_true", dest="show_all",
+        help="Include orphaned boxes",
+    )
+    list_p.add_argument(
+        "-q", "--quiet", action="store_true",
+        help="Output box names only, one per line",
+    )
+    list_p.set_defaults(func=run_list_fn)
+
+    # ps — top-level shortcut for box list --active
+    ps_p = subparsers.add_parser("ps", help="List active (running) boxes")
+    ps_p.add_argument(
+        "--all", "-a", action="store_true", dest="show_all",
+        help="Show all boxes (active and inactive)",
+    )
+    ps_p.add_argument(
+        "-q", "--quiet", action="store_true",
+        help="Output box names only, one per line",
+    )
+    ps_p.set_defaults(func=run_ps)
+
+    # create — top-level alias for box create
+    create_p = subparsers.add_parser("create", help="Create a new project")
+    create_p.add_argument(
+        "path", nargs="?", default=None,
+        help="Project directory (default: cwd). Created if it doesn't exist.",
+    )
+    create_p.add_argument(
+        "--standalone", action="store_true",
+        help="Use standalone mode (all state inside the project directory)",
+    )
+    create_p.add_argument(
+        "--name", default=None,
+        help="Project name override (default: auto-assigned from directory name)",
+    )
+    create_p.add_argument(
+        "-i", "--image", default=None,
+        help="Container image to use for this project",
+    )
+    create_p.add_argument(
+        "--no-vault", action="store_true",
+        help="Disable vault directories",
+    )
+    create_p.add_argument(
+        "--distinct-auth", action="store_true",
+        help="Use distinct credentials (no sync from host)",
+    )
+    create_p.add_argument(
+        "--allow-home", action="store_true",
+        help="Permit a standalone project rooted at $HOME (mounts your entire "
+             "home directory; required to create one there)",
+    )
+    create_p.set_defaults(func=run_create)
+
+    # rm — top-level alias for box rm
+    rm_p = subparsers.add_parser("rm", help="Remove a project")
+    rm_p.add_argument("target", help="Project name or workspace path to remove")
+    rm_p.add_argument(
+        "--purge", action="store_true",
+        help="Also delete kanibako metadata for this project",
+    )
+    rm_p.add_argument(
+        "--force", action="store_true",
+        help="Skip confirmation prompt (only relevant with --purge)",
+    )
+    rm_p.set_defaults(func=run_rm)
+
+    # Management commands.
+    add_rig_parser(subparsers)
+    add_box_parser(subparsers)
+    add_workset_parser(subparsers)
+    add_crab_parser(subparsers)
+    add_system_parser(subparsers)
+
+    return parser
+
+
+_COMMAND_ALIASES: dict[str, str] = {
+    "agent": "crab",
+    "image": "rig",
+    "container": "box",
+}
+
+_SUBCOMMANDS = {
+    # Top-level aliases (delegate to box subcommands).
+    "start", "stop", "shell", "ps", "list", "create", "rm",
+    # Management commands.
+    "box", "rig", "workset", "crab", "system",
+    # Command aliases (#62).
+    "agent", "image", "container",
+    # Setup wizard.
+    "setup",
+}
+
+
+def _ensure_initialized() -> None:
+    """Ensure kanibako is initialized (create config + data dirs on first run)."""
+    from kanibako.config import (
+        KanibakoConfig,
+        config_file_path,
+        write_global_config,
+    )
+    from pathlib import Path
+
+    from kanibako.paths import resolve_system_paths, xdg
+
+    config_home = xdg("XDG_CONFIG_HOME", ".config")
+    cf = config_file_path(config_home)
+
+    if cf.exists():
+        return  # Already initialized
+
+    # First run: create config and data dirs
+    config = KanibakoConfig()
+    write_global_config(cf, config)
+
+    # Create data directories
+    data_home = xdg("XDG_DATA_HOME", ".local/share")
+    sys_paths = resolve_system_paths(
+        config.system_paths, data_home=data_home, home=Path.home(),
+    )
+    data_path = sys_paths["system.path.data"]
+    (data_path / "containers").mkdir(parents=True, exist_ok=True)
+    sys_paths["system.path.boxes"].mkdir(parents=True, exist_ok=True)
+
+    templates_dir = sys_paths["system.path.templates"]
+    (templates_dir / "general" / "base").mkdir(parents=True, exist_ok=True)
+    (templates_dir / "general" / "standard").mkdir(parents=True, exist_ok=True)
+
+    comms_dir = sys_paths["system.path.comms"]
+    (comms_dir / "mailbox").mkdir(parents=True, exist_ok=True)
+    (comms_dir / "broadcast.log").touch(exist_ok=True)
+
+    # Create crabs directory and generate default crab TOMLs.
+    from kanibako.crabs import CrabConfig, write_crab_config
+    from kanibako.targets import discover_targets
+
+    crabs_path = sys_paths["system.path.crabs"]
+    crabs_path.mkdir(parents=True, exist_ok=True)
+
+    general_toml = crabs_path / "general.yaml"
+    if not general_toml.exists():
+        write_crab_config(general_toml, CrabConfig(name="Shell"))
+
+    for target_name, cls in discover_targets().items():
+        target_toml = crabs_path / f"{target_name}.yaml"
+        if not target_toml.exists():
+            crab_cfg = cls().generate_crab_config()
+            write_crab_config(target_toml, crab_cfg)
+        else:
+            crab_cfg = CrabConfig()
+        (templates_dir / target_name / crab_cfg.shell).mkdir(
+            parents=True, exist_ok=True,
+        )
+
+    # Seed default global environment variables (don't overwrite existing).
+    from kanibako.shellenv import read_env_file, write_env_file
+
+    global_env_path = data_path / "env"
+    global_env = read_env_file(global_env_path)
+    for key, value in {"COLORTERM": "truecolor"}.items():
+        global_env.setdefault(key, value)
+    write_env_file(global_env_path, global_env)
+
+    # Try shell completion
+    try:
+        from kanibako.commands.install import _install_completion
+
+        _install_completion()
+    except Exception:
+        pass
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+
+    try:
+        import argcomplete
+        argcomplete.autocomplete(parser)
+    except ImportError:
+        pass
+
+    effective = list(argv if argv is not None else sys.argv[1:])
+
+    # Extract -v/--verbose before subcommand dispatch.
+    verbose = "-v" in effective or "--verbose" in effective
+    effective = [a for a in effective if a not in ("-v", "--verbose")]
+
+    from kanibako.log import setup_logging
+    setup_logging(verbose=verbose)
+
+    # Handle top-level --help and --version before argparse dispatch
+    # (kept off the parser so they don't appear in tab-completion).
+    if effective and effective[0] in ("-h", "--help"):
+        parser.print_help()
+        sys.exit(0)
+    elif effective and effective[0] == "--version":
+        print(f"kanibako {__version__}")
+        sys.exit(0)
+    else:
+        # If the first arg isn't a known subcommand, default to "start".
+        if not effective or effective[0] not in _SUBCOMMANDS:
+            effective = ["start"] + effective
+        # Translate command aliases (e.g. agent→crab, image→rig).
+        if effective and effective[0] in _COMMAND_ALIASES:
+            effective[0] = _COMMAND_ALIASES[effective[0]]
+
+        # For start/shell, split args at '--' so flags after the project
+        # positional still work (REMAINDER would otherwise swallow them).
+        # Everything before '--' goes to argparse; everything after becomes
+        # args passed to the agent/shell.
+        post_dash: list[str] | None = None
+        if (
+            len(effective) >= 2
+            and effective[0] in ("start", "shell")
+            and "--" in effective[1:]
+        ):
+            idx = effective.index("--", 1)
+            post_dash = effective[idx + 1:]
+            effective = effective[:idx]
+
+        args = parser.parse_args(effective)
+        if args.command == "start":
+            args.agent_args = post_dash or []
+        elif args.command == "shell":
+            args.shell_args = post_dash or []
+
+        # Lazy init: create config + data dirs on first run.
+        # Skip for crab (helper/fork run inside containers).
+        if args.command not in ("crab", "setup"):
+            _ensure_initialized()
+
+    func = getattr(args, "func", None)
+    if func is None:
+        parser.print_help()
+        sys.exit(0)
+
+    try:
+        rc = func(args)
+    except UserCancelled:
+        print("Aborted.")
+        rc = 2
+    except KanibakoError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        rc = 1
+    except KeyboardInterrupt:
+        print()
+        rc = 130
+
+    sys.exit(rc)