dap-cli 0.3.0__py3-none-any.whl

dap_cli/dashboard.py

@@ -0,0 +1,99 @@
+"""Locate and launch the bundled dashboard (#302 sub-D2, #334).
+
+The wheel ships the Next.js standalone bundle at
+``dap_cli/_dashboard/`` when built via the release pipeline (or after
+running ``scripts/build-dashboard-bundle.sh`` locally). Dev wheels
+built without the bundler ship an effectively-empty directory — this
+module's ``find_bundle`` returns ``None`` in that case so ``dap
+start`` can fall back to a friendly message instead of crashing.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from importlib.resources import files
+from pathlib import Path
+
+
+def find_bundle() -> Path | None:
+    """Return the absolute path of the dashboard bundle's ``server.js``,
+    or ``None`` when no real bundle is present.
+
+    The wheel always ships the ``_dashboard/`` directory (a
+    ``.gitkeep`` placeholder keeps it on disk) but only release /
+    Docker / locally-bundled builds carry ``server.js``. Probing for
+    ``server.js`` instead of the directory itself is the right
+    presence check.
+    """
+    try:
+        # ``importlib.resources.files`` resolves to the install location
+        # of the ``dap_cli`` package — works whether installed via wheel,
+        # pip install -e, or run from the source tree.
+        bundle_dir = Path(str(files("dap_cli") / "_dashboard"))
+    except (ModuleNotFoundError, FileNotFoundError):
+        return None
+    server_js = bundle_dir / "server.js"
+    return server_js if server_js.is_file() else None
+
+
+def find_node() -> str | None:
+    """Return the path to the ``node`` binary, or ``None`` when Node isn't
+    installed.
+
+    The bundle runs on Node 20+ (matches the version the dashboard
+    was built with — see the Dockerfile). We don't verify the
+    version here because Next standalone is usually forgiving across
+    Node majors; the operator gets a clear runtime error from Node
+    itself on real incompatibility.
+    """
+    return shutil.which("node")
+
+
+def spawn_dashboard(
+    *,
+    port: int,
+    engine_url: str,
+) -> subprocess.Popen[bytes] | None:
+    """Spawn ``node <bundle>/server.js`` in the background.
+
+    Returns the ``Popen`` handle on success, or ``None`` when either
+    the bundle or Node is missing — caller surfaces an appropriate
+    message and continues without the dashboard. Stdout/stderr are
+    inherited from the parent process so the operator sees engine
+    and dashboard logs interleaved without ``dap`` having to pump
+    bytes between pipes.
+    """
+    bundle = find_bundle()
+    if bundle is None:
+        return None
+    node = find_node()
+    if node is None:
+        return None
+
+    env = {
+        **os.environ,
+        "PORT": str(port),
+        "HOSTNAME": "127.0.0.1",
+        "DAP_ENGINE_URL": engine_url,
+        # Same flag the Dockerfile sets — keeps Next quiet on first run.
+        "NEXT_TELEMETRY_DISABLED": "1",
+    }
+
+    # ``Popen`` instead of ``run`` — we want the dashboard alive in
+    # the background while the engine runs in the foreground via
+    # uvicorn. The parent's ``finally`` block in ``dap start``
+    # terminates this process explicitly on shutdown.
+    return subprocess.Popen(
+        [node, str(bundle)],
+        env=env,
+        stdout=sys.stdout,
+        stderr=sys.stderr,
+        # New session so a SIGINT to the engine doesn't get duplicated
+        # to the dashboard before our own handler decides what to do.
+        # Best-effort: ``start_new_session`` is POSIX-only; on Windows
+        # the equivalent isn't available and Popen falls back gracefully.
+        start_new_session=True,
+    )

dap_cli/paths.py

@@ -0,0 +1,27 @@
+"""Standardowe ścieżki projektu DAP."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+LOCAL_DAP_DIR_NAME = ".dap"
+USER_DAP_DIR = Path.home() / ".dap"
+
+DEFAULT_ENGINE_PORT = 7333
+DEFAULT_DASHBOARD_PORT = 7332
+
+
+def local_dap_dir(cwd: Path | None = None) -> Path:
+    return (cwd or Path.cwd()) / LOCAL_DAP_DIR_NAME
+
+
+def local_config_path(cwd: Path | None = None) -> Path:
+    return local_dap_dir(cwd) / "config.json"
+
+
+def local_db_path(cwd: Path | None = None) -> Path:
+    return local_dap_dir(cwd) / "state.db"
+
+
+def local_pid_path(cwd: Path | None = None) -> Path:
+    return local_dap_dir(cwd) / "dap.pid"

dap_cli/process.py

@@ -0,0 +1,130 @@
+"""PID file management + signal handling dla `dap start` / `stop` / `status`."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import signal
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TypedDict
+
+import psutil
+
+from dap_cli.paths import local_pid_path
+
+GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS = 5
+PID_KILL_POLL_INTERVAL_SECONDS = 0.1
+SECONDS_PER_MINUTE = 60
+SECONDS_PER_HOUR = 3600
+
+
+class PidFile(TypedDict):
+    pid: int
+    port: int
+    started_at: str  # ISO 8601 with timezone
+
+
+def write_pid_file(pid: int, port: int, path: Path | None = None) -> Path:
+    pid_path = path or local_pid_path()
+    payload: PidFile = {
+        "pid": pid,
+        "port": port,
+        "started_at": datetime.now(UTC).isoformat(),
+    }
+    pid_path.parent.mkdir(parents=True, exist_ok=True)
+    pid_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    return pid_path
+
+
+def read_pid_file(path: Path | None = None) -> PidFile | None:
+    pid_path = path or local_pid_path()
+    if not pid_path.exists():
+        return None
+    try:
+        data = json.loads(pid_path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    if not all(k in data for k in ("pid", "port", "started_at")):
+        return None
+    return PidFile(
+        pid=int(data["pid"]),
+        port=int(data["port"]),
+        started_at=str(data["started_at"]),
+    )
+
+
+def remove_pid_file(path: Path | None = None) -> None:
+    pid_path = path or local_pid_path()
+    pid_path.unlink(missing_ok=True)
+
+
+def is_process_alive(pid: int) -> bool:
+    """Check if process exists AND looks like ours (Python interpreter)."""
+    if not psutil.pid_exists(pid):
+        return False
+    try:
+        process = psutil.Process(pid)
+        return bool(process.is_running()) and process.status() != psutil.STATUS_ZOMBIE
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return False
+
+
+def stop_process(pid: int, *, timeout: float = GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS) -> bool:
+    """Send SIGTERM, wait for graceful exit, fall back to SIGKILL.
+
+    Returns True if process was alive and got terminated, False if already dead.
+    """
+    if not is_process_alive(pid):
+        return False
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        return False
+
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if not is_process_alive(pid):
+            return True
+        time.sleep(PID_KILL_POLL_INTERVAL_SECONDS)
+
+    with contextlib.suppress(ProcessLookupError):
+        os.kill(pid, signal.SIGKILL)
+
+    return True
+
+
+def install_pid_cleanup_handlers(path: Path | None = None) -> None:
+    """Register SIGINT/SIGTERM handlers that remove PID file before exit."""
+    pid_path = path or local_pid_path()
+
+    def _handler(signum: int, _frame: object) -> None:
+        remove_pid_file(pid_path)
+        # Re-raise default handling so uvicorn / asyncio can shutdown cleanly.
+        signal.signal(signum, signal.SIG_DFL)
+        os.kill(os.getpid(), signum)
+
+    signal.signal(signal.SIGINT, _handler)
+    signal.signal(signal.SIGTERM, _handler)
+
+
+def uptime_from_started_at(started_at_iso: str) -> str:
+    """Format uptime as human-readable from ISO timestamp."""
+    try:
+        started = datetime.fromisoformat(started_at_iso)
+    except ValueError:
+        return "?"
+    delta = datetime.now(UTC) - started
+    seconds = int(delta.total_seconds())
+    if seconds < SECONDS_PER_MINUTE:
+        return f"{seconds}s"
+    if seconds < SECONDS_PER_HOUR:
+        return f"{seconds // SECONDS_PER_MINUTE}m {seconds % SECONDS_PER_MINUTE}s"
+    hours = seconds // SECONDS_PER_HOUR
+    minutes = (seconds % SECONDS_PER_HOUR) // SECONDS_PER_MINUTE
+    return f"{hours}h {minutes}m"

dap_cli-0.3.0.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: dap-cli
+Version: 0.3.0
+Summary: DAP CLI launcher (dap init / start / stop / status)
+Requires-Python: >=3.13
+Requires-Dist: dap-engine
+Requires-Dist: httpx>=0.27.2
+Requires-Dist: psutil>=6.1.0
+Requires-Dist: rich>=13.9.2
+Requires-Dist: typer>=0.12.5
+Requires-Dist: uvicorn[standard]>=0.32.0
+Description-Content-Type: text/markdown
+
+# dap-cli
+
+Typer-based CLI launcher dla DAP. Spawn engine + dashboard, podobnie jak `npx paperclip`.
+
+## Komendy (F0)
+
+| Komenda          | Status      | Opis                                                       |
+| ---------------- | ----------- | ---------------------------------------------------------- |
+| `dap --version`  | ✅          | Wersja                                                     |
+| `dap --help`     | ✅          | Lista komend                                               |
+| `dap init`       | ✅          | Tworzy `./.dap/` z config.json i podkatalogami             |
+| `dap start`      | ✅ partial  | Spawn engine na 127.0.0.1:7333 (dashboard: F6)             |
+| `dap stop`       | 🚧 stub     | F1 (PID management)                                        |
+| `dap status`     | ✅ partial  | Pokazuje czy projekt zainicjowany                          |
+
+## Lokalne uruchomienie z monorepo
+
+```bash
+uv sync
+uv run dap --version
+uv run dap init
+uv run dap start
+```
+
+## Po opublikowaniu (F12)
+
+```bash
+uv tool install dap-cli
+dap init && dap start
+```

dap_cli-0.3.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+dap_cli/__init__.py,sha256=VrXpHDu3erkzwl_WXrqINBm9xWkcyUy53IQOj042dOs,22
+dap_cli/__main__.py,sha256=vrapAdppoP-ZYWPh7x7dMvUDk19sS5Oof0sA6CFKD24,2691
+dap_cli/bootstrap.py,sha256=ZOI96412dqA48XIIo1TGTtSKfB2Cur8lk-Vp40O2p04,9883
+dap_cli/dashboard.py,sha256=1E-fCMWs2S619jQgVMQuXJLUZ9H9wCEia-FB9NucGL0,3592
+dap_cli/paths.py,sha256=1ntufmiUMAziTFnlgtTKVe1QcXdORpkBExWXqdGoP0E,631
+dap_cli/process.py,sha256=pONKqgy3JYCa4926a29W5YJy-cdPCMdXvyx8DxrsGuQ,3900
+dap_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dap_cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dap_cli/commands/cortex.py,sha256=T-zHfFfL9DTnb2WhCtYoKMBqC56K--fPlKL_zKvzi30,25562
+dap_cli/commands/init.py,sha256=nJdrsAjEE1kjqwLofIe7vv3K0z3cdh8-poFGWJy_tbs,7009
+dap_cli/commands/project.py,sha256=QrcEsYloPXVhzmOMXHue66ar7vhs9r9OEK6uocQ9TCA,4259
+dap_cli/commands/start.py,sha256=cis0huwJ3NjsW91MBohP7clkBuzH7tFOXa6lVou8xK8,4042
+dap_cli/commands/status.py,sha256=ejs9rfSkk5d1ffbqrPF3FgqJsHHAJErnch1hjagNzfY,4452
+dap_cli/commands/stop.py,sha256=jakjwndZMZUJFtXhgPzDYx8zjZkJ75zhD8c9vnZ-UvA,1034
+dap_cli/_dashboard/.gitkeep,sha256=igL1q83-AUb-mnv1Mk6prMvmC2rWUjgQM-_zpThBgDY,277
+dap_cli/_dashboard/BUNDLE_INFO.txt,sha256=z1QSexjV5D3ha4ym8_9LFSpZn3mgjkRnevsRZmciAAU,70
+dap_cli/_dashboard/package.json,sha256=rI4xjBFwOcqwXAZ6wcpKH9O1IB1U95vDrVxxJo6woKU,1489
+dap_cli/_dashboard/server.js,sha256=vRc2-nBhHzD1fE-P14EJ7uU1xDhpbWMuHC9tAPh4Enw,5845
+dap_cli-0.3.0.dist-info/METADATA,sha256=HQhzl9o0889PvZxaChrXjpbouON4Bx7Iltf0mhJRFXw,1450
+dap_cli-0.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+dap_cli-0.3.0.dist-info/entry_points.txt,sha256=Jpf_ycfImek6vc3u-wUWXNDy-rx2HdAToKtNSQ2j0rY,45
+dap_cli-0.3.0.dist-info/RECORD,,

dap_cli-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dap_cli-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dap = dap_cli.__main__:app