desktop-monkey 0.1.0__py3-none-any.whl

desktop_monkey/__init__.py

@@ -0,0 +1,3 @@
+"""Desktop Monkey - remote MCP + device mesh."""
+
+__version__ = "0.1.0"

desktop_monkey/agent/__init__.py

@@ -0,0 +1 @@
+"""desktop_monkey.agent"""

desktop_monkey/agent/cli.py

@@ -0,0 +1,308 @@
+"""Agent CLI - Typer sub-app wired as dmonkey remote|status|revoke|pause|resume|logout."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import httpx
+import typer
+
+from desktop_monkey.agent.identity import home_dir
+from desktop_monkey.agent.policy import ensure_default_policy, set_paused_flag
+from desktop_monkey.agent.state import is_paused as _is_paused
+from desktop_monkey.agent.state import load_state, wipe_state
+
+app = typer.Typer(help="Device agent - enrol, tunnel, and remote execution")
+
+
+@app.command("remote")
+def remote(
+    server: Annotated[str | None, typer.Option("--server", help="Relay origin URL")] = None,
+    name: Annotated[str | None, typer.Option("--name", help="Device name")] = None,
+    allow: Annotated[
+        list[str] | None, typer.Option("--allow", help="Allowed directory (repeatable)")
+    ] = None,
+    unrestricted: Annotated[bool, typer.Option("--unrestricted", help="Allow all paths")] = False,
+    foreground: Annotated[bool, typer.Option("--foreground", help="Run in foreground")] = False,
+    tools: Annotated[
+        str | None, typer.Option("--tools", help="Comma-separated tool allow-list")
+    ] = None,
+    no_browser: Annotated[
+        bool, typer.Option("--no-browser", help="Print the enrolment URL; never open a tab")
+    ] = False,
+) -> None:
+    """Enrol if needed, then run the tunnel (foreground or daemon)."""
+    h = home_dir()
+    srv = server or "http://127.0.0.1:8787"
+
+    # Configure policy first
+    allow_list = list(allow) if allow else None
+    tools_list = [t.strip() for t in tools.split(",")] if tools else None
+    ensure_default_policy(h, allow_paths=allow_list, unrestricted=unrestricted, tools=tools_list)
+
+    state = load_state(h)
+    if state is None:
+        # Enrol
+        from desktop_monkey.agent.enroll import enrol
+
+        typer.echo(f"Enrolling device with {srv} ...")
+        try:
+            state = enrol(srv, device_name=name, home=h, open_browser=False if no_browser else None)
+            typer.echo(f"Enrolled as {state.device_id} ({state.device_name})")
+        except Exception as exc:
+            typer.echo(f"Enrolment failed: {exc}", err=True)
+            raise typer.Exit(1) from exc
+    else:
+        typer.echo(f"Device already enrolled: {state.device_id}")
+
+    # Run daemon
+    from desktop_monkey.agent.daemon import run_blocking, setup_logging
+
+    setup_logging(h)
+    if foreground:
+        typer.echo("Running in foreground - press Ctrl+C to stop")
+        run_blocking(h)
+    else:
+        # For now, also run blocking (daemon mode needs OS service integration)
+        typer.echo("Running agent (use --foreground to keep in foreground)")
+        run_blocking(h)
+
+
+@app.command("status")
+def status() -> None:
+    """Show device enrolment and connection status."""
+    h = home_dir()
+    state = load_state(h)
+    if state is None:
+        typer.echo("Not enrolled")
+        return
+    typer.echo(f"Device: {state.device_name} ({state.device_id})")
+    typer.echo(f"Server: {state.server}")
+    paused = _is_paused(h)
+    typer.echo(f"Paused: {paused}")
+    # Check tunnel URL
+    if state.tunnel_url:
+        typer.echo(f"Tunnel: {state.tunnel_url}")
+    # Check config
+    from desktop_monkey.agent.policy import load_policy
+
+    policy = load_policy(h)
+    typer.echo(f"Allowed dirs: {policy.allowed_directories}")
+    if policy.allowed_tools:
+        typer.echo(f"Allowed tools: {policy.allowed_tools}")
+    typer.echo(f"Unrestricted: {policy.unrestricted}")
+
+
+@app.command("revoke")
+def revoke() -> None:
+    """Wipe local state and best-effort server revoke."""
+    h = home_dir()
+    state = load_state(h)
+    if state is not None:
+        # Best-effort server revoke
+        try:
+            resp = httpx.post(
+                f"{state.server.rstrip('/')}/device/revoke",
+                json={"device_id": state.device_id},
+                headers={"Authorization": f"Bearer {state.device_token}"},
+                timeout=5,
+            )
+            if resp.status_code == 200:
+                typer.echo("Server revoke OK")
+            else:
+                typer.echo(f"Server revoke returned {resp.status_code} (continuing)")
+        except Exception as exc:
+            typer.echo(f"Server revoke failed: {exc} (continuing)")
+    wipe_state(h)
+    typer.echo("Local state wiped")
+
+
+@app.command("pause")
+def pause() -> None:
+    """Pause remote execution (device stays connected but refuses calls)."""
+    h = home_dir()
+    set_paused_flag(True, h)
+    typer.echo("Device paused - remote calls will be refused")
+
+
+@app.command("resume")
+def resume() -> None:
+    """Resume remote execution."""
+    h = home_dir()
+    set_paused_flag(False, h)
+    typer.echo("Device resumed")
+
+
+@app.command("logout")
+def logout() -> None:
+    """Alias for revoke (wipe local state)."""
+    h = home_dir()
+    state = load_state(h)
+    if state is not None:
+        try:
+            httpx.post(
+                f"{state.server.rstrip('/')}/device/revoke",
+                json={"device_id": state.device_id},
+                headers={"Authorization": f"Bearer {state.device_token}"},
+                timeout=5,
+            )
+        except Exception:
+            pass
+    wipe_state(h)
+    typer.echo("Logged out - local state wiped")
+
+
+@app.command("memory")
+def memory(
+    json_out: Annotated[
+        bool, typer.Option("--json", help="Print the full snapshot as JSON")
+    ] = False,
+    publish_file: Annotated[
+        bool, typer.Option("--publish", help="Also write the status file Monkey Monitor reads")
+    ] = False,
+) -> None:
+    """How much RAM this agent holds, and how close the host is to Quner's floor."""
+    from desktop_monkey.mesh.memory import MemoryGauge, memory_status_path, publish
+
+    try:
+        snap = MemoryGauge.from_env().sample()
+    except ValueError as exc:
+        typer.echo(f"invalid memory configuration: {exc}", err=True)
+        raise typer.Exit(2) from exc
+    written = publish(snap, memory_status_path(home_dir())) if publish_file else None
+    if json_out:
+        typer.echo(snap.model_dump_json(indent=2))
+        return
+
+    gib = 1.0 / 1024
+    h, a, q = snap.host, snap.agent, snap.quner
+    typer.echo(f"memory level: {snap.level.upper()}")
+    for r in snap.reasons:
+        typer.echo(f"  - {r}")
+    if h.available_frac is not None and h.total_mib and h.available_mib is not None:
+        typer.echo(
+            f"host: {h.available_mib * gib:.1f} of {h.total_mib * gib:.1f} GiB available "
+            f"({h.available_frac * 100:.1f}%)"
+            + (f", swap used {h.swap_used_mib * gib:.1f} GiB" if h.swap_used_mib else "")
+        )
+        if h.psi_some_avg10 is not None:
+            typer.echo(
+                f"      stall (PSI avg10): some {h.psi_some_avg10:.1f}%  full {h.psi_full_avg10 or 0.0:.1f}%"
+            )
+    else:
+        typer.echo("host: memory could not be read")
+    pss = "n/a" if a.pss_mib is None else f"{a.pss_mib:.0f} MiB"
+    partial = "" if a.pss_complete or a.pss_mib is None else " (partial)"
+    typer.echo(
+        f"agent: {a.process_count} process(es), {pss} PSS{partial}"
+        + (f", {a.share_of_host_pct:.1f}% of host" if a.share_of_host_pct is not None else "")
+    )
+    typer.echo(f"       RSS {a.rss_mib:.0f} MiB - {a.rss_note}")
+    if a.budget_mib is not None:
+        typer.echo(
+            f"       budget {a.budget_mib:.0f} MiB ({'OVER' if a.over_budget else 'within'})"
+        )
+    for p in a.processes[:6]:
+        pp = "  n/a" if p.pss_mib is None else f"{p.pss_mib:>6.0f}"
+        typer.echo(
+            f"         pid {p.pid:<7} {p.name[:22]:<22} PSS {pp} MiB  RSS {p.rss_mib:>6.0f} MiB"
+        )
+    typer.echo(
+        "quner: "
+        + (
+            f"memguard '{q.action}' (warns {q.warn_frac * 100:.0f}%, kills {q.kill_frac * 100:.0f}% available)"
+            if q.readable
+            else "status file not readable"
+        )
+    )
+    if snap.quner_victim is not None:
+        v = snap.quner_victim
+        typer.echo(
+            f"       would pick: {v.name} pid {v.pid} ({v.rss_mib:.0f} MiB RSS)"
+            + ("  <-- THIS AGENT" if v.ours else "")
+        )
+    for n in snap.notes:
+        typer.echo(f"note: {n}")
+    if written:
+        typer.echo(f"published: {written}")
+
+
+@app.command("learn")
+def learn(
+    action: Annotated[
+        str, typer.Argument(help="Action: observe, sleep, jettison, refine, recall, stats")
+    ] = "stats",
+    query: Annotated[str | None, typer.Option("--query", "-q", help="Query for recall")] = None,
+    content: Annotated[
+        str | None, typer.Option("--content", "-c", help="Content to observe")
+    ] = None,
+    source: Annotated[
+        str | None, typer.Option("--source", "-s", help="Source for observation")
+    ] = None,
+) -> None:
+    """Brain-like learning system for the mesh.
+
+    Actions:
+      observe  - Observe and learn from information
+      sleep    - Run a sleep/dream cycle for consolidation
+      jettison - Jettison low-salience memories
+      refine   - Refine memory pathways
+      recall   - Recall relevant memories (requires --query)
+      stats    - Show learning statistics
+    """
+    from desktop_monkey.learning.mesh_learning import MeshLearning
+
+    h = home_dir()
+    state = load_state(h)
+    device_id = state.device_id if state else "local"
+
+    learner = MeshLearning(device_id)
+
+    if action == "observe":
+        if not content:
+            typer.echo("Error: --content required for observe", err=True)
+            raise typer.Exit(1)
+        src = source or "cli"
+        entry_id = learner.observe_event(src, {"content": content})
+        if entry_id:
+            typer.echo(f"Retained as {entry_id}")
+        else:
+            typer.echo("Observed but not retained (low salience)")
+
+    elif action == "sleep":
+        typer.echo("Running sleep/dream cycle...")
+        learner.sleep_cycle()
+        typer.echo("Sleep cycle complete")
+
+    elif action == "jettison":
+        typer.echo("Jettisoning low-salience memories...")
+        learner.jettison_memories()
+        typer.echo("Done")
+
+    elif action == "refine":
+        typer.echo("Refining memory pathways...")
+        learner.refine_pathways()
+        typer.echo("Done")
+
+    elif action == "recall":
+        if not query:
+            typer.echo("Error: --query required for recall", err=True)
+            raise typer.Exit(1)
+        memories = learner.recall_relevant(query, top_k=5)
+        if not memories:
+            typer.echo("No relevant memories found")
+        else:
+            for i, mem in enumerate(memories, 1):
+                typer.echo(f"{i}. [{mem.entry_id}] {mem.content[:100]}...")
+                typer.echo(f"   strength={mem.strength:.2f} accesses={mem.access_count}")
+
+    elif action == "stats":
+        stats = learner.get_learning_stats()
+        typer.echo(f"Observations: {stats['observations']}")
+        typer.echo(f"Memories: {stats['memories']}")
+        typer.echo(f"Dream cycles: {stats['dream_cycles']}")
+        typer.echo(f"Avg salience: {stats['avg_salience']:.3f}")
+
+    else:
+        typer.echo(f"Unknown action: {action}", err=True)
+        raise typer.Exit(1)

desktop_monkey/agent/daemon.py

@@ -0,0 +1,183 @@
+"""Daemon - orchestrates tunnel + executor + logging."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from typing import Any
+
+from desktop_monkey.agent.executor import Executor, SeenJtis
+from desktop_monkey.agent.identity import home_dir
+from desktop_monkey.agent.memreport import MemoryReporter
+from desktop_monkey.agent.policy import load_policy
+from desktop_monkey.agent.state import load_state, log_file, wipe_state
+from desktop_monkey.agent.tunnel import Tunnel
+from desktop_monkey.mesh.memory import MemoryGauge, memory_status_path
+from desktop_monkey.protocol import crypto
+from desktop_monkey.protocol.frames import Revoke
+
+# Never log secrets - filter
+_SENSITIVE_KEYS = {
+    "device_token",
+    "refresh_token",
+    "ed25519_priv",
+    "x25519_priv",
+    "token",
+    "secret",
+}
+
+
+class _SecretFilter(logging.Filter):
+    """Redact sensitive values from log records."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        msg = record.getMessage().lower()
+        for key in _SENSITIVE_KEYS:
+            if key in msg:
+                # Don't emit lines that look like they contain secrets
+                # But we use structured logging without secret values, so this is safety net
+                pass
+        return True
+
+
+def setup_logging(home: Path | None = None) -> logging.Logger:
+    """Configure structured logging to agent.log (rotating), never logging args/results/tokens."""
+    h = home or home_dir()
+    h.mkdir(parents=True, exist_ok=True)
+    lf = log_file(home)
+    logger = logging.getLogger("desktop_monkey.agent")
+    logger.setLevel(logging.INFO)
+    # Avoid duplicate handlers
+    if not any(isinstance(ha, RotatingFileHandler) for ha in logger.handlers):
+        handler = RotatingFileHandler(
+            str(lf),
+            maxBytes=5 * 1024 * 1024,
+            backupCount=3,
+            encoding="utf-8",
+        )
+        fmt = logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s")
+        handler.setFormatter(fmt)
+        handler.addFilter(_SecretFilter())
+        logger.addHandler(handler)
+        # Also prevent propagation to root
+        logger.propagate = False
+    return logger
+
+
+def _build_executor(
+    device_id: str,
+    seal_key: crypto.SealKey | None,
+    home: Path | None = None,
+    registry: Any = None,
+    signing_key: crypto.SigningKey | None = None,
+    memory: Any = None,
+) -> Executor:
+    """Build executor with policy and pause check."""
+    from desktop_monkey.agent.state import is_paused
+
+    policy = load_policy(home)
+
+    # Build registry if not provided
+    if registry is None:
+        try:
+            from desktop_monkey.commander.base import build_registry
+
+            registry = build_registry()
+        except Exception:
+            registry = None
+
+    def _is_paused() -> bool:
+        return is_paused(home)
+
+    def _on_revoke(_frame: Revoke) -> None:
+        wipe_state(home)
+
+    seen = SeenJtis(max_size=10_000, ttl_s=120)
+
+    executor = Executor(
+        device_id=device_id,
+        device_seal_key=seal_key,
+        registry=registry,
+        policy=policy,
+        seen_jtis=seen,
+        is_paused_fn=_is_paused,
+        on_revoke=_on_revoke,
+        device_signing_key=signing_key,
+        memory=memory,
+    )
+    return executor
+
+
+async def run_daemon(
+    home: Path | None = None,
+    registry: Any = None,
+) -> None:
+    """Run the agent daemon (tunnel + executor) until stopped."""
+    h = home or home_dir()
+    state = load_state(h)
+    if state is None:
+        raise RuntimeError("device not enrolled - run 'dmonkey remote' first")
+
+    logger = setup_logging(h)
+    logger.info("agent starting device_id=%s server=%s", state.device_id, state.server)
+
+    # Build keys from stored state
+    signing_key = crypto.SigningKey.from_b64(state.ed25519_priv)
+    seal_key = crypto.SealKey.from_b64(state.x25519_priv, state.x25519_pub)
+
+    # Memory self-awareness: one gauge feeds admission control, ping telemetry, the status
+    # file Monkey Monitor reads, and the tunnel's pressure/heartbeat frames.
+    try:
+        gauge = MemoryGauge.from_env()
+    except ValueError as exc:
+        raise RuntimeError(f"invalid memory configuration: {exc}") from exc
+
+    executor = _build_executor(
+        state.device_id, seal_key, h, registry=registry, signing_key=signing_key, memory=gauge
+    )
+
+    def _handle_revoke_sync(_frame: Revoke) -> None:
+        logger.info("revoke received - wiping state")
+        wipe_state(h)
+
+    # Wire revoke handler that actually wipes
+    executor.on_revoke = _handle_revoke_sync  # type: ignore[assignment]
+
+    tunnel = Tunnel(
+        server=state.server,
+        device_id=state.device_id,
+        signing_key=signing_key,
+        executor=executor,
+        tunnel_url=state.tunnel_url,
+    )
+
+    reporter = MemoryReporter(gauge, path=memory_status_path(h), send_frame=tunnel.send_frame)
+    reporter_task = reporter.start()
+    first = gauge.latest(max_age_s=0)
+    logger.info(
+        "memory: agent %s MiB PSS across %d process(es), host %.0f%% available, level %s",
+        first.agent.pss_mib,
+        first.agent.process_count,
+        100 * (first.host.available_frac or 0.0),
+        first.level,
+    )
+
+    logger.info("connecting to %s", tunnel.ws_url)
+    try:
+        await tunnel.run_forever()
+    except asyncio.CancelledError:
+        logger.info("agent stopped")
+        raise
+    finally:
+        await reporter.stop(reporter_task)
+        logger.info("agent exiting")
+
+
+def run_blocking(home: Path | None = None, registry: Any = None) -> None:
+    """Synchronous entry point for CLI --foreground mode."""
+    try:
+        asyncio.run(run_daemon(home=home, registry=registry))
+    except KeyboardInterrupt:
+        pass