gdmcode 0.1.0__py3-none-any.whl

src/remote/tunnel.py

@@ -0,0 +1,212 @@
+"""TunnelManager — multi-provider tunnel support with crash recovery."""
+
+from __future__ import annotations
+
+import json
+import socket
+import subprocess
+import threading
+import time
+from typing import Callable
+
+
+_DEFAULT_BACKOFF = [5.0, 15.0, 30.0]
+
+_PROVIDERS: list[dict] = [
+    {
+        "name": "cloudflared",
+        "cmd": lambda port: ["cloudflared", "tunnel", "--url", f"http://localhost:{port}"],
+        "url_marker": "trycloudflare.com",
+    },
+    {
+        "name": "ngrok",
+        "cmd": lambda port: ["ngrok", "http", str(port), "--log=stdout", "--log-format=json"],
+        "url_marker": "ngrok",
+    },
+    {
+        "name": "localtunnel",
+        "cmd": lambda port: ["lt", "--port", str(port)],
+        "url_marker": "loca.lt",
+    },
+]
+
+
+def _lan_ip() -> str:
+    """Return best-guess LAN IP without sending actual traffic."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except OSError:
+        return "127.0.0.1"
+
+
+class TunnelError(RuntimeError):
+    """Raised when no tunnel provider is available."""
+
+
+class TunnelManager:
+    """Start/stop/monitor a public tunnel to *port*.
+
+    Provider priority: cloudflared → ngrok → localtunnel → LAN.
+    Crash recovery is implemented by a background monitor thread that
+    restarts the tunnel with exponential back-off on unexpected exit.
+
+    Parameters
+    ----------
+    port:
+        Local port to expose.
+    providers:
+        Override the provider list (for testing).
+    backoff_delays:
+        Seconds to wait between retry attempts (injectable for tests).
+    """
+
+    def __init__(
+        self,
+        port: int = 8765,
+        providers: list[dict] | None = None,
+        backoff_delays: list[float] | None = None,
+    ) -> None:
+        self._port = port
+        self._providers = providers if providers is not None else list(_PROVIDERS)
+        self._backoff_delays: list[float] = (
+            backoff_delays if backoff_delays is not None else _DEFAULT_BACKOFF
+        )
+        self._url: str | None = None
+        self._provider_name: str | None = None
+        self._proc: subprocess.Popen | None = None
+        self._lock = threading.Lock()
+        self._stop_event = threading.Event()
+        self._monitor_thread: threading.Thread | None = None
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def start(self) -> str:
+        """Start the tunnel and return the public URL."""
+        with self._lock:
+            if self._url:
+                return self._url
+            url, name = self._try_start_with_retry()
+            self._url = url
+            self._provider_name = name
+            self._stop_event.clear()
+            self._monitor_thread = threading.Thread(
+                target=self._monitor_loop, daemon=True, name="gdm-tunnel-monitor"
+            )
+            self._monitor_thread.start()
+            return url
+
+    def stop(self) -> None:
+        """Stop the tunnel and the monitor thread."""
+        self._stop_event.set()
+        with self._lock:
+            self._kill_proc()
+            self._url = None
+            self._provider_name = None
+
+    def status(self) -> dict:
+        """Return current tunnel status dict."""
+        with self._lock:
+            return {
+                "running": self._url is not None,
+                "url": self._url,
+                "provider": self._provider_name,
+                "port": self._port,
+            }
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _lan_fallback(self) -> tuple[str, str]:
+        ip = _lan_ip()
+        return f"http://{ip}:{self._port}", "lan"
+
+    def _try_provider(self, provider: dict) -> tuple[str, str] | None:
+        """Try to start *provider*; return (url, name) or None."""
+        try:
+            cmd = provider["cmd"](self._port)
+            proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+            marker = provider["url_marker"]
+            # Read stdout until we see the URL or the process exits
+            for _ in range(60):
+                if proc.poll() is not None:
+                    return None
+                assert proc.stdout is not None
+                line = proc.stdout.readline()
+                if not line:
+                    time.sleep(0.5)
+                    continue
+                if marker in line:
+                    # Extract the URL from the line
+                    for token in line.split():
+                        if marker in token:
+                            url = token.strip().rstrip(",")
+                            if not url.startswith("http"):
+                                url = "https://" + url
+                            self._proc = proc
+                            return url, provider["name"]
+            proc.kill()
+            return None
+        except FileNotFoundError:
+            return None
+        except Exception:
+            return None
+
+    def _try_start_with_retry(self) -> tuple[str, str]:
+        """Try all providers; retry with back-off; fall back to LAN."""
+        delays = list(self._backoff_delays)
+
+        for delay in delays:
+            for provider in self._providers:
+                result = self._try_provider(provider)
+                if result:
+                    return result
+            time.sleep(delay)
+
+        # Final attempt before LAN fallback
+        for provider in self._providers:
+            result = self._try_provider(provider)
+            if result:
+                return result
+
+        return self._lan_fallback()
+
+    def _kill_proc(self) -> None:
+        if self._proc and self._proc.poll() is None:
+            try:
+                self._proc.kill()
+                self._proc.wait(timeout=5)
+            except Exception:
+                pass
+        self._proc = None
+
+    def _monitor_loop(self) -> None:
+        """Watch the subprocess; restart if it dies unexpectedly."""
+        while not self._stop_event.is_set():
+            time.sleep(1)
+            with self._lock:
+                if self._stop_event.is_set():
+                    break
+                if self._proc is None:
+                    continue
+                if self._proc.poll() is not None:
+                    # Process died unexpectedly — restart
+                    self._proc = None
+                    try:
+                        url, name = self._try_start_with_retry()
+                        self._url = url
+                        self._provider_name = name
+                    except Exception:
+                        self._url = None
+                        self._provider_name = None

src/repl.py

@@ -0,0 +1,475 @@
+"""gdm REPL -- interactive coding agent loop.
+
+Uses prompt_toolkit for rich input (history, editing) with a plain
+input() fallback when prompt_toolkit is unavailable.
+"""
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import logging
+import sys
+import uuid
+from datetime import date, datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.status import Status
+
+if TYPE_CHECKING:
+    from src.config import GdmConfig
+    from src.memory.db import GdmDatabase
+
+__all__ = ["start_repl"]
+
+log = logging.getLogger(__name__)
+
+_HISTORY_FILENAME = ".context-memory/gdm_history"
+_PROMPT_HTML = "<ansiCyan>gdm</ansiCyan><ansiwhite> > </ansiwhite>"
+
+
+# ---------------------------------------------------------------------------
+# Session bootstrap
+# ---------------------------------------------------------------------------
+
+def _ensure_session(db: "GdmDatabase", project_root: Path) -> str:
+    """Upsert project + session rows so FK constraints are satisfied.
+
+    Uses a UUID-5 of the project root as a stable project_id, then creates
+    a fresh session row.  Errors are logged but not re-raised.
+    """
+    project_id = str(uuid.uuid5(uuid.NAMESPACE_URL, str(project_root)))
+    session_id = str(uuid.uuid4())
+    now = datetime.now(timezone.utc).isoformat()
+    try:
+        db.execute(
+            "INSERT INTO projects (project_id, root_path, name) VALUES (?, ?, ?)"
+            ' ON CONFLICT(project_id) DO UPDATE SET last_seen = datetime("now")',
+            (project_id, str(project_root), project_root.name),
+        )
+        db.execute(
+            "INSERT INTO sessions (session_id, project_id, created_at, updated_at)"
+            " VALUES (?, ?, ?, ?)",
+            (session_id, project_id, now, now),
+        )
+    except Exception as exc:  # noqa: BLE001
+        log.warning("Session DB init failed (%s) -- btw_queue will be unavailable", exc)
+    return session_id
+
+
+# ---------------------------------------------------------------------------
+# Pending /btw notes display
+# ---------------------------------------------------------------------------
+
+def _show_pending_btw(db: "GdmDatabase", session_id: str, console: Console) -> list[str]:
+    """Print and mark-read pending /btw notes.  Returns message strings."""
+    try:
+        rows = db.execute_all(
+            "SELECT id, message FROM btw_queue"
+            " WHERE session_id = ? AND read_at IS NULL ORDER BY created_at",
+            (session_id,),
+        )
+    except Exception:  # noqa: BLE001
+        return []
+    if not rows:
+        return []
+    messages: list[str] = []
+    now = datetime.now(timezone.utc).isoformat()
+    for row in rows:
+        console.print(f"[dim yellow]note:[/dim yellow] {row['message']}")
+        messages.append(row["message"])
+        try:
+            db.execute("UPDATE btw_queue SET read_at = ? WHERE id = ?", (now, row["id"]))
+        except Exception:  # noqa: BLE001
+            pass
+    return messages
+
+
+# ---------------------------------------------------------------------------
+# Spinner verb selection
+# ---------------------------------------------------------------------------
+
+def _pick_spinner_verb(db: "GdmDatabase", session_id: str) -> str:  # noqa: ARG001
+    """Return a weighted-random spinner verb."""
+    import random
+    from src._internal.constants import _ALL_SPINNER_VERBS, _PRIORITY_VERBS
+
+    today = date.today().isoformat()
+    seen_today = db.spinner_state_get(today)
+
+    weights: list[int] = []
+    for verb in _ALL_SPINNER_VERBS:
+        if verb in _PRIORITY_VERBS:
+            weights.append(30 if verb not in seen_today else 15)
+        else:
+            weights.append(1)
+
+    chosen = random.choices(list(_ALL_SPINNER_VERBS), weights=weights, k=1)[0]
+    if chosen in _PRIORITY_VERBS:
+        db.spinner_state_mark_seen(today, chosen)
+    return chosen
+
+
+# ---------------------------------------------------------------------------
+# Event rendering
+# ---------------------------------------------------------------------------
+
+def _fmt_args(args: dict) -> str:  # type: ignore[type-arg]
+    """Format a tool-args dict for single-line display, truncating long values."""
+    parts = []
+    for k, v in list(args.items())[:3]:
+        sv = str(v)
+        sv = sv[:40] + "..." if len(sv) > 40 else sv
+        parts.append(f"{k}={sv!r}")
+    return ", ".join(parts)
+
+
+def _render_event(event: object, status: Status, console: Console) -> None:
+    """Render one AgentEvent to the terminal while the spinner is live."""
+    from src.agent.loop import EventType  # lazy
+
+    ev = event  # type: ignore[assignment]
+    match ev.type:  # type: ignore[union-attr]
+        case EventType.THINKING:
+            snippet = str(ev.content or "")[:100]  # type: ignore[union-attr]
+            label = f"[dim cyan]Thinking... {snippet}[/dim cyan]"
+            status.update(label)
+        case EventType.TOOL_CALL:
+            console.print(f"[yellow][tool] {ev.tool_name}({_fmt_args(ev.args)})[/yellow]")  # type: ignore[union-attr]
+        case EventType.TOOL_RESULT:
+            result_str = str(ev.result or "")[:80]  # type: ignore[union-attr]
+            console.print(f"[dim green]  -> {result_str}[/dim green]")
+        case EventType.RESPONSE:
+            status.stop()
+            console.print(str(ev.content or ""))  # type: ignore[union-attr]
+        case EventType.ERROR:
+            status.stop()
+            console.print(f"[red]Error: {ev.content}[/red]")  # type: ignore[union-attr]
+        case EventType.COST_UPDATE:
+            console.print(f"[dim]  [${ev.cost_usd:.5f} | turn {ev.turn}][/dim]")  # type: ignore[union-attr]
+        case EventType.DONE:
+            status.stop()
+            console.print("[green]Done[/green]")
+
+
+# ---------------------------------------------------------------------------
+# Agent turn runner
+# ---------------------------------------------------------------------------
+
+def _run_agent_turn(
+    loop: object,
+    user_message: str,
+    console: Console,
+    db: "GdmDatabase",
+    session_id: str,
+) -> None:
+    """Run one agent turn, streaming events with a spinner."""
+    try:
+        from src.agent.loop import AgentLoop  # noqa: F401
+    except (ImportError, AttributeError):
+        console.print("[yellow]Agent loop not yet implemented.[/yellow]")
+        return
+
+    verb = _pick_spinner_verb(db, session_id)
+    status = Status(f"[cyan]{verb}...[/cyan]", console=console, spinner="dots")
+    status.start()
+    try:
+        for event in loop.run(user_message):  # type: ignore[union-attr]
+            _render_event(event, status, console)
+    except Exception as exc:  # noqa: BLE001
+        status.stop()
+        console.print(f"[red]Agent error: {exc}[/red]")
+        log.exception("Agent turn failed")
+    finally:
+        status.stop()
+
+
+# ---------------------------------------------------------------------------
+# Input helper
+# ---------------------------------------------------------------------------
+
+def _build_input_fn(history_path: Path) -> object:
+    """Return a callable() -> str for reading user input.
+
+    Uses prompt_toolkit when available, falls back to built-in input().
+    """
+    if importlib.util.find_spec("prompt_toolkit") is not None:
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.formatted_text import HTML
+        from prompt_toolkit.history import FileHistory
+        import re as _re
+
+        _SENSITIVE_RE = _re.compile(r"^\s*/proxy\s+token\s+\S", _re.IGNORECASE)
+
+        class _SafeHistory(FileHistory):
+            """FileHistory that never persists sensitive /proxy token <secret> entries."""
+            def append_string(self, string: str) -> None:
+                if _SENSITIVE_RE.match(string):
+                    return  # drop silently — token must not reach disk
+                super().append_string(string)
+
+        pt_session: PromptSession[str] = PromptSession(
+            history=_SafeHistory(str(history_path)),
+        )
+
+        def _pt_input() -> str:
+            return pt_session.prompt(HTML(_PROMPT_HTML))
+
+        return _pt_input
+
+    def _builtin_input() -> str:
+        return input("gdm > ")
+
+    return _builtin_input
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+def start_repl(cfg: "GdmConfig", db: "GdmDatabase", *, yes: bool = False, model_override: str | None = None) -> None:
+    """Start the interactive gdm REPL.
+
+    Bootstraps session, builds the agent loop (or falls back gracefully),
+    then enters the prompt/dispatch loop until the user exits.
+    """
+    from src.commands import CommandDispatcher
+    from src.cost_tracker import CostTracker
+
+    console = Console()
+    project_root = cfg.project_root.resolve()
+
+    session_id = _ensure_session(db, project_root)
+
+    history_path = project_root / _HISTORY_FILENAME
+    history_path.parent.mkdir(parents=True, exist_ok=True)
+    read_input = _build_input_fn(history_path)
+
+    cost_tracker = CostTracker(session_id=session_id, provider=cfg.provider)
+    dispatcher = CommandDispatcher(
+        session_id,
+        db,
+        cost_tracker,
+        current_tier="coder",
+        provider=cfg.provider,
+        console=console,
+        project_root=project_root,
+        confirm_fn=read_input,
+        cfg=cfg,
+    )
+
+    loop: object = None
+    permissions: object = None
+    try:
+        from src.agent.context_budget import ContextBudget
+        from src.agent.loop import AgentLoop
+        from src.agent.tool_orchestrator import ToolOrchestrator
+        from src.agent.transcript import TranscriptStore
+        from src.models.definitions import ModelTier, get_model
+        from src.models.router import ModelRouter
+        from src.permissions import PermissionContext
+
+        tier = model_override or ModelTier.CODER
+        model_def = get_model(tier, cfg.provider)
+        _project_id = str(uuid.uuid5(uuid.NAMESPACE_URL, str(project_root)))
+        transcript = TranscriptStore(max_tokens=model_def.context_window)
+        budget = ContextBudget(model_context_window=model_def.context_window)
+        permissions = PermissionContext(db=db, session_id=session_id, non_interactive=False)
+        if yes:
+            permissions.allow_all_session()
+        router = ModelRouter()
+        orchestrator = ToolOrchestrator(
+            permissions=permissions, db=db, session_id=session_id, project_id=_project_id
+        )
+        loop = AgentLoop(
+            cfg=cfg,
+            orchestrator=orchestrator,
+            transcript=transcript,
+            budget=budget,
+            cost_tracker=cost_tracker,
+            model_tier=tier,
+            router=router,
+            db=db,
+            session_id=session_id,
+            project_id=_project_id,
+        )
+    except (ImportError, AttributeError, TypeError) as exc:
+        log.info("AgentLoop unavailable: %s", exc)
+
+    # Graceful shutdown: threading.Event flag pattern — no I/O in signal handlers.
+    import atexit
+    import signal as _sig
+    import threading
+
+    _shutdown_event: threading.Event = threading.Event()
+    _flushed: threading.Event = threading.Event()
+
+    def _flush() -> None:
+        if _flushed.is_set():
+            return
+        _flushed.set()
+        if loop is not None:
+            try:
+                loop._flush_checkpoint_sync()  # type: ignore[union-attr]
+            except Exception:  # noqa: BLE001
+                pass
+
+    def _handle_sigterm(*_: object) -> None:
+        """SIGTERM handler — sets shutdown flag only. No I/O here."""
+        _shutdown_event.set()
+
+    def _handle_sigint(sig: int, frame: object) -> None:
+        """SIGINT handler — first Ctrl+C requests shutdown; second forces exit."""
+        if not _shutdown_event.is_set():
+            _shutdown_event.set()
+        else:
+            _flush()
+            sys.exit(130)
+
+    atexit.register(_flush)
+    try:
+        _sig.signal(_sig.SIGTERM, _handle_sigterm)
+        _sig.signal(_sig.SIGINT, _handle_sigint)
+        if sys.platform == "win32":
+            _sig.signal(_sig.SIGBREAK, _handle_sigterm)  # type: ignore[attr-defined]
+    except (OSError, ValueError):
+        pass  # Not in main thread or platform limitation
+
+    # Startup: check for resumable active sessions from previous runs
+    if loop is not None:
+        try:
+            incomplete = db.list_incomplete_sessions()
+            # Exclude the session we just created (it has no turns yet)
+            incomplete = [s for s in incomplete if s["session_id"] != session_id]
+            if incomplete:
+                sess = incomplete[0]
+                sid_short = sess["session_id"][:8]
+                turns = sess["turn_count"] or 0
+                started = sess["updated_at"] or sess["created_at"] or ""
+                console.print(
+                    f"[yellow]⚡ Session {sid_short}... was in progress "
+                    f"({turns} turn(s), last active: {started[:16].replace('T', ' ')})."
+                    " Resume? [Y/n][/yellow]"
+                )
+                try:
+                    ans = input("").strip().lower()
+                    if not ans or ans.startswith("y"):
+                        n = loop.restore_from_db(sess["session_id"])  # type: ignore[union-attr]
+                        if n:
+                            console.print(f"[green]✓ Restored {n} turns from previous session.[/green]")
+                        else:
+                            console.print("[dim]No checkpoint data found; starting fresh.[/dim]")
+                except (EOFError, KeyboardInterrupt):
+                    pass
+        except Exception:  # noqa: BLE001
+            pass
+
+    # Startup hints from ContinuousMemory (non-blocking, max 3 seconds)
+    if not getattr(cfg, "gdm_quiet", False):
+        try:
+            from src.memory.continuous_memory import ContinuousMemory as _CM
+            _cm_path = str(project_root / ".gdm" / "memory.db")
+            _cm = _CM(db_path=_cm_path)
+            _cm_project_id = str(uuid.uuid5(uuid.NAMESPACE_URL, str(project_root)))
+            _hints = _cm.get_session_hints([], _cm_project_id)
+            if _hints:
+                console.print("[dim]hints (press Enter to skip):[/dim]")
+                for _h in _hints:
+                    console.print(f"[dim]  * {_h}[/dim]")
+                _skip_event: threading.Event = threading.Event()
+
+                def _wait_skip() -> None:
+                    try:
+                        input()
+                        _skip_event.set()
+                    except Exception:  # noqa: BLE001
+                        pass
+
+                threading.Thread(target=_wait_skip, daemon=True).start()
+                _skip_event.wait(3.0)
+        except Exception:  # noqa: BLE001
+            pass
+
+    console.print("[bold green]gdm[/bold green] [dim]ready -- type /help for commands, /exit to quit[/dim]")
+
+    while True:
+        try:
+            raw = read_input()  # type: ignore[call-arg]
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Bye.[/dim]")
+            break
+
+        text = raw.strip()
+        if not text:
+            continue
+
+        if dispatcher.is_command(text):
+            result = dispatcher.handle(text)
+            if result.output:
+                console.print(result.output)
+            if result.prompt_secret:
+                # Token must be collected via hidden input — never stored in history
+                try:
+                    if importlib.util.find_spec("prompt_toolkit") is not None:
+                        from prompt_toolkit.shortcuts import prompt as _pt_prompt
+                        _secret = _pt_prompt(result.prompt_secret, is_password=True)
+                    else:
+                        import getpass as _gp
+                        _secret = _gp.getpass(result.prompt_secret)
+                except (EOFError, KeyboardInterrupt):
+                    _secret = ""
+                sub = dispatcher.apply_proxy_token(_secret)
+                if sub.output:
+                    console.print(sub.output)
+            if result.should_exit:
+                console.print("[dim]Bye.[/dim]")
+                break
+            if result.allow_all and permissions is not None:
+                try:
+                    permissions.allow_all_session()  # type: ignore[union-attr]
+                except AttributeError:
+                    pass
+            if result.force_compact and loop is not None:
+                try:
+                    n = loop._maybe_compress()  # type: ignore[union-attr]
+                    console.print(f"[dim]Compacted {n} turn(s).[/dim]")
+                except AttributeError:
+                    pass
+            if result.new_model_tier and loop is not None:
+                try:
+                    loop.set_tier(result.new_model_tier)  # type: ignore[union-attr]
+                except AttributeError:
+                    pass
+            if result.proxy_action == "enable" and loop is not None and result.proxy_url and result.proxy_token:
+                try:
+                    loop.set_proxy(result.proxy_url, result.proxy_token)  # type: ignore[union-attr]
+                except AttributeError:
+                    pass
+            elif result.proxy_action == "disable" and loop is not None:
+                try:
+                    loop.clear_proxy()  # type: ignore[union-attr]
+                except AttributeError:
+                    pass
+            if result.force_resume and loop is not None:
+                try:
+                    restore_id = result.resume_session_id  # may be None
+                    n = loop.restore_from_db(restore_id)  # type: ignore[union-attr]
+                    if n:
+                        console.print(f"[green]✓ Restored {n} turns from checkpoint.[/green]")
+                    else:
+                        console.print("[yellow]No checkpoint found for this session.[/yellow]")
+                except AttributeError:
+                    console.print("[yellow]Restore not supported by current agent.[/yellow]")
+            continue
+
+        pending = _show_pending_btw(db, session_id, console)
+        full_message = text
+        if pending:
+            notes = "\n".join(f"[context note: {m}]" for m in pending)
+            full_message = f"{notes}\n{text}"
+
+        if loop is None:
+            console.print("[yellow]Agent loop not yet implemented.[/yellow]")
+        else:
+            _run_agent_turn(loop, full_message, console, db, session_id)

src/runtime/__init__.py

@@ -0,0 +1 @@
+"""gdm runtime — branch farming, replay engine, and parallel evaluation."""