deployforge 0.1.0__py3-none-any.whl

deployforge/cli.py

@@ -0,0 +1,825 @@
+"""DeployForge command-line interface.
+
+Primary experience::
+
+    deployforge
+
+inside any existing GitHub-backed project. Additional commands cover
+analyze, deploy, status, verify, security, doctor, config, and logs.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+from rich.table import Table
+
+from deployforge.__version__ import __version__
+from deployforge.analyzer import analyze_project
+from deployforge.config import (
+    ConfigError,
+    KeyringSecrets,
+    ProjectConfig,
+    ProjectConfigManager,
+    default_config_path,
+    default_data_dir,
+    resolve_render_api_key,
+    resolve_vercel_token,
+)
+from deployforge.deployment import (
+    DeployOutcome,
+    build_plan,
+    verify_endpoints,
+)
+from deployforge.deployment.orchestrator import run_deploy
+from deployforge.errors import (
+    AuthenticationError,
+    DeployForgeError,
+    DeploymentError,
+    PartialDeploymentError,
+    ProjectError,
+    ProviderError,
+    SecurityError,
+)
+from deployforge.github.integration import github_token, repo_exists
+from deployforge.providers import build_providers
+from deployforge.providers.base import DeploymentResult
+from deployforge.ui import (
+    banner,
+    error,
+    fail,
+    info,
+    link,
+    live_panel,
+    note,
+    ok,
+    prompt_yes_no,
+    section,
+    spinner,
+    step,
+    warn,
+)
+
+app = typer.Typer(
+    name="deployforge",
+    help="From GitHub to a Live Application. Automatically.",
+    add_completion=False,
+    no_args_is_help=False,
+    rich_markup_mode="rich",
+    pretty_exceptions_show_locals=False,
+    pretty_exceptions_short=False,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+# ---------------------------------------------------------------------------
+# Shared plumbing
+# ---------------------------------------------------------------------------
+
+
+def _project_config(project: Path) -> ProjectConfig:
+    try:
+        return ProjectConfigManager(project).load()
+    except ConfigError as exc:
+        error(str(exc))
+        raise typer.Exit(code=1) from exc
+
+
+def _providers(config: ProjectConfig) -> dict:
+    secrets = KeyringSecrets()
+    vercel = resolve_vercel_token(secrets)
+    render = resolve_render_api_key(secrets)
+    return build_providers(vercel, render)
+
+
+def _confirm(message: str) -> bool:
+    return prompt_yes_no(message)
+
+
+def _step(message: str) -> None:
+    step(message)
+
+
+def _auto_deploy(
+    project: Path,
+    *,
+    dry_run: bool,
+    non_interactive: bool,
+    debug: bool,
+    skip_security: bool,
+    timeout: int,
+    plan_name: str,
+) -> DeployOutcome:
+    config = _project_config(project)
+    section("Analyzing project")
+    analysis = analyze_project(project, config)
+
+    with spinner("Analyzing project…"):
+        if analysis.repo.exists:
+            ok("GitHub repository detected")
+            if analysis.repo.url:
+                note(f"  Repository: {analysis.repo.url}")
+        elif analysis.repo.branch:
+            ok("Git repository detected (no GitHub remote)")
+        else:
+            warn("No git repository detected")
+        ok("Project structure analyzed")
+
+    if not analysis.has_frontend and not analysis.has_backend:
+        fail(
+            "No deployable application detected.",
+            hint="DeployForge looks for frontend frameworks (Next.js, Vite, …), "
+            "Python or Node.js backends, and monorepo workspaces.",
+        )
+        raise typer.Exit(code=1)
+
+    plan = build_plan(analysis)
+    _render_architecture(analysis, plan)
+
+    if not analysis.repo.exists and not analysis.repo.slug() and not dry_run:
+        fail(
+            "No GitHub repository detected.",
+            hint="DeployForge works best with PushForge.\n\n"
+            "    pushforge\n\n"
+            "Then return here and run:\n\n"
+            "    deployforge",
+        )
+        raise typer.Exit(code=1)
+
+    _render_plan(plan, analysis)
+
+    if not non_interactive and not dry_run and not _confirm("Continue?"):
+        info("Deployment cancelled by user.")
+        raise typer.Exit(code=0)
+
+    providers = _providers(config)
+    outcome = run_deploy(
+        analysis,
+        plan,
+        providers,
+        security_enabled=config.security_enabled and not skip_security,
+        block_on_secrets=config.block_on_secrets,
+        security_level="normal",
+        dry_run=dry_run,
+        non_interactive=non_interactive,
+        confirm=_confirm,
+        on_step=_step,
+        timeout=timeout,
+        plan_name=plan_name,
+    )
+    return outcome
+
+
+def _render_architecture(analysis, plan) -> None:
+    table = Table(title="Application Architecture", header_style="bold blue")
+    table.add_column("Component")
+    table.add_column("Technology")
+    table.add_column("Route")
+    for service in plan.services:
+        table.add_row(service.kind.title(), service.framework, service.provider)
+    if (db := getattr(analysis, "database", None)) is not None and getattr(db, "engine", None):
+        table.add_row("Database", db.engine, "existing" if db.configured else "—")
+    if analysis.backend:
+        backend = analysis.backend
+        if backend.start_command:
+            note(f"  Backend entry point: {backend.start_command}")
+    from deployforge.ui import console
+
+    console.print(table)
+
+
+def _render_plan(plan, analysis) -> None:
+    section("Deployment plan")
+    for service in plan.services:
+        note(f"{service.kind.title()}: {service.framework} → {service.provider}")
+    for env in plan.env_vars:
+        note(f"  {env.key} → {env.provider}")
+    if plan.database_note:
+        warn(plan.database_note)
+    if not plan.services:
+        warn("Nothing to deploy.")
+        return
+
+
+def _render_outcome(outcome: DeployOutcome) -> None:
+    if outcome.dry_run:
+        warn("Dry run — no changes were made.")
+        return
+    section("Done")
+    lines: list[tuple[str, str]] = []
+    if outcome.frontend_url:
+        ok("Frontend deployed")
+        link(outcome.frontend_url)
+        lines.append(("Frontend", outcome.frontend_url))
+    if outcome.backend_url:
+        ok("Backend deployed")
+        link(outcome.backend_url)
+        lines.append(("Backend", outcome.backend_url))
+    for key, value in outcome.env_vars_set:
+        ok(f"{key} configured")
+        note(f"  {key}={value}")
+    if outcome.verification:
+        for result in outcome.verification.results:
+            if result.reachable:
+                ok(f"{result.name} reachable ({result.status_code})")
+            else:
+                fail(f"{result.name} not reachable")
+    if lines:
+        state = "✓ CONFIGURED" if outcome.env_vars_set else "— NOT REQUIRED"
+        lines.append(("API Connection", state))
+        live_panel("🚀 APPLICATION LIVE", lines)
+
+
+# ---------------------------------------------------------------------------
+# Default: deployforge
+# ---------------------------------------------------------------------------
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview without changing anything."),
+    non_interactive: bool = typer.Option(
+        False, "--non-interactive", help="Run without prompts (for CI/CD)."
+    ),
+    debug: bool = typer.Option(False, "--debug", help="Show debug detail."),
+    skip_security: bool = typer.Option(
+        False, "--skip-security", help="Disable the security preflight."
+    ),
+    timeout: int = typer.Option(
+        900, "--timeout", help="Deployment wait timeout in seconds.", show_default=True
+    ),
+    plan: str = typer.Option(
+        "starter", "--plan", help="Render plan: free | starter | pro.", show_default=True
+    ),
+) -> None:
+    """Deploy the current GitHub-backed project (analyze → plan → deploy → verify)."""
+    if ctx.invoked_subcommand is not None:
+        return
+    banner()
+    project = Path.cwd()
+    if dry_run:
+        section("DRY RUN")
+    try:
+        outcome = _auto_deploy(
+            project,
+            dry_run=dry_run,
+            non_interactive=non_interactive,
+            debug=debug,
+            skip_security=skip_security,
+            timeout=timeout,
+            plan_name=plan,
+        )
+    except SecurityError as exc:
+        error(str(exc))
+        raise typer.Exit(code=3) from exc
+    except PartialDeploymentError as exc:
+        error(str(exc))
+        raise typer.Exit(code=4) from exc
+    except (DeploymentError, ProviderError, AuthenticationError, ProjectError) as exc:
+        error(str(exc))
+        raise typer.Exit(code=1) from exc
+    _render_outcome(outcome)
+
+
+# ---------------------------------------------------------------------------
+# deployforge analyze
+# ---------------------------------------------------------------------------
+
+
+@app.command("analyze")
+def analyze_cmd(
+    path: Path = typer.Argument(Path("."), help="Project directory."),
+) -> None:
+    """Analyze the project architecture without deploying anything."""
+    banner()
+    if not path.exists() or not path.is_dir():
+        error(f"Path does not exist or is not a directory: {path}")
+        raise typer.Exit(code=2)
+    config = _project_config(path)
+    analysis = analyze_project(path, config)
+    plan = build_plan(analysis)
+
+    section("APPLICATION ANALYSIS")
+    info(f"Project: {analysis.name}")
+    note(f"Repository: {path.resolve()}")
+
+    if analysis.repo.exists:
+        ok("GitHub repository detected")
+        if analysis.repo.url:
+            note(f"  {analysis.repo.url}")
+    else:
+        warn("No GitHub repository detected")
+
+    if not analysis.has_frontend and not analysis.has_backend:
+        fail("No deployable application detected.")
+        return
+
+    _render_architecture(analysis, plan)
+    if plan.database_note:
+        warn(plan.database_note)
+    step("Recommended deployment")
+    for service in plan.services:
+        note(f"  {service.kind.title()}: {service.framework} → {service.provider}")
+    for env in plan.env_vars:
+        note(f"  {env.key} → {env.provider}")
+    step("Run:")
+    note("  deployforge deploy")
+
+
+# ---------------------------------------------------------------------------
+# deployforge deploy
+# ---------------------------------------------------------------------------
+
+
+@app.command("deploy")
+def deploy_cmd(
+    path: Path = typer.Argument(Path("."), help="Project directory."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview without changing anything."),
+    non_interactive: bool = typer.Option(
+        False, "--non-interactive", help="Run without prompts (for CI/CD)."
+    ),
+    debug: bool = typer.Option(False, "--debug", help="Show debug detail."),
+    skip_security: bool = typer.Option(
+        False, "--skip-security", help="Disable the security preflight."
+    ),
+    timeout: int = typer.Option(
+        900, "--timeout", help="Deployment wait timeout in seconds.", show_default=True
+    ),
+    plan: str = typer.Option(
+        "starter", "--plan", help="Render plan: free | starter | pro.", show_default=True
+    ),
+) -> None:
+    """Deploy the project to production (analyze → plan → deploy → verify)."""
+    banner()
+    if not path.exists() or not path.is_dir():
+        error(f"Path does not exist or is not a directory: {path}")
+        raise typer.Exit(code=2)
+    if dry_run:
+        section("DRY RUN")
+    try:
+        outcome = _auto_deploy(
+            path,
+            dry_run=dry_run,
+            non_interactive=non_interactive,
+            debug=debug,
+            skip_security=skip_security,
+            timeout=timeout,
+            plan_name=plan,
+        )
+    except SecurityError as exc:
+        error(str(exc))
+        raise typer.Exit(code=3) from exc
+    except PartialDeploymentError as exc:
+        error(str(exc))
+        raise typer.Exit(code=4) from exc
+    except (DeploymentError, ProviderError, AuthenticationError, ProjectError) as exc:
+        error(str(exc))
+        raise typer.Exit(code=1) from exc
+    _render_outcome(outcome)
+
+
+# ---------------------------------------------------------------------------
+# deployforge init
+# ---------------------------------------------------------------------------
+
+
+@app.command("init")
+def init_cmd(
+    path: Path = typer.Argument(Path("."), help="Project directory."),
+    force: bool = typer.Option(False, "--force", help="Overwrite an existing config."),
+) -> None:
+    """Create the .deployforge/config.yml for a project."""
+    banner()
+    if not path.exists() or not path.is_dir():
+        error(f"Path does not exist or is not a directory: {path}")
+        raise typer.Exit(code=2)
+    manager = ProjectConfigManager(path)
+    if manager.path.exists() and not force:
+        warn(f"Config already exists at {manager.path}")
+        info("Use --force to overwrite it.")
+        return
+    analysis = analyze_project(path, manager.load())
+    config = ProjectConfig(
+        name=analysis.name,
+        branch=analysis.repo.branch or "main",
+        github_repository=analysis.repo.slug(),
+        frontend_directory=analysis.frontend.directory.relative_to(path).as_posix()
+        if analysis.has_frontend and analysis.frontend
+        else None,
+        backend_directory=analysis.backend.directory.relative_to(path).as_posix()
+        if analysis.has_backend and analysis.backend
+        else None,
+    )
+    manager.save(config)
+    ok(f"Configuration written to {manager.path}")
+    note("Never store secrets in .deployforge/config.yml.")
+
+
+# ---------------------------------------------------------------------------
+# deployforge status
+# ---------------------------------------------------------------------------
+
+
+@app.command("status")
+def status_cmd(
+    path: Path = typer.Argument(Path("."), help="Project directory."),
+) -> None:
+    """Show project, repository, and deployment status."""
+    banner()
+    config = _project_config(path)
+    analysis = analyze_project(path, config)
+
+    from deployforge.ui import console
+
+    table = Table(title="DEPLOYFORGE STATUS", header_style="bold blue")
+    table.add_column("Item")
+    table.add_column("Value")
+    table.add_row("Application", analysis.name)
+    table.add_row("Directory", str(path.resolve()))
+    table.add_row("GitHub", f"✓ {analysis.repo.slug()}" if analysis.repo.slug() else "—")
+    table.add_row("Branch", analysis.repo.branch or "—")
+
+    secrets = KeyringSecrets()
+    vercel_token = resolve_vercel_token(secrets)
+    render_key = resolve_render_api_key(secrets)
+    table.add_row("Vercel auth", "✓ available" if vercel_token else "— not configured")
+    table.add_row("Render auth", "✓ available" if render_key else "— not configured")
+
+    if analysis.frontend:
+        fe = analysis.frontend
+        table.add_row(
+            "Frontend",
+            f"{fe.framework} ({fe.directory.name}) → {fe.provider}",
+        )
+    else:
+        table.add_row("Frontend", "—")
+    if analysis.backend:
+        be = analysis.backend
+        table.add_row(
+            "Backend",
+            f"{be.framework} ({be.directory.name}) → {be.provider}",
+        )
+    else:
+        table.add_row("Backend", "—")
+
+    last = _last_log_entry()
+    if last:
+        if last.get("frontend_url"):
+            table.add_row("Frontend URL", last["frontend_url"])
+        if last.get("backend_url"):
+            table.add_row("Backend URL", last["backend_url"])
+    from deployforge.integration import connection_summary
+
+    for line in connection_summary(analysis):
+        table.add_row("Integration", line)
+    console.print(table)
+    note("Status reflects the last recorded deployment. Run 'deployforge verify' for live checks.")
+
+
+# ---------------------------------------------------------------------------
+# deployforge verify
+# ---------------------------------------------------------------------------
+
+
+@app.command("verify")
+def verify_cmd(
+    frontend_url: str | None = typer.Option(None, "--frontend", help="Frontend URL to check."),
+    backend_url: str | None = typer.Option(None, "--backend", help="Backend URL to check."),
+) -> None:
+    """Verify deployed services are reachable."""
+    banner()
+    last = _last_log_entry()
+    fe_url = frontend_url or (last.get("frontend_url") if last else None)
+    be_url = backend_url or (last.get("backend_url") if last else None)
+    if not fe_url and not be_url:
+        warn("No deployed URLs found for this machine.")
+        info("Pass --frontend and/or --backend, or deploy first with 'deployforge'.")
+        return
+    section("Verification")
+    pairs: list[tuple[str, str, str | None]] = []
+    if fe_url:
+        pairs.append(("Frontend", fe_url, None))
+    if be_url:
+        pairs.append(("Backend", be_url, "/health"))
+    report = verify_endpoints(pairs)
+    for result in report.results:
+        if result.reachable:
+            ok(f"{result.name} HTTP {result.status_code} ({result.latency_ms}ms)")
+            if result.health_ok is True:
+                ok(f"{result.name} health endpoint OK")
+        else:
+            fail(f"{result.name} not reachable {result.url}")
+    if report.passed:
+        step("Deployment healthy.")
+    else:
+        fail("Deployment unhealthy.")
+
+
+# ---------------------------------------------------------------------------
+# deployforge security
+# ---------------------------------------------------------------------------
+
+
+@app.command("security")
+def security_cmd(
+    path: Path = typer.Argument(Path("."), help="Project directory to scan."),
+    level: str = typer.Option("normal", "--level", help="off | normal | strict."),
+) -> None:
+    """Run the security preflight independently."""
+    from deployforge.security import scan_project
+    from deployforge.ui import console
+
+    banner()
+    if not path.exists() or not path.is_dir():
+        error(f"Path does not exist or is not a directory: {path}")
+        raise typer.Exit(code=2)
+    section("DeployForge Security Scan")
+    with spinner("Scanning…"):
+        report = scan_project(path, level=level)
+    ok(f"Sensitive file detection ({len(report.sensitive_files)} blocked file kinds)")
+    ok(f"Secret pattern scan ({len(report.findings)} findings)")
+    if report.gitignore_ok:
+        ok(".gitignore validation")
+    else:
+        warn(f".gitignore missing rules: {', '.join(report.gitignore_missing)}")
+
+    if report.findings:
+        table = Table(title="Findings", header_style="bold red")
+        table.add_column("Confidence")
+        table.add_column("Name")
+        table.add_column("Location")
+        for finding in report.findings:
+            location = finding.file + (f":{finding.line}" if finding.line else "")
+            confidence = "[bold red]high[/bold red]" if finding.confidence == "high" else "low"
+            table.add_row(confidence, finding.name, location)
+        console.print(table)
+    else:
+        ok("No secret patterns detected.")
+
+    if report.high_confidence:
+        fail("SECURITY PREFLIGHT: not ready — potential secrets found.")
+        raise typer.Exit(code=3)
+    step("RESULT: SECURE ENOUGH TO PROCEED")
+    note("This is a preflight check, not a guarantee that the application is secure.")
+
+
+# ---------------------------------------------------------------------------
+# deployforge doctor
+# ---------------------------------------------------------------------------
+
+
+@app.command("doctor")
+def doctor_cmd(
+    path: Path = typer.Argument(Path("."), help="Project directory to inspect."),
+) -> None:
+    """Check the local environment and provider readiness."""
+    banner()
+    section("DeployForge Doctor")
+    checks: list[tuple[str, bool, str]] = []
+
+    def _bin(name: str) -> bool:
+        try:
+            subprocess.run([name, "--version"], capture_output=True, timeout=10, check=False)
+            return True
+        except (OSError, subprocess.SubprocessError):
+            return False
+
+    checks.append(("Git installed", _bin("git"), ""))
+    checks.append(("Node.js installed", _bin("node"), ""))
+    checks.append(("Python installed", _bin("python3"), ""))
+
+    analysis = analyze_project(path, _project_config(path))
+    checks.append(("GitHub repository detected", analysis.repo.exists, analysis.repo.url or ""))
+    if analysis.repo.slug():
+        try:
+            exists = repo_exists(analysis.repo, github_token())
+            checks.append(("GitHub repository verified", exists, ""))
+        except DeployForgeError:
+            checks.append(("GitHub repository verified", False, "API unreachable"))
+
+    secrets = KeyringSecrets()
+    vercel_token = resolve_vercel_token(secrets)
+    render_key = resolve_render_api_key(secrets)
+    checks.append(("Vercel authentication available", bool(vercel_token), ""))
+    checks.append(("Render authentication available", bool(render_key), ""))
+
+    try:
+        import requests
+
+        requests.get("https://api.github.com", timeout=10)
+        checks.append(("Network", True, ""))
+    except Exception:
+        checks.append(("Network", False, ""))
+
+    if analysis.frontend:
+        checks.append(("Frontend detected", True, f"{analysis.frontend.framework}"))
+    else:
+        checks.append(("Frontend detected", False, ""))
+    if analysis.backend:
+        checks.append(("Backend detected", True, f"{analysis.backend.framework}"))
+    else:
+        checks.append(("Backend detected", False, ""))
+
+    checks.append(("DeployForge configuration present", _project_config(path).name is not None, ""))
+
+    all_ok = all(ok_ for _, ok_, _ in checks)
+    for label, result, detail in checks:
+        if result:
+            ok(f"{label}{(' — ' + detail) if detail else ''}")
+        else:
+            fail(f"{label}{(' — ' + detail) if detail else ''}")
+    section("Result")
+    if all_ok:
+        step("Environment ready.")
+    else:
+        warn("Environment needs attention before deploying.")
+
+
+# ---------------------------------------------------------------------------
+# deployforge config
+# ---------------------------------------------------------------------------
+
+
+@app.command("config")
+def config_cmd(
+    path: Path = typer.Argument(Path("."), help="Project directory."),
+    show: bool = typer.Option(True, "--show", help="Show the current project configuration."),
+    name: str | None = typer.Option(None, "--name", help="Project name."),
+    github_repository: str | None = typer.Option(
+        None, "--github-repository", help="owner/repo on GitHub."
+    ),
+    branch: str | None = typer.Option(None, "--branch", help="Default branch."),
+    frontend_directory: str | None = typer.Option(
+        None, "--frontend-directory", help="Frontend directory (relative)."
+    ),
+    backend_directory: str | None = typer.Option(
+        None, "--backend-directory", help="Backend directory (relative)."
+    ),
+    auto_connect: bool | None = typer.Option(
+        None, "--auto-connect/--no-auto-connect", help="Automatically connect frontend ↔ backend."
+    ),
+    security_enabled: bool | None = typer.Option(
+        None, "--security-enabled/--no-security", help="Enable or disable the security preflight."
+    ),
+    block_on_secrets: bool | None = typer.Option(
+        None, "--block-on-secrets/--no-block", help="Block deployment on secret detection."
+    ),
+    vercel_token: str | None = typer.Option(
+        None, "--vercel-token", help="Store the Vercel API token (OS keyring)."
+    ),
+    render_api_key: str | None = typer.Option(
+        None, "--render-api-key", help="Store the Render API key (OS keyring)."
+    ),
+) -> None:
+    """View or update DeployForge configuration."""
+    manager = ProjectConfigManager(path)
+    updates: dict = {}
+    if name:
+        updates["name"] = name
+    if github_repository:
+        updates["github_repository"] = github_repository
+    if branch:
+        updates["branch"] = branch
+    if frontend_directory:
+        updates["frontend_directory"] = frontend_directory
+    if backend_directory:
+        updates["backend_directory"] = backend_directory
+    if auto_connect is not None:
+        updates["auto_connect"] = auto_connect
+    if security_enabled is not None:
+        updates["security_enabled"] = security_enabled
+    if block_on_secrets is not None:
+        updates["block_on_secrets"] = block_on_secrets
+    if updates:
+        manager.update(**updates)
+        ok("Project configuration updated.")
+
+    secrets = KeyringSecrets()
+    if vercel_token:
+        if secrets.set_vercel_token(vercel_token):
+            ok("Vercel token stored securely in the OS keyring.")
+        else:
+            warn("No keyring available; export VERCEL_TOKEN instead.")
+    if render_api_key:
+        if secrets.set_render_api_key(render_api_key):
+            ok("Render API key stored securely in the OS keyring.")
+        else:
+            warn("No keyring available; export RENDER_API_KEY instead.")
+
+    if show or not updates:
+        from deployforge.ui import console
+
+        table = Table(title="DeployForge Configuration", header_style="bold blue")
+        table.add_column("Key")
+        table.add_column("Value")
+        current = manager.load()
+        for key, value in sorted(current.public().items()):
+            table.add_row(key, "—" if value is None else str(value))
+        console.print(table)
+        note(f"Project config: {manager.path}")
+        note(f"User config dir: {default_config_path()}")
+        note("Credentials live in the OS keyring, never in the config file.")
+
+
+# ---------------------------------------------------------------------------
+# deployforge logs
+# ---------------------------------------------------------------------------
+
+
+def _last_log_entry() -> dict | None:
+    log_path = default_data_dir() / "deployments.jsonl"
+    if not log_path.exists():
+        return None
+    try:
+        lines = log_path.read_text(encoding="utf-8").splitlines()
+        return json.loads(lines[-1]) if lines else None
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+@app.command("logs")
+def logs_cmd(
+    limit: int = typer.Option(10, "--limit", help="Number of local log entries to show."),
+) -> None:
+    """Show recent deployment records and provider status where available."""
+    banner()
+    log_path = default_data_dir() / "deployments.jsonl"
+    section("Deployment log")
+    if not log_path.exists():
+        info("No deployments recorded yet.")
+        return
+    try:
+        lines = log_path.read_text(encoding="utf-8").splitlines()
+    except OSError:
+        fail("Could not read the deployment log.")
+        return
+    selected = lines[-limit:]
+    last = json.loads(selected[-1]) if selected else None
+    for line in selected:
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        when = entry.get("time", 0)
+        note(
+            f"[{when}] frontend={entry.get('frontend_url') or '—'} "
+            f"backend={entry.get('backend_url') or '—'}"
+        )
+
+    if last and (last.get("frontend_id") or last.get("backend_id")):
+        section("Provider status")
+        secrets = KeyringSecrets()
+        providers = build_providers(resolve_vercel_token(secrets), resolve_render_api_key(secrets))
+        for kind in ("frontend", "backend"):
+            sid = last.get(f"{kind}_id")
+            provider_name = last.get(f"{kind}_provider")
+            if not sid or provider_name not in providers:
+                continue
+            provider = providers[provider_name]
+            try:
+                result = DeploymentResult(
+                    provider=provider_name,
+                    project_name=str(last.get(f"{kind}_name") or ""),
+                    service_id=sid,
+                )
+                status = provider.get_status(result)
+                ok(f"{kind.title()} ({provider_name}): {status.state}")
+                if status.url:
+                    link(status.url)
+                for log_line in provider.get_logs(result)[:5]:
+                    note(f"  {log_line}")
+            except (ProviderError, AuthenticationError) as exc:
+                warn(f"{kind.title()} status unavailable: {exc}")
+
+
+# ---------------------------------------------------------------------------
+# deployforge version
+# ---------------------------------------------------------------------------
+
+
+@app.command("version")
+def version_cmd() -> None:
+    """Show the DeployForge version."""
+    banner()
+    print(f"deployforge {__version__}")
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def entry() -> None:
+    try:
+        app()
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    entry()