devtorch-core 3.0.1__py3-none-any.whl

devtorch_core/cloud/setup.py

@@ -0,0 +1,144 @@
+"""One-command Cloudflare Worker deployment for DevTorch MCP server.
+
+This module wraps ``deploy/cloudflare-worker/setup-mcp-server.sh`` so it can be
+called as ``devtorch cloud setup``. It is intentionally thin: the shell script
+still owns the npm/wrangler lifecycle; Python only validates CLI arguments and
+forwards them.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Sequence
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+_PACKAGE_DIR = Path(__file__).resolve().parent
+_REPO_ROOT = _PACKAGE_DIR.parents[1]
+SETUP_SCRIPT = _REPO_ROOT / "deploy" / "cloudflare-worker" / "setup-mcp-server.sh"
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def run_cloud_setup(
+    *,
+    env_file: str | Path | None = None,
+    org: str | None = None,
+    repo: str | None = None,
+    ide: str | None = None,
+    openai_key: str | None = None,
+    non_interactive: bool = False,
+    skip_key: bool = False,
+    skip_client_config: bool = False,
+    dry_run: bool = False,
+) -> dict[str, str | list[str]]:
+    """Build and optionally run the Cloudflare Worker setup command.
+
+    Args:
+        env_file: Path to an environment file to source before running the script.
+        org: DevTorch org ID. Required in non-interactive mode.
+        repo: DevTorch repo ID. Required in non-interactive mode.
+        ide: IDE to configure (opencode, claude, cursor, vscode, stdio).
+        openai_key: Optional OpenAI API key for the DRPL embedding backend.
+        non_interactive: Run without prompts (requires ``org`` and ``repo``).
+        skip_key: Skip creating a new API key.
+        skip_client_config: Skip installing MCP client config.
+        dry_run: If True, return the command without executing it.
+
+    Returns:
+        A dict with ``script`` and ``args`` (the constructed argument list).
+    """
+    if not SETUP_SCRIPT.exists():
+        raise FileNotFoundError(
+            f"Setup script not found: {SETUP_SCRIPT}. "
+            "Is the DevTorch repo checkout complete?"
+        )
+
+    if non_interactive and (not org or not repo):
+        raise ValueError("--non-interactive requires --org and --repo")
+
+    if non_interactive and not skip_client_config and not ide:
+        raise ValueError("--non-interactive requires --ide unless --skip-client-config is set")
+
+    args: list[str] = [str(SETUP_SCRIPT)]
+    if env_file:
+        args.extend(["--env-file", str(env_file)])
+    if non_interactive:
+        args.append("--non-interactive")
+    if org:
+        args.extend(["--org", org])
+    if repo:
+        args.extend(["--repo", repo])
+    if ide:
+        args.extend(["--ide", ide])
+    if openai_key:
+        args.extend(["--openai-key", openai_key])
+    if skip_key:
+        args.append("--skip-key")
+    if skip_client_config:
+        args.append("--skip-client-config")
+
+    if dry_run:
+        return {"script": str(SETUP_SCRIPT), "args": args}
+
+    result = subprocess.run(args, capture_output=False, text=True, check=False)
+    return {
+        "script": str(SETUP_SCRIPT),
+        "args": args,
+        "returncode": str(result.returncode),
+    }
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """CLI entry point used by ``devtorch cloud setup``."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Deploy a self-hosted DevTorch MCP server on Cloudflare Workers.",
+    )
+    parser.add_argument("--env-file", help="Path to environment file to source")
+    parser.add_argument("--org", help="DevTorch org ID")
+    parser.add_argument("--repo", help="DevTorch repo ID")
+    parser.add_argument("--ide", choices=["opencode", "claude", "cursor", "vscode", "stdio"],
+                        help="IDE to configure locally")
+    parser.add_argument("--openai-key", help="OpenAI API key for DRPL embedding backend")
+    parser.add_argument("--non-interactive", action="store_true",
+                        help="Run without prompts (requires --org and --repo)")
+    parser.add_argument("--skip-key", action="store_true", help="Skip creating API key")
+    parser.add_argument("--skip-client-config", action="store_true", help="Skip IDE config")
+    parser.add_argument("--dry-run", action="store_true", help="Print command instead of running")
+    args = parser.parse_args(argv)
+
+    try:
+        result = run_cloud_setup(
+            env_file=args.env_file,
+            org=args.org,
+            repo=args.repo,
+            ide=args.ide,
+            openai_key=args.openai_key,
+            non_interactive=args.non_interactive,
+            skip_key=args.skip_key,
+            skip_client_config=args.skip_client_config,
+            dry_run=args.dry_run,
+        )
+    except (FileNotFoundError, ValueError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    if args.dry_run:
+        print(" ".join(result["args"]))
+        return 0
+
+    return int(result.get("returncode", "0"))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

devtorch_core/cloud/sync.py

@@ -0,0 +1,143 @@
+"""One-way local -> cloud reasoning sync.
+
+Pushes local .GCC commits to the DevTorch cloud MCP worker so that
+cloud-connected agents' `devtorch_context` sees reasoning recorded by
+local-only agents (hooks / CLI). Uses the worker's direct-POST fallback:
+POST /messages without an SSE session returns the JSON-RPC result in the
+response body.
+
+Transport hardening: if the direct-POST path fails, we open an SSE
+handshake once, capture the live endpoint URL, and retry through that
+session-bound endpoint. The SSE-derived URL is cached for all subsequent
+commits in the same sync run.
+
+Cursor: .GCC/cloud_sync_state.json {"last_pushed_index": N}. Commit ids are
+sequential hex (COMMIT_INDEX), so the cursor is a simple integer.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+_STATE_FILE = "cloud_sync_state.json"
+_USER_AGENT = "devtorch-cloud-sync"
+
+_SSE_ENDPOINT_CACHE: str | None = None
+
+
+def _sse_handshake(sse_url: str, api_key: str, timeout: float) -> str:
+    """Open an SSE connection, capture the endpoint URL, and return it."""
+    req = urllib.request.Request(
+        sse_url,
+        headers={
+            "Accept": "text/event-stream",
+            "X-DevTorch-Key": api_key,
+            "User-Agent": _USER_AGENT,
+        },
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        # Read line-by-line so the chunked HTTP reader does not block waiting
+        # for the next chunk after the endpoint event (the server keeps the SSE
+        # connection open for subsequent messages).
+        event_type = None
+        data = None
+        while True:
+            line = resp.readline()
+            if not line:
+                break
+            line = line.decode("utf-8", errors="replace")
+            if line.startswith("event:"):
+                event_type = line[6:].strip()
+            elif line.startswith("data:"):
+                data = line[5:].strip()
+            elif line.strip() == "":
+                if event_type == "endpoint" and data:
+                    return data
+                event_type = None
+                data = None
+    raise RuntimeError("SSE endpoint event not received")
+
+
+def sync_commits(
+    gcc_dir: Path,
+    messages_url: str,
+    api_key: str,
+    timeout: float = 30.0,
+    from_now: bool = False,
+) -> dict:
+    gcc_dir = Path(gcc_dir)
+    if not gcc_dir.is_dir():
+        raise ValueError(f"{gcc_dir} is not an initialized .GCC repository")
+    try:
+        top = int((gcc_dir / "COMMIT_INDEX").read_text(encoding="utf-8").strip() or "0")
+    except (OSError, ValueError):
+        top = 0
+
+    state_path = gcc_dir / _STATE_FILE
+    try:
+        cursor = int(json.loads(state_path.read_text(encoding="utf-8"))["last_pushed_index"])
+    except (OSError, ValueError, KeyError, json.JSONDecodeError):
+        cursor = 0
+
+    if cursor > top:
+        cursor = 0
+
+    if from_now:
+        state_path.write_text(
+            json.dumps({"last_pushed_index": top}) + "\n", encoding="utf-8"
+        )
+        return {"pushed": 0, "skipped": top, "cursor": top}
+
+    global _SSE_ENDPOINT_CACHE
+    pushed = 0
+    for index in range(cursor + 1, top + 1):
+        commit_id = format(index, "08x")
+        commit_path = gcc_dir / "commits" / f"{commit_id}.json"
+        try:
+            obj = json.loads(commit_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        message = (
+            f"[synced from local {commit_id} @ {obj.get('timestamp', 'unknown')}] "
+            f"{obj.get('message', '')}"
+        )
+        try:
+            _post_commit(messages_url, api_key, index, message, timeout)
+        except (urllib.error.HTTPError, urllib.error.URLError, TimeoutError):
+            if _SSE_ENDPOINT_CACHE is None:
+                sse_url = messages_url.rsplit("/", 1)[0] + "/sse"
+                _SSE_ENDPOINT_CACHE = _sse_handshake(sse_url, api_key, timeout)
+            _post_commit(_SSE_ENDPOINT_CACHE, api_key, index, message, timeout)
+        pushed += 1
+        state_path.write_text(
+            json.dumps({"last_pushed_index": index}) + "\n", encoding="utf-8"
+        )
+
+    return {"pushed": pushed, "skipped": cursor, "cursor": max(cursor, top)}
+
+
+def _post_commit(
+    messages_url: str, api_key: str, rpc_id: int, message: str, timeout: float
+) -> None:
+    payload = {
+        "jsonrpc": "2.0",
+        "id": rpc_id,
+        "method": "tools/call",
+        "params": {"name": "devtorch_commit", "arguments": {"message": message}},
+    }
+    req = urllib.request.Request(
+        messages_url,
+        data=json.dumps(payload).encode(),
+        headers={
+            "Content-Type": "application/json",
+            "X-DevTorch-Key": api_key,
+            "User-Agent": _USER_AGENT,
+        },
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        body = json.loads(resp.read().decode())
+    if body.get("error") or body.get("result", {}).get("isError"):
+        raise RuntimeError(f"cloud commit failed: {json.dumps(body)[:200]}")