refactorai-cli 0.1.0__py3-none-any.whl

refactor_cli/commands/runtime_cmds.py

@@ -0,0 +1,164 @@
+"""Runtime and license commands for proprietary local runtime management (R12)."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from refactor_cli.auth import AuthError, ensure_authenticated
+from refactor_cli.control_plane import ensure_lease, heartbeat, read_cached_lease, resolve_policy
+from refactor_cli.runtime_manager import (
+    activate_runtime,
+    download_artifact,
+    resolve_runtime_manifest,
+    rollback_runtime,
+    runtime_status,
+)
+
+console = Console()
+app = typer.Typer(help="Manage local proprietary runtime artifacts.")
+license_app = typer.Typer(help="Inspect developer-key license/auth state.")
+
+
+def _require_auth(*, force_remote: bool = False):
+    try:
+        return ensure_authenticated(force_remote=force_remote)
+    except AuthError as exc:
+        console.print(f"[red]Blocked:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+
+@app.command("status")
+def status() -> None:
+    """Show active runtime version and artifact state."""
+    data = runtime_status()
+    active = data.get("active_version") or "<none>"
+    rollback = data.get("rollback_version") or "<none>"
+    exists = bool(data.get("active_artifact_exists"))
+    icon = "yes" if exists else "no"
+    console.print(f"[bold]active runtime[/bold]: {active}")
+    console.print(f"[bold]rollback runtime[/bold]: {rollback}")
+    console.print(f"[bold]channel[/bold]: {data.get('channel')}")
+    console.print(f"[bold]updated at[/bold]: {data.get('updated_at') or '<never>'}")
+    console.print(f"[bold]active artifact present[/bold]: {icon}")
+    if active and not exists:
+        console.print(
+            "[yellow]Active runtime points to a missing artifact.[/yellow] "
+            "Run `refactor runtime update` to recover."
+        )
+
+
+@app.command("update")
+def update(
+    channel: str = typer.Option("stable", "--channel", help="Runtime release channel."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Resolve/verify only; do not activate."),
+) -> None:
+    """Resolve and install the latest runtime artifact for the channel."""
+    _require_auth(force_remote=True)
+    outcome = "error"
+    try:
+        manifest = resolve_runtime_manifest(channel=channel)
+        console.print(
+            f"[bold]resolved manifest[/bold]: version={manifest.runtime_version} "
+            f"channel={channel}"
+        )
+        artifact = download_artifact(manifest.artifact_url)
+        console.print(f"[bold]downloaded artifact[/bold]: {len(artifact)} bytes")
+        if dry_run:
+            # Verification happens in activate_runtime; dry-run still checks
+            # integrity by attempting activation in-memory style via duplicate call.
+            # We use a no-op by verifying digest directly in manager on activation.
+            from refactor_cli.runtime_manager import verify_sha256  # local import to keep module surface small
+
+            ok = verify_sha256(artifact, manifest.sha256)
+            if not ok:
+                raise RuntimeError("Runtime artifact checksum verification failed")
+            console.print("[green]Dry run OK:[/green] manifest resolved and artifact verified.")
+            outcome = "ok"
+            return
+        artifact_path = activate_runtime(manifest, artifact, channel=channel)
+        console.print(
+            f"[green]Runtime activated.[/green] version={manifest.runtime_version} "
+            f"path={artifact_path}"
+        )
+        outcome = "ok"
+    except RuntimeError as exc:
+        console.print(f"[red]Runtime update failed:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+    finally:
+        heartbeat(
+            command="runtime.update",
+            result=outcome,
+            duration_ms=0,
+            runtime_version=str(runtime_status().get("active_version") or ""),
+        )
+
+
+@app.command("rollback")
+def rollback() -> None:
+    """Switch active runtime to the recorded rollback version."""
+    _require_auth()
+    try:
+        version = rollback_runtime()
+    except RuntimeError as exc:
+        console.print(f"[red]Runtime rollback failed:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
+    console.print(f"[green]Runtime rollback complete.[/green] active_version={version}")
+
+
+@license_app.command("status")
+def license_status(
+    force_remote: bool = typer.Option(
+        False,
+        "--force-remote",
+        help="Bypass local validation cache and revalidate with control plane.",
+    )
+) -> None:
+    """Show resolved auth/license state from developer key validation."""
+    auth_ctx = _require_auth(force_remote=force_remote)
+    try:
+        lease = ensure_lease(force_refresh=True) if force_remote else read_cached_lease()
+    except RuntimeError as exc:
+        lease = None
+        console.print(f"[yellow]lease[/yellow]: unavailable ({exc})")
+    quota = auth_ctx.quota_remaining
+    quota_text = str(quota) if quota is not None else "unknown"
+    source = auth_ctx.key.source
+    cached = "yes" if auth_ctx.cached else "no"
+    console.print(f"[bold]account[/bold]: {auth_ctx.account_id}")
+    console.print(f"[bold]key source[/bold]: {source}")
+    console.print(f"[bold]cached validation[/bold]: {cached}")
+    console.print(f"[bold]quota remaining[/bold]: {quota_text}")
+    if lease is not None:
+        expires = int(max(0, lease.expires_at_epoch))
+        console.print(f"[bold]lease cached[/bold]: {'yes' if lease.cached else 'no'}")
+        console.print(f"[bold]lease expires (epoch)[/bold]: {expires}")
+        console.print(f"[bold]lease capabilities[/bold]: {', '.join(lease.capabilities) or '<none>'}")
+        console.print(f"[bold]policy revision[/bold]: {lease.policy_revision or '<unknown>'}")
+
+
+@license_app.command("refresh")
+def license_refresh() -> None:
+    """Refresh lease and policy from control plane."""
+    _require_auth(force_remote=True)
+    try:
+        lease = ensure_lease(force_refresh=True)
+        policy = resolve_policy(force_refresh=True)
+    except RuntimeError as exc:
+        console.print(f"[red]License refresh failed:[/red] {exc}")
+        heartbeat(command="license.refresh", result="error", duration_ms=0)
+        raise typer.Exit(code=1) from exc
+    revision = str((policy.get("bundle") or {}).get("revision_id") or lease.policy_revision or "<unknown>")
+    console.print(
+        f"[green]License refreshed.[/green] account={lease.account_id} "
+        f"capabilities={len(lease.capabilities)} policy={revision}"
+    )
+    heartbeat(
+        command="license.refresh",
+        result="ok",
+        duration_ms=0,
+        policy_revision=revision,
+    )
+
+
+app.add_typer(license_app, name="license")

refactor_cli/commands/setup_cmds.py

@@ -0,0 +1,69 @@
+"""Setup bootstrap command (R16)."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from refactor_cli.setup_flow import STAGE_IDS, SetupError, get_setup_diagnostics, run_setup
+
+console = Console()
+
+
+def _ask_approval(auto_approve: bool, prompt: str) -> bool:
+    if auto_approve:
+        return True
+    if not typer.confirm(prompt, default=False):
+        return False
+    return True
+
+
+def setup(
+    yes: bool = typer.Option(False, "--yes", help="Auto-approve setup actions."),
+    resume: bool = typer.Option(False, "--resume", help="Resume from last incomplete stage."),
+    from_stage: str | None = typer.Option(
+        None,
+        "--from-stage",
+        help=f"Start from a specific stage ({', '.join(STAGE_IDS)}).",
+    ),
+    diagnostics: bool = typer.Option(False, "--diagnostics", help="Print setup checkpoint diagnostics and exit."),
+) -> None:
+    """Bootstrap local machine/runtime and execution backend for refactor."""
+    if diagnostics:
+        payload = get_setup_diagnostics()
+        state = payload.get("state") or {}
+        console.print(f"[bold]status[/bold]: {state.get('status', 'unknown')}")
+        console.print(f"[bold]current stage[/bold]: {state.get('current_stage') or '<none>'}")
+        console.print(f"[bold]backend[/bold]: {state.get('execution_backend') or '<unset>'}")
+        console.print(f"[bold]completed[/bold]: {', '.join(state.get('completed_stages') or []) or '<none>'}")
+        if state.get("last_error"):
+            console.print(f"[yellow]last error[/yellow]: {state['last_error']}")
+        stages = payload.get("stages") or {}
+        if stages:
+            console.print("[bold]stage outputs[/bold]:")
+            for stage_id in STAGE_IDS:
+                if stage_id not in stages:
+                    continue
+                data = stages[stage_id] or {}
+                console.print(f"  - {stage_id}: {data.get('stage', stage_id)}")
+        return
+    try:
+        result = run_setup(
+            auto_approve=yes,
+            resume=resume,
+            from_stage=from_stage,
+            ask_approval=lambda prompt: _ask_approval(yes, prompt),
+        )
+    except SetupError as exc:
+        console.print(f"[red]Setup failed:[/red] {exc}")
+        console.print("[yellow]Tip:[/yellow] Re-run with `refactor setup --resume` after addressing the issue.")
+        raise typer.Exit(code=1) from exc
+    if result.status == "already_completed":
+        console.print("[green]Setup already completed.[/green]")
+        console.print("Run `refactor setup --from-stage S3` to re-run a subset.")
+        return
+    console.print("[green]Setup completed successfully.[/green]")
+    if result.execution_backend:
+        console.print(f"[bold]backend[/bold]: {result.execution_backend}")
+    console.print(f"[bold]completed stages[/bold]: {', '.join(result.completed_stages)}")
+    console.print("[bold]next[/bold]: run `refactor init` and then `refactor review .`")

refactor_cli/control_plane.py

@@ -0,0 +1,240 @@
+"""Lease/policy/heartbeat client for control-plane contracts (R14)."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+import httpx
+
+from refactor_core.paths import ensure_dir, refactor_home
+
+from refactor_cli.credentials import resolve_developer_key
+from refactor_cli.settings import platform_url, policy_signing_key
+
+LEASE_DIR = "leases"
+LEASE_FILE = "current.json"
+POLICY_DIR = "policy"
+POLICY_FILE = "current.json"
+
+
+@dataclass
+class LeaseContext:
+    token: str
+    account_id: str
+    expires_at_epoch: float
+    refresh_after_epoch: float
+    capabilities: list[str]
+    policy_revision: str
+    offline_grace_seconds: int
+    cached: bool
+
+
+def _lease_path() -> Path:
+    return refactor_home() / LEASE_DIR / LEASE_FILE
+
+
+def _policy_path() -> Path:
+    return refactor_home() / POLICY_DIR / POLICY_FILE
+
+
+def _parse_iso_epoch(value: str | None) -> float:
+    if not value:
+        return 0.0
+    try:
+        dt = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except ValueError:
+        return 0.0
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.timestamp()
+
+
+def _read_json(path: Path) -> dict | None:
+    if not path.is_file():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _write_json(path: Path, payload: dict) -> None:
+    ensure_dir(path.parent)
+    data = json.dumps(payload, indent=2).encode("utf-8")
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    with tmp.open("wb") as handle:
+        handle.write(data)
+        handle.flush()
+    tmp.replace(path)
+
+
+def _policy_signature(bundle: dict) -> str:
+    canonical = json.dumps(bundle, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    digest = hmac.new(policy_signing_key().encode("utf-8"), canonical, hashlib.sha256).hexdigest()
+    return f"hmac-sha256:{digest}"
+
+
+def _verify_policy_payload(payload: dict) -> bool:
+    bundle = dict(payload.get("bundle") or {})
+    signature = str(payload.get("signature") or "")
+    if not bundle or not signature:
+        return False
+    return hmac.compare_digest(signature, _policy_signature(bundle))
+
+
+def _from_cached(payload: dict) -> LeaseContext | None:
+    token = str(payload.get("lease_token") or "")
+    account_id = str(payload.get("account_id") or "unknown")
+    expires_at = float(payload.get("expires_at_epoch") or 0.0)
+    refresh_after = float(payload.get("refresh_after_epoch") or 0.0)
+    now = time.time()
+    if not token or expires_at <= now:
+        return None
+    return LeaseContext(
+        token=token,
+        account_id=account_id,
+        expires_at_epoch=expires_at,
+        refresh_after_epoch=refresh_after,
+        capabilities=list(payload.get("capabilities") or []),
+        policy_revision=str(payload.get("policy_revision") or ""),
+        offline_grace_seconds=int(payload.get("offline_grace_seconds") or 0),
+        cached=True,
+    )
+
+
+def read_cached_lease() -> LeaseContext | None:
+    payload = _read_json(_lease_path())
+    if not payload:
+        return None
+    return _from_cached(payload)
+
+
+def request_lease(*, timeout: float = 20.0, cli_version: str = "0.1.0") -> LeaseContext:
+    resolved = resolve_developer_key()
+    if not resolved:
+        raise RuntimeError(
+            "No developer key configured. Run `refactor login`, set REFACTOR_API_KEY, "
+            "or add developer_key to refactor.config."
+        )
+    try:
+        response = httpx.post(
+            f"{platform_url()}/v1/license/lease",
+            headers={"Authorization": f"Bearer {resolved.key}", "Content-Type": "application/json"},
+            json={"cli_version": cli_version},
+            timeout=timeout,
+        )
+    except httpx.HTTPError as exc:
+        raise RuntimeError(f"Could not request lease: {exc}") from exc
+    if response.status_code >= 400:
+        raise RuntimeError(f"Lease request failed ({response.status_code}): {response.text[:500]}")
+    payload = response.json() if response.content else {}
+    token = str(payload.get("lease_token") or "")
+    expires_at_epoch = _parse_iso_epoch(payload.get("expires_at"))
+    refresh_after_epoch = _parse_iso_epoch(payload.get("refresh_after"))
+    account_id = str(payload.get("account_id") or "unknown")
+    context = LeaseContext(
+        token=token,
+        account_id=account_id,
+        expires_at_epoch=expires_at_epoch,
+        refresh_after_epoch=refresh_after_epoch,
+        capabilities=list(payload.get("capabilities") or []),
+        policy_revision=str(payload.get("policy_revision") or ""),
+        offline_grace_seconds=int(payload.get("offline_grace_seconds") or 0),
+        cached=False,
+    )
+    _write_json(
+        _lease_path(),
+        {
+            "lease_token": context.token,
+            "account_id": context.account_id,
+            "expires_at_epoch": context.expires_at_epoch,
+            "refresh_after_epoch": context.refresh_after_epoch,
+            "capabilities": context.capabilities,
+            "policy_revision": context.policy_revision,
+            "offline_grace_seconds": context.offline_grace_seconds,
+            "issued_at_epoch": time.time(),
+        },
+    )
+    return context
+
+
+def ensure_lease(*, force_refresh: bool = False) -> LeaseContext:
+    if not force_refresh:
+        cached = read_cached_lease()
+        if cached:
+            now = time.time()
+            if cached.refresh_after_epoch <= 0 or now < cached.refresh_after_epoch:
+                return cached
+            try:
+                return request_lease()
+            except RuntimeError:
+                # Best-effort refresh; keep using non-expired lease.
+                return cached
+    return request_lease()
+
+
+def resolve_policy(*, force_refresh: bool = False, project_id: str | None = None, timeout: float = 20.0) -> dict:
+    if not force_refresh:
+        cached = _read_json(_policy_path())
+        if cached and _verify_policy_payload(cached):
+            return cached
+    lease = ensure_lease()
+    try:
+        response = httpx.post(
+            f"{platform_url()}/v1/policy/resolve",
+            headers={"Authorization": f"Bearer {lease.token}", "Content-Type": "application/json"},
+            json={"project_id": project_id},
+            timeout=timeout,
+        )
+    except httpx.HTTPError as exc:
+        raise RuntimeError(f"Could not resolve policy bundle: {exc}") from exc
+    if response.status_code >= 400:
+        raise RuntimeError(f"Policy resolve failed ({response.status_code}): {response.text[:500]}")
+    payload = response.json() if response.content else {}
+    if not _verify_policy_payload(payload):
+        raise RuntimeError("Policy signature verification failed")
+    _write_json(_policy_path(), payload)
+    return payload
+
+
+def heartbeat(
+    *,
+    command: str,
+    result: str,
+    duration_ms: int,
+    model_id: str = "",
+    runtime_version: str = "",
+    policy_revision: str = "",
+    timeout: float = 10.0,
+) -> bool:
+    try:
+        lease = ensure_lease()
+    except RuntimeError:
+        return False
+    account_hash = hashlib.sha256(lease.account_id.encode("utf-8")).hexdigest()[:16]
+    payload = {
+        "account_id_hash": account_hash,
+        "command": command,
+        "result": result,
+        "duration_ms": max(0, int(duration_ms)),
+        "model_id": model_id,
+        "runtime_version": runtime_version,
+        "policy_revision": policy_revision or lease.policy_revision,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }
+    try:
+        response = httpx.post(
+            f"{platform_url()}/v1/license/heartbeat",
+            headers={"Authorization": f"Bearer {lease.token}", "Content-Type": "application/json"},
+            json=payload,
+            timeout=timeout,
+        )
+    except httpx.HTTPError:
+        return False
+    return response.status_code < 400

refactor_cli/credentials.py

@@ -0,0 +1,71 @@
+"""Developer key storage and resolution.
+
+Resolution precedence (highest wins), per ADR-203:
+  1. ``REFACTOR_API_KEY`` environment variable
+  2. ``developer_key`` in ``refactor.config`` (``${ENV}`` interpolated)
+  3. central credentials file ``~/.refactor/credentials.json``
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from refactor_core.constitution import find_config, load_config
+from refactor_core.paths import credentials_path, ensure_dir, refactor_home
+
+from refactor_cli.settings import env_api_key
+
+
+@dataclass
+class ResolvedKey:
+    key: str
+    source: str  # "env" | "config" | "credentials"
+
+
+def load_credentials() -> dict:
+    path = credentials_path()
+    if not path.is_file():
+        return {}
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_credentials(data: dict) -> Path:
+    ensure_dir(refactor_home())
+    path = credentials_path()
+    path.write_text(json.dumps(data, indent=2, sort_keys=True), encoding="utf-8")
+    os.chmod(path, 0o600)
+    return path
+
+
+def _config_key(project_root: Path | None) -> str | None:
+    config_path = find_config(project_root)
+    if not config_path:
+        return None
+    config = load_config(config_path)
+    value = config.get_setting("developer_key")
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return None
+
+
+def resolve_developer_key(project_root: Path | None = None) -> ResolvedKey | None:
+    """Resolve the developer key using the documented precedence."""
+    env_key = env_api_key()
+    if env_key:
+        return ResolvedKey(key=env_key, source="env")
+
+    config_key = _config_key(project_root)
+    if config_key:
+        return ResolvedKey(key=config_key, source="config")
+
+    stored = load_credentials().get("developer_key")
+    if isinstance(stored, str) and stored.strip():
+        return ResolvedKey(key=stored.strip(), source="credentials")
+
+    return None

refactor_cli/main.py

@@ -0,0 +1,68 @@
+"""`refactor` CLI entry point."""
+
+from __future__ import annotations
+
+import typer
+
+from refactor_cli import __version__
+from refactor_cli.commands import auth_cmds, engine_cmds, model_cmds, rules_cmds, run_cmds, runtime_cmds, setup_cmds
+
+app = typer.Typer(
+    name="refactor",
+    help="Local-first AI code review and refactor, run from your project folder.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"refactor {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show the CLI version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """refactor CLI."""
+
+
+# Auth (R7.1)
+app.command()(auth_cmds.login)
+app.command()(auth_cmds.whoami)
+
+# Project / run surface (R7.0 scaffolding; auth-guarded where required)
+app.command()(run_cmds.init)
+app.command()(run_cmds.start)
+app.command()(run_cmds.stop)
+app.command()(run_cmds.shell)
+app.command()(run_cmds.review)
+app.command()(run_cmds.code)
+app.command()(run_cmds.requests)
+app.command()(run_cmds.apply)
+app.command()(run_cmds.revert)
+app.command()(run_cmds.status)
+app.command()(run_cmds.diff)
+app.command()(run_cmds.gc)
+app.command()(run_cmds.check)
+app.command()(run_cmds.doctor)
+app.command()(run_cmds.config)
+app.command()(setup_cmds.setup)
+
+# Rule policy introspection (R12)
+app.add_typer(rules_cmds.app, name="rules")
+app.add_typer(runtime_cmds.app, name="runtime")
+app.add_typer(engine_cmds.app, name="engine")
+app.add_typer(model_cmds.app, name="model")
+
+
+if __name__ == "__main__":
+    app()