dot-mcp 0.1.0__py3-none-any.whl

dot_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""dot-mcp: single-file personal MCP agent with shell, files, memory,
+goals, inbox, scheduler, capability URL + self-hosted OAuth."""
+__version__ = "0.1.0"

dot_mcp/agent_test.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Quick client test: list tools + call list_dir, get_state, remember/recall."""
+import asyncio, json, os, sys
+from mcp.client.streamable_http import streamable_http_client
+from mcp.client.session import ClientSession
+
+URL = sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:33041/mcp/"
+
+def _secret() -> str:
+    if os.environ.get("MCP_PATH_SECRET", "").strip():
+        return os.environ["MCP_PATH_SECRET"].strip()
+    base = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")))
+    for name in ("owner_secret", "path_secret"):  # latter is legacy
+        try:
+            return open(os.path.join(base, "dot-mcp", name), encoding="utf-8").read().strip()
+        except Exception:
+            pass
+    return ""
+
+async def main():
+    try:
+        import httpx
+    except ImportError:
+        import httpx2 as httpx  # .venv/LiteLLM-era rename
+    sec = _secret()
+    client = httpx.AsyncClient(headers={"Authorization": f"Bearer {sec}"}) if sec else None
+    async with streamable_http_client(URL, http_client=client) as streams:
+        rs, ws = streams[0], streams[1]
+        async with ClientSession(rs, ws) as s:
+            await s.initialize()
+            tools = await s.list_tools()
+            names = [t.name for t in tools.tools]
+            print("TOOLS:", names)
+            r = await s.call_tool("get_state", {})
+            print("STATE:", r.content[0].text[:500] if r.content else r)
+            r = await s.call_tool("list_dir", {"path": "~", "limit": 5})
+            print("LS:", r.content[0].text[:800] if r.content else r)
+            r = await s.call_tool("remember", {"note": "agent test ok", "tag": "test"})
+            print("REMEMBER:", r.content[0].text[:300] if r.content else r)
+            r = await s.call_tool("recall", {"query": "agent test", "limit": 3})
+            print("RECALL:", r.content[0].text[:800] if r.content else r)
+
+asyncio.run(main())

dot_mcp/cli.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""dot-mcp CLI: `dot-mcp start`, `dot-mcp status`, `dot-mcp stop`.
+
+Works both from a source checkout (src/ layout) and as an installed package
+(`pip install dot-mcp`). Defaults: port 33041, data in ~/.dot-mcp.
+"""
+from __future__ import annotations
+import argparse, json, os, secrets, subprocess, sys
+from pathlib import Path
+
+from dot_mcp import orchestrator as ui
+
+
+def _repo_root() -> Path:
+    """Source checkout root if present (for .venv + logs), else the data dir."""
+    here = Path(__file__).resolve()          # <repo>/src/dot_mcp/cli.py
+    repo = here.parent.parent.parent         # <repo> in a source checkout
+    if (repo / "pyproject.toml").exists() or (repo / "dot_mcp.py").exists() or (repo / "src").is_dir():
+        return repo
+    data = Path(os.environ.get("DOT_MCP_DATA", str(Path.home() / ".dot-mcp")))
+    data.mkdir(parents=True, exist_ok=True)
+    return data
+
+
+REPO = _repo_root()
+STATE_DIR = Path(os.environ.get("DOT_MCP_STATE_DIR",
+                 os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))) ) / "dot-mcp"
+SECRET_FILE = STATE_DIR / "owner_secret"
+DEFAULT_PORT = 33041
+DEFAULT_DATA = str(Path.home() / ".dot-mcp")
+
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich import box
+    console = Console()
+    HAS_RICH = True
+except Exception:  # plain fallback
+    HAS_RICH = False
+    class _C:
+        def print(self, *a, **k):
+            print(*[str(x).replace("[", "").replace("]", "") for x in a])
+    console = _C()  # type: ignore
+    Panel = Table = None  # type: ignore
+
+ACCENT = "cyan"
+WARN = "yellow"
+ERR = "red"
+OK = "green"
+
+
+def banner(sub: str = "") -> None:
+    title = "[bold cyan]dot-mcp[/] [dim]personal MCP agent[/]"
+    if sub:
+        title += f"  [bold white]{sub}[/]"
+    if HAS_RICH:
+        console.print(Panel(title, box=box.ROUNDED, border_style=ACCENT))
+    else:
+        console.print(f"== dot-mcp {sub} ==")
+
+
+def get_secret() -> str:
+    """Per-machine owner secret: read from disk, else generate + save (0600)."""
+    try:
+        s = SECRET_FILE.read_text(encoding="utf-8").strip()
+        if s:
+            return s
+    except Exception:
+        pass
+    s = secrets.token_urlsafe(32)
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    os.chmod(STATE_DIR, 0o700)
+    tmp = SECRET_FILE.with_suffix(".tmp")
+    tmp.write_text(s + "\n", encoding="utf-8")
+    os.replace(tmp, SECRET_FILE)
+    os.chmod(SECRET_FILE, 0o600)
+    return s
+
+
+def server_python() -> tuple[str, str | None]:
+    """(python, src_dir). Source checkout: .venv if present + src on path.
+    Installed package: this interpreter (dot_mcp is importable)."""
+    src = REPO / "src"
+    if (src / "dot_mcp" / "server.py").exists():
+        venv = REPO / ".venv" / "bin" / "python"
+        py = str(venv) if (venv.is_file() and os.access(venv, os.X_OK)) else sys.executable
+        return py, str(src)
+    return sys.executable, None
+
+
+def _start_oauth_client(data_dir: str) -> dict:
+    """Read the pre-provisioned OAuth client the server writes at boot."""
+    try:
+        st = json.loads((Path(data_dir) / "oauth.json").read_text(encoding="utf-8"))
+        sc = st.get("static_client")
+        if isinstance(sc, dict) and sc.get("client_id"):
+            return sc
+    except Exception:
+        pass
+    return {}
+
+
+def cmd_start(args: argparse.Namespace) -> int:
+    port = args.port or DEFAULT_PORT
+    data_dir = args.data_dir or DEFAULT_DATA
+    # Owner secret: stable per machine (env wins, else file, else generate+save).
+    secret = (os.environ.get("MCP_PATH_SECRET", "").strip() or get_secret())
+    py, src_dir = server_python()
+    env = dict(os.environ, MCP_PORT=str(port), MCP_HOST="127.0.0.1",
+               DOT_MCP_DATA=data_dir, MCP_PATH_SECRET=secret)
+    if src_dir:  # source checkout: make `dot_mcp` importable for -m
+        env["PYTHONPATH"] = src_dir + os.pathsep + env.get("PYTHONPATH", "")
+    try:
+        v = subprocess.run([py, "-c", "import mcp; print('mcp-ok')"],
+                           capture_output=True, text=True, timeout=30, env=env).stdout.strip()
+        assert "mcp-ok" in v
+    except Exception:
+        print(f"no mcp package in {py} — run ./setup.sh first", file=sys.stderr)
+        return 1
+    ctx = ui.StartCtx(port=port, data_dir=data_dir, secret=secret, py=py,
+                      env=env, repo=REPO)
+
+    if args.json:
+        # script mode: full flow, JSON ONLY to stdout, server left running
+        import contextlib
+        import io
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            res = ui.plain_flow(ctx, STATE_DIR, console, leave_running=True)
+        oauth = _start_oauth_client(data_dir)
+        sys.stdout.write(ui.json_result(res.ok, ctx, res, oauth) + "\n")
+        return 0 if res.ok else 1
+
+    banner("start")
+    if ui.port_in_use(port):
+        console.print(f"[{ERR}]port {port} is already in use — run dot-mcp status or dot-mcp stop first[/]")
+        return 1
+
+    # Run the full flow quietly (no spinner, no live output) — then show results once.
+    # leave_running=True: the verified server stays up as a detached background
+    # process, so we can return to the shell instead of blocking it.
+    import contextlib, io
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        res = ui.plain_flow(ctx, STATE_DIR, console, leave_running=True)
+    if not res.ok:
+        return 1
+
+    # Show all info in one shot
+    host = res.host
+    public_mcp = res.public_url
+    oauth = _start_oauth_client(data_dir)
+    t = Table("", "", box=box.SIMPLE, show_header=False)
+    t.add_row("Public URL", public_mcp)
+    t.add_row("Owner secret", secret)
+    t.add_row("OAuth Client ID", oauth.get("client_id", "—"))
+    t.add_row("OAuth Client secret", oauth.get("client_secret", "—"))
+    console.print(t)
+    console.print(Panel(
+        f"[bold green]Running.[/] Paste the public URL into your connector (auth = OAuth).",
+        title="ready", border_style=OK))
+    console.print("[dim]Server running in the background — dots status / dots stop[/]\n")
+    return 0
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    port = args.port or DEFAULT_PORT
+    try:
+        import urllib.request
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=5) as r:
+            info = json.loads(r.read().decode())
+        console.print(f"[{OK}]● running[/] port {port} · tools {info.get('tools')} · home {info.get('home')}")
+        return 0
+    except Exception:
+        console.print(f"[{ERR}]○ stopped[/] port {port} (no server)")
+        return 1
+
+
+def cmd_stop(_: argparse.Namespace) -> int:
+    import signal as _sig
+    killed = 0
+    me = os.getpid()
+    try:
+        # matches both `dot_mcp.py` (legacy) and `-m dot_mcp.server` (packaged)
+        out = subprocess.run(["pgrep", "-f", "dot_mcp[.]"],
+                             capture_output=True, text=True).stdout
+        for pid in out.split():
+            try:
+                pid_i = int(pid)
+            except ValueError:
+                continue
+            if pid_i == me:
+                continue
+            try:
+                with open(f"/proc/{pid_i}/cmdline", "rb") as fh:
+                    cmd = fh.read().replace(b"\x00", b" ").decode(errors="replace")
+                if "dot_mcp.cli" in cmd:   # never kill our own CLI
+                    continue
+            except Exception:
+                continue
+            try:
+                os.kill(pid_i, _sig.SIGTERM)
+                killed += 1
+            except Exception:
+                pass
+    except Exception:
+        pass
+    pidfile = REPO / "logs" / "tunnl.pid"
+    try:
+        if pidfile.is_file():
+            os.kill(int(pidfile.read_text().strip()), _sig.SIGTERM)
+            pidfile.unlink()
+            console.print("Tunnel stopped.")
+    except Exception:
+        pass
+    console.print(f"Stopped {killed} server(s). " if killed else "No server running.")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="dot-mcp", description="dot-mcp personal agent CLI")
+    sub = ap.add_subparsers(dest="cmd")
+    p = sub.add_parser("start", help="run MCP server + tunnel (runs in background)")
+    p.add_argument("--port", type=int, default=0, help="override port (default 33041)")
+    p.add_argument("--data-dir", default="", help="override data dir (default ~/.dot-mcp)")
+    p.add_argument("--json", action="store_true", help="script mode: JSON result, server left running")
+    q = sub.add_parser("status", help="check if the server is running")
+    q.add_argument("--port", type=int, default=0, help="override port (default 33041)")
+    sub.add_parser("stop", help="stop server + tunnel")
+    args = ap.parse_args(argv)
+    if args.cmd == "start":
+        return cmd_start(args)
+    if args.cmd == "status":
+        return cmd_status(args)
+    if args.cmd == "stop":
+        return cmd_stop(args)
+    banner()
+    console.print("Commands: [bold]start[/] · [bold]status[/] · [bold]stop[/]\nExample: [cyan]dot-mcp start[/]")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dot_mcp/local_agent.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Local-only dot agent: ChatGPT model (API key) + MCP server on this machine.
+No tunnel, no sub needed. Server: http://127.0.0.1:33041/mcp
+
+  export OPENAI_API_KEY=sk-...
+  .venv/bin/python local_agent.py            # chat loop
+  .venv/bin/python local_agent.py --list     # list MCP tools only (no key needed)
+  OPENAI_MODEL=gpt-4o-mini .venv/bin/python local_agent.py
+"""
+from __future__ import annotations
+import asyncio, json, os, sys
+
+MCP_URL = os.environ.get("MCP_URL", "http://127.0.0.1:33041/mcp/")
+MODEL = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
+
+def _owner_secret() -> str:
+    if os.environ.get("MCP_PATH_SECRET", "").strip():
+        return os.environ["MCP_PATH_SECRET"].strip()
+    base = os.environ.get("DOT_MCP_STATE_DIR", "") or os.path.join(
+        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")))
+    for name in ("owner_secret", "path_secret"):  # latter is legacy
+        try:
+            s = open(os.path.join(base, "dot-mcp", name), encoding="utf-8").read().strip()
+            if s:
+                return s
+        except Exception:
+            pass
+    return ""
+
+def _http_client():
+    try:
+        import httpx
+    except ImportError:
+        import httpx2 as httpx  # .venv/LiteLLM-era rename
+    sec = _owner_secret()
+    if not sec: return None
+    # NOTE: no custom User-Agent — httpx2 in .venv duplicates it and the v2 server rejects the request.
+    return httpx.AsyncClient(headers={"Authorization": f"Bearer {sec}"})
+SYSTEM = ("You are the user's dot on their own machine. "
+  "At start call get_state, poll_inbox, recall. "
+  "Save important facts with remember, progress with add_update, "
+  "visible results with notify_user. "
+  "Relative paths resolve from $HOME.")
+
+async def mcp_tools():
+    from mcp.client.streamable_http import streamable_http_client
+    from mcp.client.session import ClientSession
+    async with streamable_http_client(MCP_URL, http_client=_http_client()) as streams:
+        rs, ws = streams[0], streams[1]
+        async with ClientSession(rs, ws) as s:
+            await s.initialize()
+            t = await s.list_tools()
+            return [{"name": x.name, "desc": x.description or "",
+                     "schema": getattr(x, "input_schema", None) or getattr(x, "inputSchema", None)} for x in t.tools]
+
+async def main():
+    if "--list" in sys.argv:
+        for t in await mcp_tools():
+            print(f"- {t['name']}: {t['desc'][:80]}")
+        return
+    key = os.environ.get("OPENAI_API_KEY", "")
+    if not key:
+        print("need OPENAI_API_KEY"); raise SystemExit(1)
+    from openai import OpenAI
+    client = OpenAI(base_url=os.environ.get("OPENAI_BASE_URL") or None)
+    defs = await mcp_tools()
+    tools = [{"type": "function", "function": {
+        "name": d["name"], "description": d["desc"][:500],
+        "parameters": d["schema"] or {"type": "object", "properties": {}}}}
+        for d in defs]
+    from mcp.client.streamable_http import streamable_http_client
+    from mcp.client.session import ClientSession
+    async with streamable_http_client(MCP_URL, http_client=_http_client()) as streams:
+        rs, ws = streams[0], streams[1]
+        async with ClientSession(rs, ws) as s:
+            await s.initialize()
+            msgs = [{"role": "system", "content": SYSTEM}]
+            print(f"dot local ready [{MODEL}] ({len(tools)} tools). exit to quit.")
+            while True:
+                try: q = input("\n> ").strip()
+                except (EOFError, KeyboardInterrupt): break
+                if q in ("exit", "quit"): break
+                if not q: continue
+                msgs.append({"role": "user", "content": q})
+                for _ in range(10):
+                    r = client.chat.completions.create(model=MODEL, messages=msgs, tools=tools or None)
+                    m = r.choices[0].message
+                    if not m.tool_calls:
+                        print(m.content); msgs.append({"role": "assistant", "content": m.content or ""}); break
+                    msgs.append({"role": "assistant", "content": m.content or "", "tool_calls": [
+                        {"id": c.id, "type": "function",
+                         "function": {"name": c.function.name, "arguments": c.function.arguments}}
+                        for c in m.tool_calls]})
+                    for c in m.tool_calls:
+                        name = c.function.name
+                        try: args = json.loads(c.function.arguments or "{}")
+                        except Exception: args = {}
+                        try:
+                            res = await s.call_tool(name, args)
+                            out = "\n".join(
+                                getattr(b, "text", str(b)) for b in (res.content or []))[:6000]
+                        except Exception as e:
+                            out = f"ERROR: {e}"
+                        print(f"[{name}] {out[:500]}")
+                        msgs.append({"role": "tool", "tool_call_id": c.id, "content": out})
+
+asyncio.run(main())