furtka/furtka/cli.py

import argparse
import json
import sys

from furtka import dockerops, installer, reconciler
from furtka.paths import apps_dir
from furtka.scanner import scan


def _cmd_app_list(args: argparse.Namespace) -> int:
    results = scan(apps_dir())
    if args.json:
        out = [
            {
                "path": str(r.path),
                "name": r.manifest.name if r.manifest else None,
                "ok": r.ok,
                "error": r.error,
                "manifest": {
                    "name": r.manifest.name,
                    "display_name": r.manifest.display_name,
                    "version": r.manifest.version,
                    "description": r.manifest.description,
                    "volumes": list(r.manifest.volumes),
                    "ports": list(r.manifest.ports),
                    "icon": r.manifest.icon,
                }
                if r.manifest
                else None,
            }
            for r in results
        ]
        print(json.dumps(out, indent=2))
        return 0
    if not results:
        print("(no apps installed)")
        return 0
    for r in results:
        if r.ok:
            m = r.manifest
            print(f"{m.name:20s}  {m.version:10s}  {m.display_name}")
        else:
            print(f"{r.path.name:20s}  ERROR       {r.error}")
    return 0


def _cmd_app_install(args: argparse.Namespace) -> int:
    try:
        src = installer.resolve_source(args.source)
        target = installer.install_from(src)
    except installer.InstallError as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    print(f"installed {target.name} to {target}")
    actions = reconciler.reconcile(apps_dir())
    for a in actions:
        print(f"  {a.describe()}")
    return 1 if reconciler.has_errors(actions) else 0


def _cmd_app_remove(args: argparse.Namespace) -> int:
    target = apps_dir() / args.name
    if not target.exists():
        print(f"error: {args.name!r} is not installed", file=sys.stderr)
        return 1
    try:
        dockerops.compose_down(target, args.name)
    except dockerops.DockerError as e:
        # Container may already be down (or never came up). Don't block removal.
        print(f"warning: compose down failed, removing folder anyway: {e}", file=sys.stderr)
    try:
        installer.remove(args.name)
    except installer.InstallError as e:
        print(f"error: {e}", file=sys.stderr)
        return 1
    print(f"removed {args.name} (volumes preserved)")
    return 0


def _cmd_serve(args: argparse.Namespace) -> int:
    # Imported lazily so `furtka` startup stays cheap when the user only runs
    # `app list` or `reconcile` (the common case during tests + scripts).
    from furtka import api

    api.serve(args.host, args.port)
    return 0


def _cmd_reconcile(args: argparse.Namespace) -> int:
    actions = reconciler.reconcile(apps_dir(), dry_run=args.dry_run)
    print(f"Scanned {apps_dir()}: {len(actions)} actions")
    for a in actions:
        print(f"  {a.describe()}")
    if args.dry_run:
        print("(dry-run — nothing changed)")
    # Exit non-zero on any per-app failure so systemd marks furtka-reconcile
    # red — but only AFTER all apps were attempted, so a broken app doesn't
    # hide healthy ones.
    return 1 if reconciler.has_errors(actions) else 0


def _cmd_update(args: argparse.Namespace) -> int:
    from furtka import updater

    if args.check:
        try:
            check = updater.check_update()
        except updater.UpdateError as e:
            print(f"error: {e}", file=sys.stderr)
            return 2
        if args.json:
            print(
                json.dumps(
                    {
                        "current": check.current,
                        "latest": check.latest,
                        "update_available": check.update_available,
                    },
                    indent=2,
                )
            )
        elif check.update_available:
            print(f"Update available: {check.current} → {check.latest}")
        else:
            print(f"Already up to date ({check.current})")
        return 0

    try:
        check = updater.run_update()
    except updater.UpdateError as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    if not check.update_available:
        print(f"Already up to date ({check.current})")
    else:
        print(f"Updated {check.current} → {check.latest}")
    return 0


def _cmd_rollback(args: argparse.Namespace) -> int:
    from furtka import updater

    try:
        restored = updater.rollback()
    except updater.UpdateError as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    print(f"Rolled back to {restored}")
    return 0


def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(prog="furtka", description="Furtka resource manager")
    sub = p.add_subparsers(dest="command", required=True)

    app = sub.add_parser("app", help="Manage installed apps")
    app_sub = app.add_subparsers(dest="subcommand", required=True)

    app_list = app_sub.add_parser("list", help="List installed apps")
    app_list.add_argument("--json", action="store_true", help="Emit JSON instead of a table")
    app_list.set_defaults(func=_cmd_app_list)

    app_install = app_sub.add_parser(
        "install",
        help="Install an app from a local folder or a bundled-app name",
    )
    app_install.add_argument(
        "source",
        help="Path to an app folder, or the name of a bundled app under /opt/furtka/apps/",
    )
    app_install.set_defaults(func=_cmd_app_install)

    app_remove = app_sub.add_parser("remove", help="Stop and uninstall an app (keeps volumes)")
    app_remove.add_argument("name", help="App name (folder name under /var/lib/furtka/apps/)")
    app_remove.set_defaults(func=_cmd_app_remove)

    reconcile = sub.add_parser(
        "reconcile",
        help="Bring docker state in line with /var/lib/furtka/apps",
    )
    reconcile.add_argument(
        "--dry-run",
        action="store_true",
        help="Show what would be done without changing anything",
    )
    reconcile.set_defaults(func=_cmd_reconcile)

    serve = sub.add_parser("serve", help="Run the resource-manager HTTP API + UI")
    serve.add_argument("--host", default="127.0.0.1", help="Bind address (default 127.0.0.1)")
    serve.add_argument("--port", type=int, default=7000, help="Bind port (default 7000)")
    serve.set_defaults(func=_cmd_serve)

    update = sub.add_parser(
        "update",
        help="Check for or apply a Furtka release (Phase 2 self-update)",
    )
    update.add_argument(
        "--check",
        action="store_true",
        help="Only check whether an update is available; don't apply",
    )
    update.add_argument(
        "--json",
        action="store_true",
        help="Emit machine-readable JSON (only honoured with --check)",
    )
    update.set_defaults(func=_cmd_update)

    rollback = sub.add_parser(
        "rollback",
        help="Flip /opt/furtka/current back to the previous version slot",
    )
    rollback.set_defaults(func=_cmd_rollback)

    return p


def main(argv: list[str] | None = None) -> int:
    args = build_parser().parse_args(argv)
    return args.func(args)


if __name__ == "__main__":
    sys.exit(main())