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

kanibako/commands/stop.py

@@ -0,0 +1,116 @@
+"""kanibako stop: stop running kanibako containers."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from kanibako.config import config_file_path, load_config
+from kanibako.container import ContainerRuntime
+from kanibako.errors import ContainerError
+from kanibako.paths import xdg, load_std_paths, resolve_any_project
+from kanibako.utils import container_name_for
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser(
+        "stop",
+        help="Stop a running kanibako container",
+        description="Stop a running kanibako container for a project.",
+    )
+    p.add_argument(
+        "project", nargs="?", default=None,
+        help="Project name or path (default: cwd)",
+    )
+    p.add_argument(
+        "--all", action="store_true", dest="all_containers",
+        help="Stop all running kanibako containers",
+    )
+    p.add_argument(
+        "--force", action="store_true",
+        help="Skip confirmation prompt (only relevant with --all)",
+    )
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    try:
+        runtime = ContainerRuntime()
+    except ContainerError:
+        print(
+            "Error: No container runtime found.\n"
+            "Install podman (https://podman.io/) or Docker.",
+            file=sys.stderr,
+        )
+        return 1
+
+    if args.all_containers:
+        return _stop_all(runtime, force=getattr(args, "force", False))
+
+    return _stop_one(runtime, project_dir=getattr(args, "project", None))
+
+
+def _stop_one(runtime: ContainerRuntime, *, project_dir: str | None) -> int:
+    """Stop the container for a single project."""
+    config_file = config_file_path(xdg("XDG_CONFIG_HOME", ".config"))
+    config = load_config(config_file)
+    std = load_std_paths(config)
+
+    proj = resolve_any_project(std, config, project_dir, initialize=False)
+    container_name = container_name_for(proj)
+
+    lock_file = proj.metadata_path / ".kanibako.lock"
+
+    if runtime.stop(container_name):
+        print(f"Stopped {container_name}")
+        # Clean up stopped container (persistent containers lack --rm)
+        if runtime.container_exists(container_name):
+            runtime.rm(container_name)
+    else:
+        print(f"No running container found for this project ({container_name})")
+        # Clean up stopped persistent container if it exists
+        if runtime.container_exists(container_name):
+            runtime.rm(container_name)
+            print(f"Removed stopped container: {container_name}")
+        else:
+            print("\nIf a stale lock file is blocking a new session, remove it manually:")
+            print(f"  rm {lock_file}")
+
+    return 0
+
+
+def _stop_all(runtime: ContainerRuntime, *, force: bool = False) -> int:
+    """Stop all running kanibako containers."""
+    containers = runtime.list_running()
+    if not containers:
+        print("No running kanibako containers found.")
+        return 0
+
+    # Confirmation prompt unless --force
+    if not force:
+        names = [name for name, _, _ in containers]
+        print(f"This will stop {len(containers)} running container(s):")
+        for n in names:
+            print(f"  {n}")
+        print()
+        try:
+            answer = input("Continue? [y/N] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            answer = ""
+        if answer not in ("y", "yes"):
+            print("Aborted.")
+            return 2
+
+    stopped = 0
+    for name, image, status in containers:
+        if runtime.stop(name):
+            print(f"Stopped {name}")
+            # Clean up stopped container (persistent containers lack --rm)
+            if runtime.container_exists(name):
+                runtime.rm(name)
+            stopped += 1
+        else:
+            print(f"Failed to stop {name}", file=sys.stderr)
+
+    print(f"\nStopped {stopped} container(s).")
+    return 0

kanibako/commands/system_cmd.py

@@ -0,0 +1,224 @@
+"""kanibako system: global configuration, self-update, and system info."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from kanibako import __version__
+from kanibako.config import config_file_path, load_config
+from kanibako.paths import xdg
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser(
+        "system",
+        help="Global configuration, upgrades, and system information",
+        description="Manage global kanibako configuration and perform system tasks.",
+    )
+    sys_sub = p.add_subparsers(dest="system_command", metavar="COMMAND")
+
+    # system info (default)
+    info_p = sys_sub.add_parser(
+        "info",
+        aliases=["inspect"],
+        help="Show system information",
+    )
+    info_p.set_defaults(func=run_info)
+
+    # system config [key[=value]] [--effective] [--reset] [--all] [--force]
+    config_p = sys_sub.add_parser(
+        "config",
+        help="View or modify global configuration",
+    )
+    config_p.add_argument(
+        "key_value", nargs="?", default=None,
+        help="key or key=value",
+    )
+    config_p.add_argument(
+        "--effective", action="store_true",
+        help="Show all resolved values including defaults",
+    )
+    config_p.add_argument(
+        "--reset", action="store_true",
+        help="Remove an override (revert to default)",
+    )
+    config_p.add_argument(
+        "--all", action="store_true", dest="all_keys",
+        help="With --reset: remove all overrides",
+    )
+    config_p.add_argument(
+        "--force", action="store_true",
+        help="Skip confirmation prompts",
+    )
+    config_p.set_defaults(func=run_config)
+
+    # system upgrade [--check]
+    from kanibako.commands.upgrade import run as run_upgrade_fn
+
+    upgrade_p = sys_sub.add_parser(
+        "upgrade",
+        help="Upgrade kanibako to the latest version",
+    )
+    upgrade_p.add_argument(
+        "--check", action="store_true",
+        help="Check for updates without installing",
+    )
+    upgrade_p.set_defaults(func=run_upgrade_fn)
+
+    # system diagnose
+    from kanibako.commands.diagnose import run_system_diagnose
+
+    diagnose_p = sys_sub.add_parser(
+        "diagnose",
+        help="Check system health (runtime, images, agents, storage)",
+    )
+    diagnose_p.set_defaults(func=run_system_diagnose)
+
+    # Default to info when 'system' is run without a subcommand
+    p.set_defaults(func=run_info)
+
+
+def run_info(args: argparse.Namespace) -> int:
+    """Show system information: version, paths, runtime."""
+    import platform
+
+    config_home = xdg("XDG_CONFIG_HOME", ".config")
+    cf = config_file_path(config_home)
+
+    print(f"Kanibako v{__version__}")
+    print(f"Python:    {platform.python_version()}")
+
+    if cf.exists():
+        print(f"Config:    {cf}")
+        config = load_config(cf)
+        from pathlib import Path
+
+        from kanibako.paths import resolve_system_paths
+        data_home = xdg("XDG_DATA_HOME", ".local/share")
+        data_path = resolve_system_paths(
+            config.system_paths, data_home=data_home, home=Path.home(),
+        )["system.path.data"]
+        print(f"Data:      {data_path}")
+    else:
+        print(
+            "Config:    (not initialized — run 'kanibako setup' or just 'kanibako start')"
+        )
+
+    # Container runtime
+    try:
+        import subprocess
+
+        from kanibako.container import ContainerRuntime
+
+        runtime = ContainerRuntime()
+        result = subprocess.run(
+            [runtime.cmd, "--version"], capture_output=True, text=True,
+        )
+        version = result.stdout.strip() if result.returncode == 0 else "unknown"
+        print(f"Runtime:   {runtime.cmd} ({version})")
+    except Exception:
+        print(
+            "Runtime:   not found — install podman (https://podman.io/) or Docker"
+        )
+
+    # Install method
+    try:
+        from kanibako.commands.upgrade import _get_repo_dir
+
+        repo = _get_repo_dir()
+        if repo is not None:
+            print(f"Install:   git ({repo})")
+        else:
+            print("Install:   pip")
+    except Exception:
+        print("Install:   pip")
+
+    # Agent count
+    try:
+        from kanibako.targets import discover_targets
+
+        targets = discover_targets()
+        count = len(targets)
+        if count > 0:
+            print(
+                f"Agents:    {count} detected (use 'kanibako crab list' for details)"
+            )
+        else:
+            print(
+                "Agents:    none (install a plugin: pip install kanibako-agent-claude)"
+            )
+    except Exception:
+        pass
+
+    print()
+    print("Tip: Run 'kanibako system diagnose' for a full health check.")
+
+    return 0
+
+
+def run_config(args: argparse.Namespace) -> int:
+    """View or modify global configuration."""
+    config_home = xdg("XDG_CONFIG_HOME", ".config")
+    cf = config_file_path(config_home)
+
+    from kanibako.config_interface import (
+        ConfigAction,
+        get_config_value,
+        is_known_key,
+        parse_config_arg,
+        reset_all,
+        reset_config_value,
+        set_config_value,
+        show_config,
+    )
+
+    key_value = getattr(args, "key_value", None)
+    action, key, value = parse_config_arg(key_value)
+
+    # --reset --all
+    if args.reset and getattr(args, "all_keys", False):
+        msg = reset_all(config_path=cf, force=args.force)
+        print(msg)
+        return 0
+
+    # --reset <key>
+    if args.reset:
+        if not key:
+            print(
+                "Error: --reset requires a key (or use --reset --all).",
+                file=sys.stderr,
+            )
+            return 1
+        msg = reset_config_value(key, config_path=cf)
+        print(msg)
+        return 0
+
+    # show (no args)
+    if action == ConfigAction.show:
+        show_config(
+            global_config_path=cf,
+            config_path=cf,
+            effective=args.effective,
+        )
+        return 0
+
+    # get
+    if action == ConfigAction.get:
+        if not is_known_key(key):
+            print(f"Error: unknown config key: {key}", file=sys.stderr)
+            return 1
+        val = get_config_value(key, global_config_path=cf)
+        if val is None:
+            print(f"{key}: (not set)")
+        else:
+            print(f"{key}={val}")
+        return 0
+
+    # set
+    if action == ConfigAction.set:
+        msg = set_config_value(key, value, config_path=cf, is_system=True)
+        print(msg)
+        return 0
+
+    return 0

kanibako/commands/upgrade.py

@@ -0,0 +1,161 @@
+"""kanibako upgrade: update kanibako itself from git."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    p = subparsers.add_parser(
+        "upgrade",
+        help="Upgrade kanibako to the latest version",
+        description="Upgrade kanibako by pulling the latest changes from git.",
+    )
+    p.add_argument(
+        "--check", action="store_true",
+        help="Check for updates without installing",
+    )
+    p.set_defaults(func=run)
+
+
+def _get_repo_dir() -> Path | None:
+    """Find the kanibako git repository directory."""
+    # Start from this file's location and walk up to find .git
+    current = Path(__file__).resolve().parent
+    for _ in range(5):  # Don't walk up forever
+        if (current / ".git").is_dir():
+            return current
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def _git(*args: str, cwd: Path) -> subprocess.CompletedProcess:
+    """Run a git command in the given directory."""
+    return subprocess.run(
+        ["git", *args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _get_current_commit(repo: Path) -> str | None:
+    """Get the current commit hash."""
+    result = _git("rev-parse", "HEAD", cwd=repo)
+    if result.returncode == 0:
+        return result.stdout.strip()
+    return None
+
+
+def _get_remote_commit(repo: Path) -> str | None:
+    """Get the latest remote commit hash after fetching."""
+    # Fetch latest from remote
+    result = _git("fetch", cwd=repo)
+    if result.returncode != 0:
+        return None
+
+    # Get the upstream branch name
+    result = _git("rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}", cwd=repo)
+    if result.returncode != 0:
+        # No upstream configured, try origin/main or origin/master
+        for branch in ("origin/main", "origin/master"):
+            result = _git("rev-parse", branch, cwd=repo)
+            if result.returncode == 0:
+                return result.stdout.strip()
+        return None
+
+    upstream = result.stdout.strip()
+    result = _git("rev-parse", upstream, cwd=repo)
+    if result.returncode == 0:
+        return result.stdout.strip()
+    return None
+
+
+def _get_commit_count_behind(repo: Path) -> int | None:
+    """Get number of commits behind upstream."""
+    result = _git("rev-list", "--count", "HEAD..@{u}", cwd=repo)
+    if result.returncode == 0:
+        try:
+            return int(result.stdout.strip())
+        except ValueError:
+            pass
+    return None
+
+
+def run(args: argparse.Namespace) -> int:
+    repo = _get_repo_dir()
+    if repo is None:
+        print("Error: Could not find kanibako git repository.", file=sys.stderr)
+        print("kanibako upgrade only works for git-based installations.", file=sys.stderr)
+        return 1
+
+    # Check for uncommitted changes
+    result = _git("status", "--porcelain", cwd=repo)
+    if result.returncode != 0:
+        print("Error: Failed to check git status.", file=sys.stderr)
+        return 1
+
+    has_changes = bool(result.stdout.strip())
+
+    current = _get_current_commit(repo)
+    if current is None:
+        print("Error: Failed to get current commit.", file=sys.stderr)
+        return 1
+
+    print(f"Repository: {repo}")
+    print(f"Current: {current[:8]}")
+
+    # Fetch and check for updates
+    print("Checking for updates...", end=" ", flush=True)
+    remote = _get_remote_commit(repo)
+    if remote is None:
+        print("failed")
+        print("Error: Failed to fetch from remote.", file=sys.stderr)
+        return 1
+
+    if current == remote:
+        print("up to date")
+        return 0
+
+    behind = _get_commit_count_behind(repo)
+    behind_str = f"{behind} commit(s)" if behind else "updates"
+    print(f"{behind_str} available")
+    print(f"Latest: {remote[:8]}")
+
+    if args.check:
+        return 0
+
+    # Actually upgrade
+    if has_changes:
+        print()
+        print("Warning: You have uncommitted changes in the repository.", file=sys.stderr)
+        print("Stash or commit them before upgrading.", file=sys.stderr)
+        return 1
+
+    print()
+    print("Pulling latest changes...")
+    result = _git("pull", "--ff-only", cwd=repo)
+    if result.returncode != 0:
+        print("Error: git pull failed.", file=sys.stderr)
+        if result.stderr:
+            print(result.stderr, file=sys.stderr)
+        return 1
+
+    print("Upgraded successfully.")
+
+    # Check if pyproject.toml changed (might need reinstall)
+    result = _git("diff", "--name-only", f"{current}..HEAD", cwd=repo)
+    changed_files = result.stdout.strip().split("\n") if result.stdout.strip() else []
+
+    if "pyproject.toml" in changed_files:
+        print()
+        print("Note: pyproject.toml changed. You may need to reinstall:")
+        print(f"  pip install -e {repo}")
+
+    return 0

kanibako/commands/vault_cmd.py

@@ -0,0 +1,199 @@
+"""kanibako vault: manage vault snapshots."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from kanibako.config import config_file_path, load_config
+from kanibako.paths import xdg, load_std_paths, resolve_any_project
+from kanibako.snapshots import (
+    _DEFAULT_MAX_SNAPSHOTS,
+    create_snapshot,
+    list_snapshots,
+    prune_snapshots,
+    restore_snapshot,
+)
+
+
+def add_vault_subparser(parent_sub: argparse._SubParsersAction) -> None:
+    """Register vault as a subcommand (used by box parser to nest under box)."""
+    p = parent_sub.add_parser(
+        "vault",
+        help="Vault snapshot commands (snapshot, list, restore, prune)",
+        description="Manage vault share-rw snapshots.",
+    )
+    _add_vault_subcommands(p)
+
+
+def add_parser(subparsers: argparse._SubParsersAction) -> None:
+    """Register vault as a top-level command (kept for backward compat during transition)."""
+    p = subparsers.add_parser(
+        "vault",
+        help="Vault snapshot commands (snapshot, list, restore, prune)",
+        description="Manage vault share-rw snapshots.",
+    )
+    _add_vault_subcommands(p)
+
+
+def _add_vault_subcommands(p: argparse.ArgumentParser) -> None:
+    vs = p.add_subparsers(dest="vault_command", metavar="COMMAND")
+
+    # kanibako box vault snapshot [project]
+    snap_p = vs.add_parser(
+        "snapshot",
+        help="Create a snapshot of vault share-rw",
+        description="Create a point-in-time snapshot of the vault share-rw directory.",
+    )
+    snap_p.add_argument(
+        "project", nargs="?", default=None,
+        help="Project directory or name (default: cwd)",
+    )
+    snap_p.set_defaults(func=run_snapshot)
+
+    # kanibako box vault list [project] [-q/--quiet]
+    list_p = vs.add_parser(
+        "list",
+        help="List vault snapshots (default)",
+        description="Show all snapshots for the current project's vault.",
+    )
+    list_p.add_argument(
+        "project", nargs="?", default=None,
+        help="Project directory or name (default: cwd)",
+    )
+    list_p.add_argument(
+        "-q", "--quiet", action="store_true",
+        help="Output snapshot names only, one per line",
+    )
+    list_p.set_defaults(func=run_list)
+
+    # kanibako box vault restore <name> [project] [--force]
+    restore_p = vs.add_parser(
+        "restore",
+        help="Restore vault share-rw from a snapshot",
+        description="Replace the current share-rw contents with a snapshot.",
+    )
+    restore_p.add_argument("name", help="Snapshot name (e.g. 20260221T103000Z.tar.xz)")
+    restore_p.add_argument(
+        "project", nargs="?", default=None,
+        help="Project directory or name (default: cwd)",
+    )
+    restore_p.add_argument(
+        "--force", action="store_true",
+        help="Skip confirmation prompt",
+    )
+    restore_p.set_defaults(func=run_restore)
+
+    # kanibako box vault prune [project] [--keep N] [--force]
+    prune_p = vs.add_parser(
+        "prune",
+        help="Remove old snapshots",
+        description="Prune old vault snapshots, keeping the most recent ones.",
+    )
+    prune_p.add_argument(
+        "project", nargs="?", default=None,
+        help="Project directory or name (default: cwd)",
+    )
+    prune_p.add_argument(
+        "--keep", type=int, default=_DEFAULT_MAX_SNAPSHOTS,
+        help=f"Number of snapshots to keep (default: {_DEFAULT_MAX_SNAPSHOTS})",
+    )
+    prune_p.add_argument(
+        "--force", action="store_true",
+        help="Skip confirmation prompt",
+    )
+    prune_p.set_defaults(func=run_prune)
+
+    p.set_defaults(func=run_list)
+
+
+def _resolve_vault_rw(project_dir: str | None):
+    """Resolve the vault share-rw path for the current project."""
+    config_file = config_file_path(xdg("XDG_CONFIG_HOME", ".config"))
+    config = load_config(config_file)
+    std = load_std_paths(config)
+    proj = resolve_any_project(std, config, project_dir, initialize=False)
+
+    if not proj.enable_vault:
+        print("Vault is disabled for this project.", file=sys.stderr)
+        return None
+    return proj.vault_rw_path
+
+
+def run_snapshot(args: argparse.Namespace) -> int:
+    project_dir = getattr(args, "project", None)
+    vault_rw = _resolve_vault_rw(project_dir)
+    if vault_rw is None:
+        return 1
+
+    snap = create_snapshot(vault_rw)
+    if snap is None:
+        print("Nothing to snapshot (share-rw is empty or missing).", file=sys.stderr)
+        return 0
+
+    print(f"Snapshot created: {snap.name}")
+    return 0
+
+
+def run_list(args: argparse.Namespace) -> int:
+    project_dir = getattr(args, "project", None)
+    vault_rw = _resolve_vault_rw(project_dir)
+    if vault_rw is None:
+        return 1
+
+    quiet = getattr(args, "quiet", False)
+
+    snaps = list_snapshots(vault_rw)
+    if not snaps:
+        if not quiet:
+            print("No snapshots found.")
+        return 0
+
+    for name, ts, size in snaps:
+        if quiet:
+            print(name)
+        else:
+            size_str = _human_size(size)
+            print(f"  {name}  {ts}  {size_str}")
+
+    return 0
+
+
+def run_restore(args: argparse.Namespace) -> int:
+    project_dir = getattr(args, "project", None)
+    vault_rw = _resolve_vault_rw(project_dir)
+    if vault_rw is None:
+        return 1
+
+    try:
+        restore_snapshot(vault_rw, args.name)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    print(f"Restored vault share-rw from {args.name}")
+    return 0
+
+
+def run_prune(args: argparse.Namespace) -> int:
+    project_dir = getattr(args, "project", None)
+    vault_rw = _resolve_vault_rw(project_dir)
+    if vault_rw is None:
+        return 1
+
+    removed = prune_snapshots(vault_rw, max_keep=args.keep)
+    if removed:
+        print(f"Pruned {removed} snapshot(s), keeping {args.keep}.")
+    else:
+        print("Nothing to prune.")
+    return 0
+
+
+def _human_size(nbytes: int) -> str:
+    """Format byte count as human-readable string."""
+    size = float(nbytes)
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024:
+            return f"{size:.0f}{unit}" if unit == "B" else f"{size:.1f}{unit}"
+        size /= 1024
+    return f"{size:.1f}TB"