kanibako-cli 1.5.0.dev14__tar.gz → 1.5.1__tar.gz

{kanibako_cli-1.5.0.dev14/src/kanibako_cli.egg-info → kanibako_cli-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kanibako-cli
-Version: 1.5.0.dev14
+Version: 1.5.1
 Summary: Run AI coding agents in rootless containers with per-project isolation
 Requires-Python: >=3.11
 License-File: LICENSE.md

{kanibako_cli-1.5.0.dev14 → kanibako_cli-1.5.1}/README.md

@@ -222,11 +222,13 @@ shortcuts for common operations:
 | `box config` | View or modify project configuration |
 | `box diagnose [project]` | Check project box health |
 
-**Relocation:**
+**Relocation & conversion:**
 
 | Subcommand | Description |
 |------------|-------------|
-| `box move [project] <dest>` | Relocate project workspace |
+| `box remap <old> [<new>]` | Update kanibako's recorded path after you moved the folder yourself (records only, no file move; `<new>` defaults to `./`) |
+| `box move <old> <new>` / `box mv` | Physically relocate the workspace (both paths required; a target flag also changes ownership) |
+| `box convert [<old>] (--default \| --standalone \| --workset <ws>)` | Change ownership/mode (in-place by default; `--move [path]` relocates, bare `--move` moves into the target workset; `--name` renames) |
 | `box duplicate <source> [dest]` | Copy project (`--name`, `--bare`, `--force`) |
 | `box archive [project]` | Pack session data to .txz (`--all`, `--allow-uncommitted`, `--allow-unpushed`, `--force`) |
 | `box extract <archive> [dest]` | Unpack from archive (`--name`, `--force`) |
@@ -248,7 +250,7 @@ shortcuts for common operations:
 | `rig list` / `rig ls` | List available rigs (`-q`) |
 | `rig info` / `rig inspect` | Rig details (source, size, recoverability) |
 | `rig rm` / `rig delete` | Remove rig (`--force`) |
-| `rig rebuild [rig]` | Rebuild from registry or stored Containerfile (`--all`) |
+| `rig rebuild [rig]` | Rebuild a template, or pull a prefab/base from the registry (`--all`) |
 | `rig diagnose` | Check rig (image) status |
 
 ### `workset` Subcommands
@@ -437,13 +439,17 @@ Container rigs are built on [Droste](https://github.com/doctorjei/droste), a
 layered OCI image builder.
 [Kento](https://github.com/doctorjei/kento) converts them to LXC/VM hosts.
 
-Rigs are pulled automatically from GHCR on first use.  If the pull fails,
-Kanibako falls back to a local build from the bundled Containerfiles.
+Base rigs are pulled automatically from GHCR on first use; they are
+**pull-only** (Kanibako does not build them locally). If a pull fails, Kanibako
+reports an actionable error. To use a custom base, build it yourself from the
+[kanibako-images](https://github.com/doctorjei/kanibako-images) repo and point
+Kanibako at the resulting local image via `--image` / `box_image`. Toolchain
+*templates* still build locally (they layer on a pulled base).
 
 ```bash
 kanibako rig list                     # show local rigs
-kanibako rig rebuild                  # rebuild current project's rig
-kanibako rig rebuild --all            # rebuild all known rigs
+kanibako rig rebuild                  # build the current template / pull the current base
+kanibako rig rebuild --all            # update all known rigs
 ```
 
 ### Custom Rigs
@@ -802,6 +808,7 @@ All kanibako config files are YAML.
 | `autonomous` | `true` | Enable autonomy override |
 | `persistence` | `persistent` | Session type (persistent/ephemeral) |
 | `box.image` | `kanibako-oci:latest` | Container rig |
+| `box.shell` | `$KANIBAKO_SHELL` | Shell launched for a no-agent box (`kanibako start` with no agent, `kanibako shell`); resolved `box.shell` → `$KANIBAKO_SHELL` → the image's recorded login shell → `sh` |
 | `box.crab` | (auto-detect) | Agent target plugin |
 | `box.share_images` | | Share host images into the box |
 | `group_auth` | `true` | Shared credentials across the group (`true`) vs. per-project (`false`) |

{kanibako_cli-1.5.0.dev14 → kanibako_cli-1.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kanibako-cli"
-version = "1.5.0.dev14"
+version = "1.5.1"
 description = "Run AI coding agents in rootless containers with per-project isolation"
 requires-python = ">=3.11"
 dependencies = ["argcomplete>=3.0", "PyYAML>=6.0"]
@@ -22,8 +22,9 @@ dev = ["pytest>=7.0", "pytest-cov", "mypy", "ruff", "bump2version"]
 where = ["src"]
 
 [tool.setuptools.package-data]
-"kanibako.containers" = ["Containerfile.*"]
+"kanibako.containers" = ["Containerfile.*", "tmux.conf"]
 "kanibako.scripts" = ["*.sh", "kanibako-entry"]
+"kanibako.data" = ["*.yaml"]
 
 [tool.ruff]
 target-version = "py311"

{kanibako_cli-1.5.0.dev14 → kanibako_cli-1.5.1}/src/kanibako/__init__.py

@@ -1,3 +1,3 @@
 """kanibako: Run AI coding agents in rootless containers with per-project isolation."""
 
-__version__ = "1.5.0.dev14"
+__version__ = "1.5.1"

kanibako_cli-1.5.1/src/kanibako/_atomic.py

@@ -0,0 +1,62 @@
+"""Atomic file writes for persistent state.
+
+A crash mid-write with a plain ``path.write_text(...)`` leaves a torn/truncated
+file that the next run fails to parse.  Writing to a temp file in the *same
+directory* and then ``os.replace``-ing it over the target is atomic on POSIX
+(``rename(2)`` within one filesystem), so a reader sees either the old file or
+the new one — never a half-written one.
+
+These helpers are dependency-free (only the stdlib) so any module can route its
+registry/state writes through them without risking an import cycle.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+import yaml
+
+
+def atomic_write_text(path: Path, data: str) -> None:
+    """Write *data* to *path* atomically.
+
+    The bytes land in a temp file in ``path.parent`` (so ``os.replace`` stays on
+    one filesystem), are flushed and ``fsync``-ed, then renamed over *path*.  On
+    any failure the temp file is removed and the original *path* is left intact.
+    Parent directories are created if needed.
+    """
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    encoded = data.encode("utf-8")
+    # Create the temp file in the SAME directory as the target so os.replace is
+    # a same-filesystem rename (atomic).  delete=False so we control the rename.
+    fd, tmp_name = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=str(path.parent),
+    )
+    tmp_path = Path(tmp_name)
+    try:
+        with os.fdopen(fd, "wb") as fh:
+            fh.write(encoded)
+            fh.flush()
+            os.fsync(fh.fileno())
+        os.replace(tmp_path, path)
+    except BaseException:
+        # Leave the original file untouched; clean up the temp on any failure.
+        try:
+            tmp_path.unlink()
+        except OSError:
+            pass
+        raise
+
+
+def atomic_write_yaml(path: Path, data: object, **dump_kwargs: object) -> None:
+    """Serialize *data* to YAML and write it to *path* atomically.
+
+    A thin convenience over :func:`atomic_write_text` for the common case of a
+    YAML document.  Extra keyword arguments are forwarded to ``yaml.safe_dump``.
+    """
+    text = yaml.safe_dump(data, **dump_kwargs)
+    atomic_write_text(path, text)

{kanibako_cli-1.5.0.dev14 → kanibako_cli-1.5.1}/src/kanibako/auth_browser.py

@@ -185,6 +185,7 @@ def auto_refresh_auth(
     *,
     headless: bool = True,
     login_timeout: float = 60,
+    env: dict[str, str] | None = None,
 ) -> AuthResult:
     """Orchestrate fully automated OAuth: start login, parse URL, automate browser.
 
@@ -194,6 +195,11 @@ def auto_refresh_auth(
     4. If the browser clicks "Authorize", the redirect completes the login
     5. Wait for ``claude auth login`` to finish
 
+    *env*, when supplied, fully replaces the environment of the spawned
+    ``claude auth login`` process.  Callers pass it to inject
+    ``DISABLE_AUTOUPDATER=1`` so this host exec does not wake Claude's async
+    background auto-updater mid-launch.
+
     Returns :class:`AuthResult` indicating success or failure.
     """
     import subprocess
@@ -215,6 +221,7 @@ def auto_refresh_auth(
             stderr=subprocess.STDOUT,
             stdin=subprocess.PIPE,
             text=True,
+            env=env,
         )
     except (FileNotFoundError, OSError) as exc:
         return AuthResult(success=False, error=f"Failed to start auth: {exc}")

kanibako_cli-1.5.1/src/kanibako/baseline.py

@@ -0,0 +1,124 @@
+"""Image-baseline manifest: the universal in-box runtime tool contract.
+
+The baseline is a mapping of ``apt-package-name -> [executables]``.  The shipped
+default lives in :mod:`kanibako.data` (``image-baseline.yaml``); site and user
+overlays are merged on top **additively** (the scoped-shares spirit in
+:mod:`kanibako.settings_shares`): later layers add new packages or override an
+existing package's executable list.  Precedence, least- to most-specific:
+
+    built-in default  <  /etc/kanibako/image-baseline.yaml  <  ~/.config/kanibako/image-baseline.yaml
+
+The package NAME is what ``apt-get install`` consumes (auto-install assumes
+apt/debian); the EXECUTABLE values are what ``command -v`` probes (verify is
+package-manager-agnostic).  They differ on purpose (e.g. ``ripgrep`` -> ``rg``).
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+import yaml
+
+from kanibako.paths import xdg
+
+# Filename used both for the shipped default (in kanibako.data) and the overlays.
+BASELINE_FILENAME = "image-baseline.yaml"
+
+
+def _read_doc(path: Path) -> dict[str, list[str]]:
+    """Parse a baseline YAML file into ``{package: [executables]}``.
+
+    Tolerates a missing/empty file (returns ``{}``).  Normalizes each value to
+    a list of strings; a bare string value becomes a single-element list.
+    """
+    if not path.is_file():
+        return {}
+    raw = yaml.safe_load(path.read_text()) or {}
+    if not isinstance(raw, dict):
+        return {}
+    result: dict[str, list[str]] = {}
+    for pkg, exes in raw.items():
+        if exes is None:
+            result[str(pkg)] = []
+        elif isinstance(exes, str):
+            result[str(pkg)] = [exes]
+        else:
+            result[str(pkg)] = [str(e) for e in exes]
+    return result
+
+
+def _shipped_default() -> dict[str, list[str]]:
+    """Read the bundled default baseline shipped as package data."""
+    ref = importlib.resources.files("kanibako.data").joinpath(BASELINE_FILENAME)
+    return _read_doc(Path(str(ref)))
+
+
+def _overlay_paths() -> list[Path]:
+    """Overlay locations, in additive merge order (machine then user)."""
+    config_home = xdg("XDG_CONFIG_HOME", ".config")
+    return [
+        Path("/etc/kanibako") / BASELINE_FILENAME,
+        config_home / "kanibako" / BASELINE_FILENAME,
+    ]
+
+
+def load_baseline() -> dict[str, list[str]]:
+    """Return the merged baseline ``{package: [executables]}``.
+
+    Starts from the shipped default, then additively merges the machine
+    (``/etc``) and user (``~/.config``) overlays if present: a later layer adds
+    a new package or replaces an existing package's executable list.  Missing
+    overlay files are treated as empty levels.
+    """
+    merged = _shipped_default()
+    for path in _overlay_paths():
+        merged.update(_read_doc(path))
+    return merged
+
+
+def packages() -> list[str]:
+    """Return the baseline package names in sorted, stable order."""
+    return sorted(load_baseline())
+
+
+def executables() -> list[tuple[str, str]]:
+    """Return ``(package, executable)`` pairs, sorted by package then executable."""
+    pairs: list[tuple[str, str]] = []
+    baseline = load_baseline()
+    for pkg in sorted(baseline):
+        for exe in baseline[pkg]:
+            pairs.append((pkg, exe))
+    return pairs
+
+
+def verify(probe: Callable[[str], bool]) -> list[tuple[str, str]]:
+    """Return the ``(package, executable)`` pairs whose executable is missing.
+
+    *probe* answers "is this executable present?" (typically a ``command -v``
+    check inside an image).  An empty result means the baseline is satisfied.
+    """
+    return [(pkg, exe) for pkg, exe in executables() if not probe(exe)]
+
+
+def install_command(pkgs: list[str]) -> list[str]:
+    """Build the apt-get install argv for *pkgs* (debian).
+
+    Returns the full argv (``apt-get install -y --no-install-recommends ...``).
+    The caller decides where it runs (host vs. in-box) and on non-debian
+    systems should skip it (see :func:`warn_non_debian`).
+    """
+    return [
+        "apt-get", "install", "-y", "--no-install-recommends", *pkgs,
+    ]
+
+
+def warn_non_debian() -> None:
+    """Emit a stderr warning that auto-install only supports apt/debian."""
+    print(
+        "kanibako baseline: automatic install assumes apt/debian; "
+        "install the baseline packages with your distro's package manager.",
+        file=sys.stderr,
+    )

{kanibako_cli-1.5.0.dev14 → kanibako_cli-1.5.1}/src/kanibako/cli.py

@@ -74,6 +74,7 @@ def build_parser() -> argparse.ArgumentParser:
     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
+    from kanibako.commands.baseline_cmd import add_parser as add_baseline_parser
 
     # Setup wizard (before management commands, works pre-init).
     from kanibako.commands.setup_cmd import run_setup
@@ -165,6 +166,7 @@ def build_parser() -> argparse.ArgumentParser:
     add_workset_parser(subparsers)
     add_crab_parser(subparsers)
     add_system_parser(subparsers)
+    add_baseline_parser(subparsers)
 
     return parser
 
@@ -179,7 +181,7 @@ _SUBCOMMANDS = {
     # Top-level aliases (delegate to box subcommands).
     "start", "stop", "shell", "ps", "list", "create", "rm",
     # Management commands.
-    "box", "rig", "workset", "crab", "system",
+    "box", "rig", "workset", "crab", "system", "baseline",
     # Command aliases (#62).
     "agent", "image", "container",
     # Setup wizard.

kanibako_cli-1.5.1/src/kanibako/commands/baseline_cmd.py

@@ -0,0 +1,235 @@
+"""kanibako baseline: inspect, verify, and install the image baseline contract.
+
+The baseline is the universal set of in-box runtime tools kanibako relies on
+(see :mod:`kanibako.baseline`).  ``list`` feeds a Containerfile (``apt-get
+install $(kanibako baseline list)``), ``verify`` probes an image for the
+required executables, and ``install`` runs the apt-get install of the package
+names.
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+
+from kanibako import baseline as baseline_mod
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser(
+        "baseline",
+        help="Inspect/verify the universal in-box tool baseline",
+        description=(
+            "Inspect, verify, or install the image baseline — the universal set "
+            "of in-box runtime tools kanibako relies on across all box variants."
+        ),
+    )
+    sub = p.add_subparsers(dest="baseline_command", metavar="COMMAND")
+
+    # baseline list [--executables]
+    list_p = sub.add_parser(
+        "list",
+        help="Print baseline package names (or executables with --executables)",
+    )
+    list_p.add_argument(
+        "--executables", action="store_true",
+        help="Print 'package: exe1 exe2' per line instead of just package names",
+    )
+    list_p.set_defaults(func=run_list)
+
+    # baseline verify [IMAGE] [--all] [--only PKG ...] [--skip PKG ...]
+    verify_p = sub.add_parser(
+        "verify",
+        help="Probe an image for the baseline executables",
+    )
+    verify_p.add_argument(
+        "image", nargs="?", default=None,
+        help="Image to probe (default: the configured box_image)",
+    )
+    verify_p.add_argument(
+        "--all", action="store_true", dest="all_images",
+        help="Probe every local kanibako-* image",
+    )
+    verify_p.add_argument(
+        "--only", nargs="+", default=None, metavar="PKG",
+        help="Only check these baseline packages",
+    )
+    verify_p.add_argument(
+        "--skip", nargs="+", default=None, metavar="PKG",
+        help="Skip these baseline packages",
+    )
+    verify_p.set_defaults(func=run_verify)
+
+    # baseline install [--only PKG ...] [--skip PKG ...]
+    install_p = sub.add_parser(
+        "install",
+        help="apt-get install the baseline packages (debian; current environment)",
+    )
+    install_p.add_argument(
+        "--only", nargs="+", default=None, metavar="PKG",
+        help="Only install these baseline packages",
+    )
+    install_p.add_argument(
+        "--skip", nargs="+", default=None, metavar="PKG",
+        help="Skip these baseline packages",
+    )
+    install_p.add_argument(
+        "--dry-run", action="store_true",
+        help="Print the install command instead of running it",
+    )
+    install_p.set_defaults(func=run_install)
+
+    # Default to list when 'baseline' is run bare.
+    p.set_defaults(func=run_list)
+
+
+def _filter_packages(
+    pkgs: list[str], only: list[str] | None, skip: list[str] | None,
+) -> list[str]:
+    """Apply --only / --skip filters to a sorted package list."""
+    result = pkgs
+    if only:
+        only_set = set(only)
+        result = [p for p in result if p in only_set]
+    if skip:
+        skip_set = set(skip)
+        result = [p for p in result if p not in skip_set]
+    return result
+
+
+def run_list(args: argparse.Namespace) -> int:
+    """Print the baseline.
+
+    Default: package names, space-separated on one line — a Containerfile
+    consumes this verbatim via ``$(kanibako baseline list)``, so stdout stays
+    clean (no logging).  With ``--executables``: ``package: exe1 exe2`` lines.
+    """
+    if getattr(args, "executables", False):
+        baseline = baseline_mod.load_baseline()
+        for pkg in sorted(baseline):
+            exes = " ".join(baseline[pkg])
+            print(f"{pkg}: {exes}")
+        return 0
+
+    pkgs = baseline_mod.packages()
+    print(" ".join(pkgs))
+    return 0
+
+
+def _make_probe(runtime, image: str):
+    """Return a ``probe(exe) -> bool`` that runs an ephemeral container.
+
+    Each probe runs ``<runtime> run --rm <image> sh -lc 'command -v <exe>'``
+    and reports success on a zero exit code.
+    """
+    def probe(exe: str) -> bool:
+        result = subprocess.run(
+            [
+                runtime.cmd, "run", "--rm", image,
+                "sh", "-lc", f"command -v {exe}",
+            ],
+            capture_output=True,
+            text=True,
+        )
+        return result.returncode == 0
+
+    return probe
+
+
+def _verify_image(runtime, image: str, pkgs: list[str]) -> list[tuple[str, str]]:
+    """Probe *image* for the executables of *pkgs*. Return missing pairs."""
+    baseline = baseline_mod.load_baseline()
+    wanted = {pkg: baseline[pkg] for pkg in pkgs if pkg in baseline}
+    probe = _make_probe(runtime, image)
+    missing: list[tuple[str, str]] = []
+    for pkg in sorted(wanted):
+        for exe in wanted[pkg]:
+            if not probe(exe):
+                missing.append((pkg, exe))
+    return missing
+
+
+def run_verify(args: argparse.Namespace) -> int:
+    """Probe one or all images for the baseline executables.
+
+    Exit code: 1 if any executable is missing in any probed image, else 0.
+    """
+    from kanibako.config import config_file_path, load_merged_config
+    from kanibako.container import ContainerRuntime
+    from kanibako.errors import ContainerError
+    from kanibako.paths import xdg
+
+    try:
+        runtime = ContainerRuntime()
+    except ContainerError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+    pkgs = _filter_packages(
+        baseline_mod.packages(),
+        getattr(args, "only", None),
+        getattr(args, "skip", None),
+    )
+
+    # Determine the image(s) to probe.
+    if getattr(args, "all_images", False):
+        images = [repo for repo, _size in runtime.list_local_images()]
+        if not images:
+            print("No local kanibako images found.", file=sys.stderr)
+            return 1
+    else:
+        image = getattr(args, "image", None)
+        if not image:
+            config_home = xdg("XDG_CONFIG_HOME", ".config")
+            cf = config_file_path(config_home)
+            merged = load_merged_config(cf, None)
+            image = merged.box_image
+        images = [image]
+
+    any_missing = False
+    for image in images:
+        missing = _verify_image(runtime, image, pkgs)
+        print(f"Baseline verify: {image}")
+        if not missing:
+            print("  [ok] all baseline executables present")
+        else:
+            any_missing = True
+            for pkg, exe in missing:
+                print(f"  [!!] {pkg}: missing '{exe}'")
+        print()
+
+    return 1 if any_missing else 0
+
+
+def run_install(args: argparse.Namespace) -> int:
+    """apt-get install the baseline packages in the CURRENT environment.
+
+    This targets the environment the command runs in (e.g. inside a box, or a
+    host that uses apt) — it does NOT shell into a separate box.  Use it from a
+    Containerfile/box where ``apt-get`` is available and you have privileges.
+    Non-debian systems are warned and skipped.
+    """
+    import shutil
+
+    pkgs = _filter_packages(
+        baseline_mod.packages(),
+        getattr(args, "only", None),
+        getattr(args, "skip", None),
+    )
+    if not pkgs:
+        print("Nothing to install.", file=sys.stderr)
+        return 0
+
+    cmd = baseline_mod.install_command(pkgs)
+
+    if getattr(args, "dry_run", False):
+        print(" ".join(cmd))
+        return 0
+
+    if shutil.which("apt-get") is None:
+        baseline_mod.warn_non_debian()
+        return 1
+
+    result = subprocess.run(cmd)
+    return result.returncode

{kanibako_cli-1.5.0.dev14 → kanibako_cli-1.5.1}/src/kanibako/commands/box/__init__.py

@@ -1,7 +1,11 @@
-"""kanibako box: project lifecycle management (create, list, config, migrate, duplicate, move, archive, extract, purge, vault)."""
+"""kanibako box: project lifecycle management (create, list, config, remap, move, convert, duplicate, archive, extract, purge, vault)."""
 
 from kanibako.commands.box._duplicate import run_duplicate
-from kanibako.commands.box._migrate import run_migrate
+from kanibako.commands.box._lifecycle import (
+    run_convert,
+    run_move,
+    run_remap,
+)
 from kanibako.commands.box._parser import (
     _check_container_running,
     _format_credential_age,
@@ -10,13 +14,12 @@ from kanibako.commands.box._parser import (
     run_create,
     run_info,
     run_list,
-    run_move,
     run_ps,
     run_rm,
 )
 
 __all__ = [
     "_check_container_running", "_format_credential_age",
-    "add_parser", "run_config", "run_create", "run_duplicate",
-    "run_info", "run_list", "run_migrate", "run_move", "run_ps", "run_rm",
+    "add_parser", "run_config", "run_convert", "run_create", "run_duplicate",
+    "run_info", "run_list", "run_move", "run_ps", "run_remap", "run_rm",
 ]