dap-cli 0.3.0__py3-none-any.whl

dap_cli/commands/init.py

@@ -0,0 +1,183 @@
+"""dap init — bootstrap ./.dap/ + admin user (#302 sub-D4)."""
+
+from __future__ import annotations
+
+import getpass
+import json
+import os
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+from dap_cli.bootstrap import (
+    bootstrap_marker_path,
+    ensure_admin_user,
+    validate_email,
+    validate_password,
+    write_bootstrap_marker,
+)
+from dap_cli.paths import (
+    DEFAULT_DASHBOARD_PORT,
+    DEFAULT_ENGINE_PORT,
+    local_config_path,
+    local_dap_dir,
+    local_db_path,
+)
+
+console = Console()
+
+
+def init_command(
+    force: bool = False,
+    admin_email: str | None = None,
+    admin_password: str | None = None,
+    admin_password_stdin: bool = False,
+) -> None:
+    """Initialise ``.dap/`` and create / promote the bootstrap admin.
+
+    Three input modes for the admin credentials, in order of
+    precedence:
+
+    1. ``--admin-email`` + ``--admin-password-stdin`` (read password
+       from stdin) — automation-friendly, mirrors ``kubectl``.
+    2. ``--admin-email`` + ``--admin-password=...`` — quick, suitable
+       for local dev only (the password lands in shell history).
+    3. Interactive prompt — if neither flag is set, prompt for both.
+       Empty password → generate a random one and print once.
+
+    Re-running is idempotent: an existing user with the supplied
+    email gets promoted to admin without changing their password.
+    """
+    dap_dir = local_dap_dir()
+    config_path = local_config_path()
+
+    if dap_dir.exists() and not force:
+        console.print(f"[yellow]⚠ .dap/ already exists at {dap_dir}[/yellow]")
+        console.print("[dim]  Use --force to reinitialize.[/dim]")
+        return
+
+    (dap_dir / "pipelines").mkdir(parents=True, exist_ok=True)
+    (dap_dir / "agents").mkdir(parents=True, exist_ok=True)
+    (dap_dir / "runs").mkdir(parents=True, exist_ok=True)
+
+    default_config = {
+        "version": 1,
+        "engine": {"host": "127.0.0.1", "port": DEFAULT_ENGINE_PORT},
+        "dashboard": {"port": DEFAULT_DASHBOARD_PORT},
+        "runtimes": {"paths": {}},
+    }
+    config_path.write_text(json.dumps(default_config, indent=2) + "\n", encoding="utf-8")
+
+    # Bootstrap the admin user. Errors here are user-visible — we
+    # leave the ``.dap/`` skeleton on disk (better than rolling back
+    # to "no project at all" and forcing a re-init) but report the
+    # admin step as failed so the operator can fix and retry.
+    try:
+        email, password = _collect_credentials(
+            admin_email=admin_email,
+            admin_password=admin_password,
+            admin_password_stdin=admin_password_stdin,
+        )
+    except (ValueError, EOFError, KeyboardInterrupt) as exc:
+        console.print(f"[red]✗ Admin bootstrap aborted: {exc}[/red]")
+        console.print("[dim]  Re-run `dap init --force` to retry.[/dim]")
+        raise SystemExit(2) from exc
+
+    # ``DAP_DB_PATH`` (set by the standalone compose to ``/data/state.db``)
+    # wins over the in-CWD default so ``dap init`` inside the container
+    # writes to the same SQLite the engine reads from. Otherwise the
+    # bootstrap row lands in an unrelated ``./.dap/state.db`` file and
+    # the operator can't actually log in.
+    env_db_path = os.environ.get("DAP_DB_PATH", "").strip()
+    db_path = Path(env_db_path) if env_db_path else local_db_path()
+    result = ensure_admin_user(
+        db_path,
+        email=email,
+        password=password,
+    )
+    write_bootstrap_marker(bootstrap_marker_path(dap_dir), result)
+
+    console.print("[green]✓ Initialized DAP project[/green]")
+    console.print(f"[dim]  {dap_dir}/[/dim]")
+    console.print("[dim]  ├─ config.json[/dim]")
+    console.print("[dim]  ├─ bootstrap.json[/dim]  [dim](admin metadata)[/dim]")
+    console.print("[dim]  ├─ pipelines/[/dim]")
+    console.print("[dim]  ├─ agents/[/dim]")
+    console.print("[dim]  └─ runs/[/dim]")
+    console.print()
+    if result.promoted_existing:
+        console.print(
+            f"[green]✓ Admin: {result.email}[/green] [dim](existing user — promoted)[/dim]"
+        )
+    else:
+        console.print(f"[green]✓ Admin: {result.email}[/green]")
+    if result.generated_password is not None:
+        # Print exactly once. We don't store it anywhere — the
+        # operator must capture it now or run a reset later.
+        console.print()
+        console.print("[yellow]⚠ Generated random password — copy it now:[/yellow]")
+        console.print(f"  [bold]{result.generated_password}[/bold]")
+        console.print(
+            "[dim]  This is the only time it will be shown. "
+            "Re-run `dap init --force --admin-email=... --admin-password=...`[/dim]"
+        )
+        console.print("[dim]  to set your own.[/dim]")
+    console.print()
+    console.print("[cyan]Next: dap start[/cyan]")
+
+
+def _collect_credentials(
+    *,
+    admin_email: str | None,
+    admin_password: str | None,
+    admin_password_stdin: bool,
+) -> tuple[str, str | None]:
+    """Resolve the email + password from flags or interactive prompts.
+
+    Returns ``(email, password)`` where ``password`` may be ``None``
+    when neither a flag nor an interactive entry produced one — in
+    that case the bootstrap helper generates a random value.
+    """
+    # Email — flag wins; otherwise prompt. We never accept email
+    # via stdin because mixing stdin email + stdin password would
+    # be ambiguous, and emails are short enough to type live.
+    if admin_email is None:
+        if not sys.stdin.isatty():
+            raise ValueError(
+                "No --admin-email and stdin is not a TTY — can't prompt. "
+                "Pass --admin-email=... explicitly for non-interactive runs."
+            )
+        admin_email = input("Admin email: ").strip()
+    email = validate_email(admin_email)
+
+    # Password — three paths.
+    if admin_password_stdin:
+        # Read the WHOLE stdin (operator pipes via ``echo ... | dap init``).
+        # Strip trailing newline only — other whitespace is part of the
+        # password, the operator picks the format.
+        password: str | None = sys.stdin.read().rstrip("\n")
+        if not password:
+            raise ValueError("--admin-password-stdin set but stdin was empty")
+        validate_password(password)
+        return email, password
+
+    if admin_password is not None:
+        validate_password(admin_password)
+        return email, admin_password
+
+    if not sys.stdin.isatty():
+        # Non-interactive with no password provided → generate one.
+        # The bootstrap helper handles the generation; we just signal
+        # by returning ``None``.
+        return email, None
+
+    # Interactive prompt with getpass (no echo).
+    typed = getpass.getpass("Admin password (leave empty to auto-generate a random one): ")
+    if typed == "":
+        return email, None
+    validate_password(typed)
+    confirm = getpass.getpass("Re-enter password: ")
+    if confirm != typed:
+        raise ValueError("passwords did not match")
+    return email, typed

dap_cli/commands/project.py

@@ -0,0 +1,134 @@
+"""dap project — sub-commands for project-scoped pipeline operations.
+
+Current pipeline types: cortex
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from dap_cli.commands import cortex as _cortex
+from dap_cli.paths import DEFAULT_ENGINE_PORT
+
+project_app = typer.Typer(
+    name="project",
+    help="Project-scoped pipeline operations",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+_ENGINE_DEFAULT = f"http://localhost:{DEFAULT_ENGINE_PORT}"
+
+
+@project_app.command("run")
+def cmd_run(
+    pipeline: Annotated[str, typer.Argument(help="Pipeline type (currently: cortex)")],
+    issue_url: Annotated[str, typer.Argument(help="GitHub issue URL to process")],
+    engine: Annotated[
+        str,
+        typer.Option("--engine", help="DAP engine base URL", envvar="DAP_ENGINE_URL"),
+    ] = _ENGINE_DEFAULT,
+    no_interactive: Annotated[
+        bool,
+        typer.Option("--no-interactive", help="Approve all gates automatically"),
+    ] = False,
+    watch: Annotated[
+        bool,
+        typer.Option("--watch", help="Monitor only — do not approve gates"),
+    ] = False,
+    workspace: Annotated[
+        str | None,
+        typer.Option("--workspace", help="Local workspace path for the pipeline"),
+    ] = None,
+) -> None:
+    """Trigger a pipeline run for a GitHub issue.
+
+    Example:
+
+        dap project run cortex https://github.com/Dixter999/cortex-project/issues/332
+    """
+    if pipeline != "cortex":
+        typer.echo(f"Unknown pipeline type: {pipeline!r}. Supported: cortex", err=True)
+        raise typer.Exit(1)
+    _cortex.cortex_run(
+        issue_url=issue_url,
+        engine_url=engine,
+        no_interactive=no_interactive,
+        watch=watch,
+        workspace=workspace,
+    )
+
+
+@project_app.command("approve")
+def cmd_approve(
+    pipeline: Annotated[str, typer.Argument(help="Pipeline type (currently: cortex)")],
+    run_id: Annotated[str, typer.Argument(help="Run ID to approve")],
+    engine: Annotated[
+        str,
+        typer.Option("--engine", help="DAP engine base URL", envvar="DAP_ENGINE_URL"),
+    ] = _ENGINE_DEFAULT,
+) -> None:
+    """Approve the current gate for a paused run.
+
+    Example:
+
+        dap project approve cortex <run-id>
+    """
+    if pipeline != "cortex":
+        typer.echo(f"Unknown pipeline type: {pipeline!r}. Supported: cortex", err=True)
+        raise typer.Exit(1)
+    _cortex.cortex_approve(run_id=run_id, engine_url=engine)
+
+
+@project_app.command("reject")
+def cmd_reject(
+    pipeline: Annotated[str, typer.Argument(help="Pipeline type (currently: cortex)")],
+    run_id: Annotated[str, typer.Argument(help="Run ID to reject")],
+    reason: Annotated[str, typer.Argument(help="Rejection reason")] = "",
+    engine: Annotated[
+        str,
+        typer.Option("--engine", help="DAP engine base URL", envvar="DAP_ENGINE_URL"),
+    ] = _ENGINE_DEFAULT,
+) -> None:
+    """Reject (abort) the current gate for a paused run.
+
+    Example:
+
+        dap project reject cortex <run-id> "Phase 1 spec incomplete"
+    """
+    if pipeline != "cortex":
+        typer.echo(f"Unknown pipeline type: {pipeline!r}. Supported: cortex", err=True)
+        raise typer.Exit(1)
+    _cortex.cortex_reject(run_id=run_id, reason=reason, engine_url=engine)
+
+
+@project_app.command("state")
+def cmd_state(
+    pipeline: Annotated[str, typer.Argument(help="Pipeline type (currently: cortex)")],
+    run_id: Annotated[str, typer.Argument(help="Run ID to inspect")],
+    engine: Annotated[
+        str,
+        typer.Option("--engine", help="DAP engine base URL", envvar="DAP_ENGINE_URL"),
+    ] = _ENGINE_DEFAULT,
+    fmt: Annotated[
+        str,
+        typer.Option(
+            "--format",
+            help="Output format: table (default) or json",
+            click_type=__import__("click").Choice(["table", "json"], case_sensitive=False),
+        ),
+    ] = "table",
+) -> None:
+    """Show current state of a pipeline run.
+
+    Example:
+
+        dap project state cortex <run-id>
+        dap project state cortex <run-id> --format json
+    """
+    if pipeline != "cortex":
+        typer.echo(f"Unknown pipeline type: {pipeline!r}. Supported: cortex", err=True)
+        raise typer.Exit(1)
+    _cortex.cortex_state(run_id=run_id, engine_url=engine, fmt=fmt)

dap_cli/commands/start.py

@@ -0,0 +1,124 @@
+"""dap start — odpala FastAPI engine in-process + bundled dashboard."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+import uvicorn
+from rich.console import Console
+
+from dap_cli.dashboard import find_bundle, find_node, spawn_dashboard
+from dap_cli.paths import (
+    DEFAULT_DASHBOARD_PORT,
+    DEFAULT_ENGINE_PORT,
+    local_dap_dir,
+    local_db_path,
+)
+from dap_cli.process import (
+    install_pid_cleanup_handlers,
+    is_process_alive,
+    read_pid_file,
+    remove_pid_file,
+    write_pid_file,
+)
+
+console = Console()
+
+
+def start_command(
+    port: int = DEFAULT_DASHBOARD_PORT,
+    engine_port: int = DEFAULT_ENGINE_PORT,
+    headless: bool = False,
+) -> None:
+    if not local_dap_dir().exists():
+        console.print("[red]✗ No .dap/ found in current directory.[/red]")
+        console.print("[dim]  Run `dap init` first.[/dim]")
+        raise SystemExit(1)
+
+    existing = read_pid_file()
+    if existing is not None:
+        if is_process_alive(existing["pid"]):
+            console.print(
+                f"[red]✗ DAP already running (PID {existing['pid']}, "
+                f"port {existing['port']}).[/red]",
+            )
+            console.print("[dim]  Use `dap stop` first if you want to restart.[/dim]")
+            raise SystemExit(1)
+        console.print(
+            f"[yellow]⚠ Stale PID file "
+            f"(process {existing['pid']} not running) — cleaning up.[/yellow]",
+        )
+        remove_pid_file()
+
+    # Lazy import — dap --version / --help nie ładują FastAPI/SQLAlchemy
+    from dap_engine.app import EngineConfig, create_app  # noqa: PLC0415
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)-7s %(name)s | %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    config = EngineConfig(
+        db_path=str(local_db_path()),
+        host="127.0.0.1",
+        port=engine_port,
+    )
+    app = create_app(config)
+
+    write_pid_file(pid=os.getpid(), port=engine_port)
+    install_pid_cleanup_handlers()
+
+    console.print("[cyan]Starting DAP...[/cyan]")
+    console.print(f"[green]✓ engine[/green]  http://127.0.0.1:{engine_port}")
+
+    # Try to spawn the bundled dashboard. ``spawn_dashboard`` returns
+    # None when either the bundle (``_dashboard/server.js``) or
+    # ``node`` is missing — both are expected in dev installs that
+    # haven't run ``scripts/build-dashboard-bundle.sh``.
+    dashboard_proc = spawn_dashboard(
+        port=port,
+        engine_url=f"http://127.0.0.1:{engine_port}",
+    )
+    if dashboard_proc is not None:
+        console.print(f"[green]✓ dashboard[/green]  http://127.0.0.1:{port}")
+    else:
+        # Distinguish the two no-dashboard cases so the operator
+        # knows which knob to turn.
+        if find_bundle() is None:
+            reason = (
+                "no bundle in this wheel — run "
+                "[bold]scripts/build-dashboard-bundle.sh[/bold] from a checkout"
+            )
+        elif find_node() is None:
+            reason = "Node.js not on PATH — install Node 20+ to enable"
+        else:
+            reason = "unknown (check logs)"
+        console.print(
+            f"[yellow]○ dashboard[/yellow]  not started [dim]({reason})[/dim]",
+        )
+
+    if not headless and dashboard_proc is not None:
+        console.print(f"[dim]  Open http://127.0.0.1:{port} in your browser.[/dim]")
+    console.print()
+    console.print("[dim]Press Ctrl+C to stop.[/dim]")
+
+    try:
+        uvicorn.run(
+            app,
+            host=config.host,
+            port=config.port,
+            log_level="info",
+            access_log=False,
+        )
+    finally:
+        # Stop the dashboard before clearing our PID file so the
+        # operator never sees the dashboard outlive ``dap stop``.
+        if dashboard_proc is not None and dashboard_proc.poll() is None:
+            dashboard_proc.terminate()
+            try:
+                dashboard_proc.wait(timeout=5)
+            except Exception:
+                dashboard_proc.kill()
+        remove_pid_file()

dap_cli/commands/status.py

@@ -0,0 +1,136 @@
+"""dap status — pokazuje stan projektu DAP, runtime info gdy działa."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import httpx
+from rich.console import Console
+from rich.table import Table
+
+from dap_cli.bootstrap import bootstrap_marker_path, read_bootstrap_marker
+from dap_cli.paths import local_dap_dir
+from dap_cli.process import (
+    is_process_alive,
+    read_pid_file,
+    remove_pid_file,
+    uptime_from_started_at,
+)
+
+console = Console()
+
+HTTP_REQUEST_TIMEOUT_SECONDS = 2.0
+
+
+def _fetch_runtimes(port: int) -> list[dict[str, Any]] | None:
+    base = f"http://127.0.0.1:{port}"
+    try:
+        with httpx.Client(timeout=HTTP_REQUEST_TIMEOUT_SECONDS) as client:
+            response = client.get(f"{base}/runtimes")
+            response.raise_for_status()
+            data = response.json()
+    except (httpx.HTTPError, ValueError):
+        return None
+    if not isinstance(data, list):
+        return None
+    return data
+
+
+def _fetch_runtime_health(port: int, runtime_id: str) -> dict[str, Any] | None:
+    base = f"http://127.0.0.1:{port}"
+    try:
+        with httpx.Client(timeout=HTTP_REQUEST_TIMEOUT_SECONDS) as client:
+            response = client.get(f"{base}/runtimes/{runtime_id}/health")
+            response.raise_for_status()
+            data = response.json()
+    except (httpx.HTTPError, ValueError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    return data
+
+
+def _print_bootstrap_section(dap_dir: Path) -> None:
+    """Print admin-bootstrap state (one line) above the engine status.
+
+    Reads ``.dap/bootstrap.json`` (written by ``dap init``). Stays
+    silent when it's not present *and* the project is otherwise
+    initialised — we don't want to nag every ``dap status`` call when
+    the operator hasn't bootstrapped yet, so we just show a hint."""
+    marker = read_bootstrap_marker(bootstrap_marker_path(dap_dir))
+    if marker is None:
+        console.print("[yellow]○ admin bootstrap:[/yellow] none — run `dap init` to create one")
+        return
+    email = marker.get("email", "?")
+    created = marker.get("created_at", "?")
+    console.print(f"[green]✓ admin bootstrap:[/green] {email} [dim]({created})[/dim]")
+
+
+def status_command() -> None:
+    dap_dir = local_dap_dir()
+
+    if not dap_dir.exists():
+        console.print("[red]✗ Not a DAP project[/red]")
+        console.print("[dim]  Run `dap init` to initialize.[/dim]")
+        return
+
+    _print_bootstrap_section(dap_dir)
+
+    pid_info = read_pid_file()
+
+    if pid_info is None:
+        console.print("[green]✓ DAP project[/green]")
+        console.print(f"[dim]  {dap_dir}[/dim]")
+        console.print()
+        console.print("[yellow]○ engine: stopped[/yellow]")
+        console.print("[dim]  Run `dap start` to launch.[/dim]")
+        return
+
+    pid = pid_info["pid"]
+    port = pid_info["port"]
+    started_at = pid_info["started_at"]
+
+    if not is_process_alive(pid):
+        console.print("[green]✓ DAP project[/green]")
+        console.print(f"[dim]  {dap_dir}[/dim]")
+        console.print()
+        console.print(f"[red]✗ engine: stale PID file (process {pid} not running)[/red]")
+        remove_pid_file()
+        console.print("[dim]  Cleaned up. Run `dap start`.[/dim]")
+        return
+
+    uptime = uptime_from_started_at(started_at)
+    console.print("[green]✓ DAP project[/green]")
+    console.print(f"[dim]  {dap_dir}[/dim]")
+    console.print()
+    console.print(f"[green]● engine: running[/green]  PID {pid}  port {port}  uptime {uptime}")
+
+    runtimes = _fetch_runtimes(port)
+    if runtimes is None:
+        console.print(
+            "[yellow]  ⚠ Engine process running but /runtimes endpoint unreachable.[/yellow]"
+        )
+        return
+
+    table = Table(title="Runtime adapters", show_lines=False, header_style="bold")
+    table.add_column("ID")
+    table.add_column("Display name")
+    table.add_column("Kind")
+    table.add_column("Available")
+
+    for entry in runtimes:
+        rt_id = str(entry.get("id", "?"))
+        health = _fetch_runtime_health(port, rt_id)
+        available = (
+            "[green]✓[/green]" if health is not None and health.get("available") else "[red]✗[/red]"
+        )
+        table.add_row(
+            rt_id,
+            str(entry.get("displayName", "?")),
+            str(entry.get("kind", "?")),
+            available,
+        )
+
+    console.print()
+    console.print(table)

dap_cli/commands/stop.py

@@ -0,0 +1,35 @@
+"""dap stop — wysyła SIGTERM (potem SIGKILL) procesowi z PID file."""
+
+from __future__ import annotations
+
+from rich.console import Console
+
+from dap_cli.process import is_process_alive, read_pid_file, remove_pid_file, stop_process
+
+console = Console()
+
+
+def stop_command() -> None:
+    pid_info = read_pid_file()
+    if pid_info is None:
+        console.print("[yellow]⚠ No PID file found — DAP is not running.[/yellow]")
+        raise SystemExit(1)
+
+    pid = pid_info["pid"]
+    port = pid_info["port"]
+
+    if not is_process_alive(pid):
+        console.print(
+            f"[yellow]⚠ Stale PID file (process {pid} not running) — cleaning up.[/yellow]",
+        )
+        remove_pid_file()
+        raise SystemExit(1)
+
+    console.print(f"[cyan]Stopping DAP (PID {pid}, port {port})...[/cyan]")
+    terminated = stop_process(pid)
+    remove_pid_file()
+
+    if terminated:
+        console.print("[green]✓ Stopped.[/green]")
+    else:
+        console.print("[yellow]⚠ Process already exited before SIGTERM.[/yellow]")