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

kanibako/commands/install.py

@@ -0,0 +1,152 @@
+"""kanibako install utilities: setup logic and shell completion.
+
+The ``setup`` CLI command has been replaced by lazy initialization
+(``_ensure_initialized`` in ``cli.py``).  This module is kept for
+``_install_completion()`` and the ``run()`` helper used by lazy init
+and tests.
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+
+from kanibako.config import (
+    KanibakoConfig,
+    config_file_path,
+    load_config,
+    write_global_config,
+)
+from kanibako.container import ContainerRuntime
+from kanibako.containerfiles import get_containerfile
+from kanibako.paths import xdg
+
+
+def run(args: argparse.Namespace) -> int:
+    config_home = xdg("XDG_CONFIG_HOME", ".config")
+    config_file = config_file_path(config_home)
+
+    # ------------------------------------------------------------------
+    # 1. Write config
+    # ------------------------------------------------------------------
+    if config_file.exists():
+        print("Configuration file already exists, loading.")
+        config = load_config(config_file)
+    else:
+        print("Writing general configuration file (kanibako.yaml)... ", end="", flush=True)
+        config = KanibakoConfig()
+        write_global_config(config_file, config)
+        print("done!")
+
+    # ------------------------------------------------------------------
+    # 2. Create containers directory for user overrides
+    # ------------------------------------------------------------------
+    from pathlib import Path
+
+    from kanibako.paths import resolve_system_paths
+
+    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"]
+    containers_dest = data_path / "containers"
+    containers_dest.mkdir(parents=True, exist_ok=True)
+
+    # Create template directory structure.
+    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)
+
+    # Create peer communication directory.
+    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.yaml (no-agent default)
+    general_toml = crabs_path / "general.yaml"
+    if not general_toml.exists():
+        write_crab_config(general_toml, CrabConfig(name="Shell"))
+
+    # Each discovered target plugin
+    for target_name, cls in discover_targets().items():
+        target_toml = crabs_path / f"{target_name}.yaml"
+        if not target_toml.exists():
+            agent_cfg = cls().generate_crab_config()
+            write_crab_config(target_toml, agent_cfg)
+        else:
+            agent_cfg = CrabConfig()  # just need the shell default
+        # Create the agent-specific template variant directory.
+        (templates_dir / target_name / agent_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)
+    _DEFAULT_ENV = {"COLORTERM": "truecolor"}
+    for key, value in _DEFAULT_ENV.items():
+        global_env.setdefault(key, value)
+    write_env_file(global_env_path, global_env)
+
+    # ------------------------------------------------------------------
+    # 3. Pull or build base container image
+    # ------------------------------------------------------------------
+    try:
+        runtime = ContainerRuntime()
+        from kanibako.commands.image import resolve_image_reference
+        image = resolve_image_reference(
+            config.box_image, runtime, config.box_image,
+        )
+        if runtime.image_exists(image):
+            print("Container rig already exists, skipping.")
+        elif runtime.pull(image):
+            print("Rig pulled from registry!")
+        else:
+            print("Pull failed; building locally...")
+            base_cf = get_containerfile("base", containers_dest)
+            if base_cf is not None:
+                runtime.build(image, base_cf, base_cf.parent)
+                print("Base rig built!")
+            else:
+                print("Warning: No Containerfile.base found; skipping build.", file=sys.stderr)
+    except Exception as e:
+        print(f"Warning: {e}", file=sys.stderr)
+        print("Skipping rig setup.")
+
+    # ------------------------------------------------------------------
+    # 4. Register shell completion
+    # ------------------------------------------------------------------
+    print("Setting up shell completion... ", end="", flush=True)
+    _install_completion()
+    print("done!")
+
+    return 0
+
+
+def _install_completion() -> None:
+    """Register bash/zsh completion for kanibako via argcomplete."""
+    completions_dir = xdg("XDG_DATA_HOME", ".local/share") / "bash-completion" / "completions"
+    completions_dir.mkdir(parents=True, exist_ok=True)
+    target = completions_dir / "kanibako"
+
+    try:
+        result = subprocess.run(
+            ["register-python-argcomplete", "kanibako"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            target.write_text(result.stdout)
+        else:
+            print("(register-python-argcomplete failed, skipping)", end=" ")
+    except FileNotFoundError:
+        print("(argcomplete not on PATH, skipping)", end=" ")

kanibako/commands/refresh_credentials.py

@@ -0,0 +1,67 @@
+"""kanibako reauth: manually verify or re-establish agent authentication."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from kanibako.config import config_file_path, load_config
+from kanibako.paths import xdg
+from kanibako.targets import resolve_target
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser(
+        "reauth",
+        help="Check authentication and login if needed",
+        description="Verify agent authentication status and run interactive "
+        "login if credentials are expired or missing.",
+    )
+    p.add_argument(
+        "-p", "--project", default=None, help="Target a specific project directory",
+    )
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    config_file = config_file_path(xdg("XDG_CONFIG_HOME", ".config"))
+    config = load_config(config_file)
+
+    # Resolve project to check auth mode.
+    from kanibako.paths import load_std_paths, resolve_any_project
+    std = load_std_paths(config)
+    proj = resolve_any_project(std, config, getattr(args, "project", None))
+
+    try:
+        target = resolve_target(config.box_crab or None)
+    except KeyError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    if not target.has_binary:
+        print("No agent target configured.", file=sys.stderr)
+        return 1
+
+    if not proj.group_auth:
+        # Check project's own credentials instead of host.
+        creds_path = target.credential_check_path(proj.shell_path)
+        if creds_path and creds_path.is_file():
+            print(f"{target.display_name}: distinct auth (project credentials exist).", file=sys.stderr)
+            return 0
+        else:
+            print(
+                f"{target.display_name}: distinct auth — no credentials found. "
+                "Launch the container to authenticate.",
+                file=sys.stderr,
+            )
+            return 1
+
+    if target.check_auth():
+        # Sync refreshed credentials to the project shell directory
+        if proj.group_auth:
+            target.refresh_credentials(proj.shell_path)
+        print(f"{target.display_name}: authenticated.", file=sys.stderr)
+        return 0
+    else:
+        print(f"{target.display_name}: authentication failed.", file=sys.stderr)
+        return 1

kanibako/commands/restore.py

@@ -0,0 +1,298 @@
+"""kanibako extract: restore session data from archive with validation."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+from pathlib import Path
+
+from kanibako.config import config_file_path, load_config
+from kanibako.errors import UserCancelled
+from kanibako.git import is_git_repo
+from kanibako.paths import xdg, load_std_paths, resolve_any_project
+from kanibako.utils import confirm_prompt
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser(
+        "extract",
+        help="Extract session data from archive",
+        description="Extract session data from a .txz archive created by 'kanibako box archive'.",
+    )
+    p.add_argument("file", nargs="?", default=None, help="Archive file to extract from")
+    p.add_argument("path", nargs="?", default=None, help="Path to the project directory")
+    p.add_argument(
+        "--name", default=None,
+        help="Override project name for the extracted data",
+    )
+    p.add_argument(
+        "--all", action="store_true", dest="all_archives",
+        help="Extract all kanibako-*.txz archives in the current directory",
+    )
+    p.add_argument("--force", action="store_true", help="Skip all confirmation prompts")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    config_file = config_file_path(xdg("XDG_CONFIG_HOME", ".config"))
+    config = load_config(config_file)
+    std = load_std_paths(config)
+
+    if args.all_archives:
+        return _restore_all(std, config, args)
+
+    if args.file is None:
+        print("Error: specify an archive file, or use --all", file=sys.stderr)
+        return 1
+
+    return _restore_one(std, config, project_dir=args.path,
+                        archive_file=Path(args.file), force=args.force)
+
+
+def _restore_one(std, config, *, project_dir, archive_file, force) -> int:
+    """Extract session data from a single archive."""
+    if not archive_file.is_file():
+        print(f"Error: Archive file not found: {archive_file}", file=sys.stderr)
+        return 1
+
+    proj = resolve_any_project(
+        std, config,
+        project_dir=str(project_dir) if project_dir else None,
+        initialize=False,
+    )
+
+    temp_dir = tempfile.mkdtemp()
+    try:
+        try:
+            with tarfile.open(str(archive_file), "r:xz") as tar:
+                tar.extractall(temp_dir, filter="data")
+        except (tarfile.TarError, OSError) as e:
+            print(f"Error: Failed to extract archive: {e}", file=sys.stderr)
+            return 1
+
+        # Find the archive hash directory
+        entries = list(Path(temp_dir).iterdir())
+        if not entries:
+            print("Error: Empty archive.", file=sys.stderr)
+            return 1
+        archive_hash_dir = entries[0]
+        archive_hash = archive_hash_dir.name
+        info_file = archive_hash_dir / "kanibako-archive-info.txt"
+
+        if not info_file.is_file():
+            print(
+                "Error: Invalid archive format (missing kanibako-archive-info.txt)",
+                file=sys.stderr,
+            )
+            return 1
+
+        # Parse metadata
+        info = _parse_info(info_file)
+        archive_path = info.get("Project path", "")
+        archive_basename = Path(archive_path).name if archive_path else ""
+        current_basename = proj.project_path.name
+
+        # Validate hash match
+        hash_match = (
+            archive_hash == proj.project_hash
+            or archive_basename == current_basename
+        )
+
+        if not hash_match and not force:
+            print("Warning: Project path mismatch")
+            print()
+            print(f"Archive from: {archive_path}")
+            print(f"Restoring to: {proj.project_path}")
+            print()
+            try:
+                confirm_prompt("Continue anyway? Type 'yes' to confirm: ")
+            except UserCancelled:
+                print("Aborted.")
+                return 2
+
+        # Validate git state
+        git_in_archive = info.get("Git repository", "") == "yes"
+        if git_in_archive:
+            rc = _validate_git_state(proj, info, force)
+            if rc != 0:
+                return rc
+
+        # Restore session data
+        print("Restoring session data... ", end="", flush=True)
+        projects_base = std.boxes
+        projects_base.mkdir(parents=True, exist_ok=True)
+
+        if proj.metadata_path.exists():
+            shutil.rmtree(proj.metadata_path)
+
+        shutil.copytree(str(archive_hash_dir), str(proj.metadata_path))
+
+        # Remove info file from restored data
+        restored_info = proj.metadata_path / "kanibako-archive-info.txt"
+        restored_info.unlink(missing_ok=True)
+
+        print("done.")
+        print(f"Session data restored to {proj.project_path}")
+        return 0
+
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def _peek_archive_info(archive_file: Path) -> dict[str, str] | None:
+    """Extract archive to a temp dir and parse the info file."""
+    temp_dir = tempfile.mkdtemp()
+    try:
+        try:
+            with tarfile.open(str(archive_file), "r:xz") as tar:
+                tar.extractall(temp_dir, filter="data")
+        except (tarfile.TarError, OSError):
+            return None
+        entries = list(Path(temp_dir).iterdir())
+        if not entries:
+            return None
+        info_file = entries[0] / "kanibako-archive-info.txt"
+        if not info_file.is_file():
+            return None
+        info = _parse_info(info_file)
+        info["_archive_hash"] = entries[0].name
+        return info
+    finally:
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def _restore_all(std, config, args) -> int:
+    """Restore all kanibako-*.txz archives in the current directory."""
+    import os
+
+    scan_dir = Path(os.getcwd())
+    archives = sorted(scan_dir.glob("kanibako-*.txz"))
+    if not archives:
+        print(f"No kanibako-*.txz archives found in {scan_dir}")
+        return 0
+
+    # Peek into each archive to get project path
+    plan: list[tuple[Path, str]] = []
+    for archive in archives:
+        info = _peek_archive_info(archive)
+        if info is None:
+            print(f"  Skipping {archive.name} (invalid archive)", file=sys.stderr)
+            continue
+        project_path = info.get("Project path", "")
+        if not project_path:
+            print(f"  Skipping {archive.name} (no project path in metadata)", file=sys.stderr)
+            continue
+        plan.append((archive, project_path))
+
+    if not plan:
+        print("No valid archives found to restore.")
+        return 0
+
+    print(f"Found {len(plan)} archive(s) to restore:")
+    for archive, project_path in plan:
+        print(f"  {archive.name} → {project_path}")
+    print()
+
+    if not args.force:
+        try:
+            confirm_prompt(
+                "Restore all listed archives? Existing session data will be overwritten.\n"
+                "Type 'yes' to confirm: "
+            )
+        except UserCancelled:
+            print("Aborted.")
+            return 2
+
+    restored = 0
+    failed = 0
+    for archive, project_path in plan:
+        print(f"\n--- {archive.name} → {project_path}")
+        rc = _restore_one(
+            std, config, project_dir=project_path,
+            archive_file=archive, force=True,
+        )
+        if rc == 0:
+            restored += 1
+        else:
+            failed += 1
+
+    print(f"\nRestored {restored} archive(s).", end="")
+    if failed:
+        print(f" {failed} failed.", end="")
+    print()
+    return 1 if failed else 0
+
+
+def _parse_info(info_file: Path) -> dict[str, str]:
+    """Parse kanibako-archive-info.txt into a dict."""
+    result: dict[str, str] = {}
+    for line in info_file.read_text().splitlines():
+        if ": " in line and not line.startswith("  "):
+            key, _, value = line.partition(": ")
+            result[key.strip()] = value.strip()
+    return result
+
+
+def _validate_git_state(proj, info: dict[str, str], force: bool) -> int:
+    """Validate git state between archive and workspace. Returns 0 to continue."""
+    if not is_git_repo(proj.project_path):
+        if not force:
+            print(
+                "Warning: Archive came from a git repository, "
+                "but current workspace is not a git repo."
+            )
+            print()
+            for key in ("Branch", "Commit"):
+                if key in info:
+                    print(f"  {key}: {info[key]}")
+            print()
+            try:
+                confirm_prompt("Continue anyway? Type 'yes' to confirm: ")
+            except UserCancelled:
+                print("Aborted.")
+                return 2
+        return 0
+
+    archive_commit = info.get("Commit", "")
+    result = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=proj.project_path,
+        capture_output=True,
+        text=True,
+    )
+    current_commit = result.stdout.strip() if result.returncode == 0 else ""
+
+    if archive_commit != current_commit and not force:
+        print("Warning: Git state mismatch")
+        print()
+        print("Archive from:")
+        for key in ("Branch", "Commit"):
+            if key in info:
+                print(f"  {key}: {info[key]}")
+        print()
+        print("Current workspace:")
+        branch_result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=proj.project_path,
+            capture_output=True,
+            text=True,
+        )
+        current_branch = (
+            branch_result.stdout.strip()
+            if branch_result.returncode == 0
+            else "unknown"
+        )
+        print(f"  Branch: {current_branch}")
+        print(f"  Commit: {current_commit}")
+        print()
+        try:
+            confirm_prompt("Continue anyway? Type 'yes' to confirm: ")
+        except UserCancelled:
+            print("Aborted.")
+            return 2
+
+    return 0

kanibako/commands/setup_cmd.py

@@ -0,0 +1,89 @@
+"""kanibako setup: interactive setup wizard for first-time configuration."""
+
+from __future__ import annotations
+
+import argparse
+
+
+def run_setup(args: argparse.Namespace) -> int:
+    """Run the interactive setup wizard."""
+    print()
+    print("Kanibako Setup")
+    print("=" * 40)
+    print()
+
+    # Step 1: Container runtime
+    print("Step 1: Container Runtime")
+    from kanibako.commands.diagnose import _check_runtime
+
+    status, detail = _check_runtime()
+    if status == "ok":
+        print(f"  [ok] {detail}")
+    else:
+        print("  [!!] No container runtime found.")
+        print("       Install podman (https://podman.io/) or Docker.")
+        print()
+        return 1
+    print()
+
+    # Step 2: Detect agents
+    print("Step 2: Agent Detection")
+    from kanibako.targets import discover_targets
+
+    targets = discover_targets()
+    found_any = False
+    for name, cls in targets.items():
+        try:
+            instance = cls()
+            install = instance.detect()
+            if install is not None:
+                print(f"  [ok] {instance.display_name} detected")
+                found_any = True
+            else:
+                print(f"  [--] {instance.display_name} not found on this system")
+        except Exception:
+            print(f"  [--] {name}: error during detection")
+
+    if not targets:
+        print("  [!!] No agent plugins installed.")
+        print("       Install one: pip install kanibako-agent-claude")
+    elif not found_any:
+        print()
+        print("  No agents detected on this system.")
+        print("  Install an agent (e.g., Claude Code) and try again.")
+    print()
+
+    # Step 3: Default image
+    print("Step 3: Container Rig")
+    from kanibako.commands.diagnose import _check_image
+
+    try:
+        from kanibako.config import config_file_path, load_merged_config
+        from kanibako.paths import xdg
+
+        config_home = xdg("XDG_CONFIG_HOME", ".config")
+        cf = config_file_path(config_home)
+        merged = load_merged_config(cf, None)
+        status, detail = _check_image(merged)
+        if status == "ok":
+            print(f"  [ok] {detail}")
+        else:
+            print(f"  [--] {detail}")
+            print("       The rig will be pulled automatically on first use.")
+    except Exception:
+        print("  [--] Cannot check (configuration not initialized yet)")
+        print("       Rigs will be pulled automatically on first use.")
+    print()
+
+    # Summary
+    print("Setup Complete")
+    print("-" * 40)
+    if found_any:
+        print("  You're ready to go! Run `kanibako` in any project directory.")
+    else:
+        print("  Install an agent plugin and its host binary, then run `kanibako`.")
+    print()
+    print("  For a full health check: kanibako system diagnose")
+    print()
+
+    return 0