comfygit-deploy 0.3.20__tar.gz → 0.4.0__tar.gz

{comfygit_deploy-0.3.20 → comfygit_deploy-0.4.0}/.gitignore

@@ -29,6 +29,7 @@ node_modules/
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
+*.tsbuildinfo
 
 # Environment variables
 .env
@@ -94,5 +95,7 @@ docs/contexts
 # MEOW agent orchestration runtime
 .meow/
 
-# Beads issue tracking - synced via beads-sync branch only
-.beads/issues.jsonl
+# Local/retired agent task systems
+.beads/
+.threads/
+.ctxr/

{comfygit_deploy-0.3.20 → comfygit_deploy-0.4.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: comfygit-deploy
-Version: 0.3.20
+Version: 0.4.0
 Summary: ComfyGit Deploy - Remote deployment and worker management CLI
 Project-URL: Documentation, https://docs.comfygit.org/
 Project-URL: Repository, https://github.com/comfygit-ai/comfygit
 Project-URL: Issues, https://github.com/comfygit-ai/comfygit/issues
 Requires-Python: >=3.10
-Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: comfygit==0.3.20
+Requires-Dist: aiohttp>=3.13.4
+Requires-Dist: comfygit==0.4.0
 Requires-Dist: zeroconf>=0.131.0
 Description-Content-Type: text/markdown
 

{comfygit_deploy-0.3.20 → comfygit_deploy-0.4.0}/comfygit_deploy/cli.py

@@ -187,6 +187,8 @@ def create_parser() -> argparse.ArgumentParser:
     )
     up_parser.add_argument("--broadcast", action="store_true", help="Enable mDNS broadcast")
     up_parser.add_argument("--port-range", default="8200:8210", help="Instance port range")
+    up_parser.add_argument("--cloud", help="Remote coordination service base URL or websocket URL")
+    up_parser.add_argument("--token", help="Tunnel auth token for the remote coordination service")
     up_parser.add_argument("--dev", action="store_true", help="Use saved dev config (from 'dev setup')")
     up_parser.add_argument("--dev-core", metavar="PATH", help="Use local comfygit-core (editable)")
     up_parser.add_argument("--dev-manager", metavar="PATH", help="Use local comfygit-manager")

{comfygit_deploy-0.3.20 → comfygit_deploy-0.4.0}/comfygit_deploy/commands/worker.py

@@ -4,10 +4,14 @@ Commands for setting up and managing the worker server on GPU machines.
 """
 
 import argparse
+import asyncio
+import contextlib
 import json
 import secrets
 from pathlib import Path
 
+from ..config import DeployConfig
+
 WORKER_CONFIG_PATH = Path.home() / ".config" / "comfygit" / "deploy" / "worker.json"
 
 
@@ -59,6 +63,28 @@ def save_worker_config(config: dict) -> None:
     WORKER_CONFIG_PATH.write_text(json.dumps(config, indent=2))
 
 
+def _resolve_cloud_settings(args: argparse.Namespace) -> tuple[str | None, str | None]:
+    config = DeployConfig()
+
+    cloud_arg = getattr(args, "cloud", None)
+    token_arg = getattr(args, "token", None)
+
+    cloud_url = cloud_arg or config.cloud_url
+    cloud_token = token_arg or config.cloud_token
+
+    updated = False
+    if cloud_arg:
+        config.cloud_url = cloud_arg
+        updated = True
+    if token_arg:
+        config.cloud_token = token_arg
+        updated = True
+    if updated:
+        config.save()
+
+    return cloud_url, cloud_token
+
+
 def is_worker_running() -> bool:
     """Check if worker server is running."""
     # Simple check - look for PID file or try to connect
@@ -156,15 +182,23 @@ def handle_up(args: argparse.Namespace) -> int:
         manager_link.symlink_to(dev_manager)
         print(f"Dev mode: manager -> {dev_manager}")
 
+    cloud_url, cloud_token = _resolve_cloud_settings(args)
+    if bool(cloud_url) != bool(cloud_token):
+        print("Cloud tunnel requires both --cloud and --token, or both values saved in config.")
+        return 1
+
     print(f"Starting worker server on {args.host}:{args.port}...")
     print(f"  Mode: {args.mode}")
     print(f"  Instance ports: {port_start}-{port_end}")
     print(f"  Broadcast: {args.broadcast}")
+    if cloud_url:
+        print(f"  Cloud tunnel: {cloud_url}")
     print()
     print("Press Ctrl+C to stop.")
 
     from aiohttp import web
 
+    from ..tunnel.client import TunnelClient
     from ..worker.server import create_worker_app
 
     app = create_worker_app(
@@ -175,6 +209,33 @@ def handle_up(args: argparse.Namespace) -> int:
         port_range_end=port_end,
     )
 
+    if cloud_url and cloud_token:
+        try:
+            tunnel_client = TunnelClient(
+                cloud_url=cloud_url,
+                token=cloud_token,
+                worker_server=app["worker"],
+            )
+        except ValueError as exc:
+            print(f"Invalid cloud URL: {exc}")
+            return 1
+
+        app["tunnel_client"] = tunnel_client
+
+        async def _start_tunnel(app: web.Application) -> None:
+            app["tunnel_task"] = asyncio.create_task(tunnel_client.run())
+
+        async def _stop_tunnel(app: web.Application) -> None:
+            await tunnel_client.close()
+            tunnel_task = app.get("tunnel_task")
+            if tunnel_task:
+                tunnel_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await tunnel_task
+
+        app.on_startup.append(_start_tunnel)
+        app.on_cleanup.append(_stop_tunnel)
+
     # Save PID file
     pid_file = WORKER_CONFIG_PATH.parent / "worker.pid"
     import os

{comfygit_deploy-0.3.20 → comfygit_deploy-0.4.0}/comfygit_deploy/config.py

@@ -30,7 +30,12 @@ class DeployConfig:
             path: Config file path. Defaults to ~/.config/comfygit/deploy/config.json
         """
         self.path = path or _get_default_config_path()
-        self._data: dict[str, Any] = {"version": "1", "providers": {}, "workers": {}}
+        self._data: dict[str, Any] = {
+            "version": "1",
+            "providers": {},
+            "workers": {},
+            "cloud": {},
+        }
         self._load()
 
     def _load(self) -> None:
@@ -69,6 +74,34 @@ class DeployConfig:
         """Get custom workers registry."""
         return self._data.get("workers", {})
 
+    @property
+    def cloud_url(self) -> str | None:
+        """Get the saved remote service URL for tunnel mode."""
+        return self._data.get("cloud", {}).get("url")
+
+    @cloud_url.setter
+    def cloud_url(self, value: str | None) -> None:
+        if "cloud" not in self._data:
+            self._data["cloud"] = {}
+        if value is None:
+            self._data["cloud"].pop("url", None)
+        else:
+            self._data["cloud"]["url"] = value
+
+    @property
+    def cloud_token(self) -> str | None:
+        """Get the saved remote service auth token for tunnel mode."""
+        return self._data.get("cloud", {}).get("token")
+
+    @cloud_token.setter
+    def cloud_token(self, value: str | None) -> None:
+        if "cloud" not in self._data:
+            self._data["cloud"] = {}
+        if value is None:
+            self._data["cloud"].pop("token", None)
+        else:
+            self._data["cloud"]["token"] = value
+
     def add_worker(
         self,
         name: str,

comfygit_deploy-0.4.0/comfygit_deploy/tunnel/__init__.py

@@ -0,0 +1,6 @@
+"""WebSocket tunnel support for remote workers."""
+
+from .client import TunnelClient
+from .handler import TunnelHandler
+
+__all__ = ["TunnelClient", "TunnelHandler"]

comfygit_deploy-0.4.0/comfygit_deploy/tunnel/client.py

@@ -0,0 +1,191 @@
+"""Worker-side WebSocket tunnel client."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
+
+import aiohttp
+
+from ..worker.server import WorkerServer
+from .handler import TunnelHandler
+
+MAX_MESSAGE_BYTES = 1_000_000
+PING_INTERVAL_SECONDS = 30.0
+AUTH_TIMEOUT_SECONDS = 10.0
+MAX_RECONNECT_SECONDS = 30.0
+
+
+def normalize_cloud_ws_url(cloud_url: str) -> str:
+    parsed = urlsplit(cloud_url)
+    if parsed.scheme not in {"http", "https", "ws", "wss"}:
+        raise ValueError("Cloud URL must start with http://, https://, ws://, or wss://")
+    if not parsed.netloc:
+        raise ValueError("Cloud URL must include a hostname")
+
+    if parsed.scheme == "http":
+        scheme = "ws"
+    elif parsed.scheme == "https":
+        scheme = "wss"
+    else:
+        scheme = parsed.scheme
+
+    path = parsed.path or ""
+    if path in {"", "/"}:
+        path = "/api/workers/ws"
+    elif not path.endswith("/api/workers/ws"):
+        path = path.rstrip("/") + "/api/workers/ws"
+
+    return urlunsplit((scheme, parsed.netloc, path, "", ""))
+
+
+class TunnelClient:
+    """Maintains an outbound worker tunnel connection to a remote coordination service."""
+
+    def __init__(self, cloud_url: str, token: str, worker_server: WorkerServer):
+        self.websocket_url = normalize_cloud_ws_url(cloud_url)
+        self.token = token
+        self.worker_server = worker_server
+        self.handler = TunnelHandler(worker_server)
+        self._stop_event = asyncio.Event()
+        self._session: aiohttp.ClientSession | None = None
+        self._ws: aiohttp.ClientWebSocketResponse | None = None
+        self.worker_id: str | None = None
+
+    async def run(self) -> None:
+        backoff = 1.0
+
+        while not self._stop_event.is_set():
+            try:
+                await self._run_once()
+                backoff = 1.0
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                if self._stop_event.is_set():
+                    break
+
+                print(f"Cloud tunnel disconnected: {exc}")
+                print(f"Reconnecting in {int(backoff)}s...")
+                try:
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=backoff)
+                except asyncio.TimeoutError:
+                    pass
+                backoff = min(backoff * 2, MAX_RECONNECT_SECONDS)
+
+        await self.close()
+
+    async def close(self) -> None:
+        self._stop_event.set()
+        if self._ws is not None and not self._ws.closed:
+            await self._ws.close()
+        if self._session is not None and not self._session.closed:
+            await self._session.close()
+
+    async def _run_once(self) -> None:
+        self._session = aiohttp.ClientSession()
+        try:
+            self._ws = await self._session.ws_connect(
+                self.websocket_url,
+                autoping=False,
+                heartbeat=None,
+                max_msg_size=MAX_MESSAGE_BYTES,
+            )
+            await self._send_json({"type": "auth", "token": self.token})
+
+            auth_message = await self._receive_json(timeout=AUTH_TIMEOUT_SECONDS)
+            if auth_message.get("type") == "auth_error":
+                raise RuntimeError(str(auth_message.get("message") or "Tunnel auth failed"))
+            if auth_message.get("type") != "auth_ok":
+                raise RuntimeError("Tunnel auth handshake returned an unexpected response")
+
+            self.worker_id = str(auth_message.get("worker_id") or "")
+            print(f"Connected to {self.websocket_url}")
+
+            ping_task = asyncio.create_task(self._ping_loop())
+            try:
+                while not self._stop_event.is_set():
+                    message = await self._receive_json()
+                    await self.handle_message(message)
+            finally:
+                ping_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await ping_task
+        finally:
+            self.worker_id = None
+            if self._ws is not None and not self._ws.closed:
+                await self._ws.close()
+            if self._session is not None and not self._session.closed:
+                await self._session.close()
+            self._ws = None
+            self._session = None
+
+    async def _ping_loop(self) -> None:
+        while not self._stop_event.is_set():
+            await asyncio.sleep(PING_INTERVAL_SECONDS)
+            await self._send_json({"type": "ping"})
+
+    async def _send_json(self, payload: dict[str, Any]) -> None:
+        if self._ws is None:
+            raise RuntimeError("Tunnel websocket is not connected")
+
+        encoded = json.dumps(payload, separators=(",", ":"), ensure_ascii=True)
+        if len(encoded.encode("utf-8")) > MAX_MESSAGE_BYTES:
+            raise RuntimeError("Tunnel message exceeds the 1MB size limit")
+        await self._ws.send_str(encoded)
+
+    async def _receive_json(self, *, timeout: float | None = None) -> dict[str, Any]:
+        if self._ws is None:
+            raise RuntimeError("Tunnel websocket is not connected")
+
+        message = await self._ws.receive(timeout=timeout)
+        if message.type != aiohttp.WSMsgType.TEXT:
+            if message.type in {aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSED}:
+                raise RuntimeError("Cloud tunnel closed the connection")
+            if message.type == aiohttp.WSMsgType.ERROR:
+                raise RuntimeError("Cloud tunnel websocket reported an error")
+            raise RuntimeError(f"Unexpected websocket message type: {message.type}")
+
+        raw = message.data
+        if len(raw.encode("utf-8")) > MAX_MESSAGE_BYTES:
+            raise RuntimeError("Tunnel message exceeds the 1MB size limit")
+
+        try:
+            payload = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise RuntimeError("Cloud tunnel sent invalid JSON") from exc
+
+        if not isinstance(payload, dict):
+            raise RuntimeError("Cloud tunnel sent a non-object message")
+        return payload
+
+    async def handle_message(self, message: dict[str, Any]) -> None:
+        message_type = str(message.get("type") or "")
+
+        if message_type == "pong":
+            return
+
+        if message_type == "ping":
+            await self._send_json({"type": "pong"})
+            return
+
+        try:
+            response = await self.handler.handle_message(message)
+        except Exception as exc:
+            request_id = message.get("request_id")
+            if isinstance(request_id, str) and request_id:
+                await self._send_json(
+                    {
+                        "type": "error",
+                        "request_id": request_id,
+                        "message": str(exc),
+                    }
+                )
+            else:
+                print(f"Tunnel handler error: {exc}")
+            return
+
+        await self._send_json(response)