letswork 2.0.3__tar.gz → 2.0.5__tar.gz

{letswork-2.0.3 → letswork-2.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letswork
-Version: 2.0.3
+Version: 2.0.5
 Summary: Real-time collaborative coding via MCP — two developers, one codebase
 Author: Sai Charan Rajoju
 License-Expression: MIT

{letswork-2.0.3 → letswork-2.0.5}/letswork/cli.py

@@ -37,10 +37,22 @@ def start(port, debug):
     server_module.approval_queue = approval_queue
 
     def _on_approved(change):
+        # Release the lock so the file can be written to again
+        rel = os.path.relpath(
+            os.path.abspath(os.path.join(project_root, change.path)),
+            os.path.abspath(project_root),
+        )
+        server_module.lock_manager.release_lock(rel, change.user_id)
         event_log.emit(EventType.FILE_WRITE, change.user_id,
                        {"path": change.path, "status": "approved"})
 
     def _on_rejected(change):
+        # Release the lock so the guest can retry or move on
+        rel = os.path.relpath(
+            os.path.abspath(os.path.join(project_root, change.path)),
+            os.path.abspath(project_root),
+        )
+        server_module.lock_manager.release_lock(rel, change.user_id)
         event_log.emit(EventType.FILE_WRITE, change.user_id,
                        {"path": change.path, "status": "rejected"})
 
@@ -148,14 +160,9 @@ def start(port, debug):
             click.echo(f"  [{ts}] 🔌 {event.user_id} connected")
         elif event.event_type == EventType.ERROR:
             click.echo(f"  [{ts}] ⚠️  {event.data.get('error', '?')}")
-        elif event.event_type == EventType.PING:
-            click.echo(f"  [{ts}] 🏓 {event.user_id} pinged")
-        if debug:
-            if event.event_type not in (
-                EventType.FILE_WRITE, EventType.CONNECTION,
-                EventType.ERROR, EventType.PING,
-            ):
-                click.echo(f"  [{ts}] [debug] {event.event_type.value} — {event.data}")
+        elif debug:
+            # Debug-only events (ping, file reads, locks, etc.)
+            click.echo(f"  [{ts}] [debug] {event.event_type.value} by {event.user_id} — {event.data}")
 
     event_log.on_event(_notify)
 

{letswork-2.0.3 → letswork-2.0.5}/letswork/events.py

@@ -73,8 +73,6 @@ class EventLog:
             return f"[{time}] 🔒 {user_id} locked {data.get('path', '?')}"
         elif event_type == EventType.FILE_UNLOCK:
             return f"[{time}] 🔓 {user_id} unlocked {data.get('path', '?')}"
-        elif event_type == EventType.CHAT_MESSAGE:
-            return f"[{time}] 💬 {user_id}: {data.get('message', '')}"
         elif event_type == EventType.FILE_TREE_REQUEST:
             return f"[{time}] 📁 {user_id} viewed file tree"
             

{letswork-2.0.3 → letswork-2.0.5}/letswork/proxy.py

@@ -5,6 +5,9 @@ Claude Code connects to this as a stdio MCP server (reliable, no streaming issue
 This proxy forwards all tool calls to the host's HTTP MCP server using a proper
 MCP client session (required by FastMCP's streamable HTTP transport).
 
+Reconnects automatically if the tunnel drops. Sends a keepalive ping every 30s
+to prevent Cloudflare from closing idle connections.
+
 Usage (done automatically by `letswork join`):
     claude mcp add letswork -- letswork-proxy --url <URL> --token <TOKEN>
 """
@@ -19,6 +22,9 @@ from mcp import ClientSession, types
 
 log = logging.getLogger("letswork.proxy")
 
+_RECONNECT_DELAYS = [1, 2, 5, 10, 30]  # seconds between attempts
+_KEEPALIVE_INTERVAL = 30               # seconds between keepalive pings
+
 
 def _setup_logging(debug: bool) -> None:
     level = logging.DEBUG if debug else logging.WARNING
@@ -36,13 +42,12 @@ def make_proxy_server(base_url: str, token: str) -> tuple:
         url = url + "/mcp"
 
     server = Server("letswork-proxy")
-    # Shared session state — populated once the client connects
     _session: ClientSession | None = None
+    _session_lock = asyncio.Lock()
 
     async def _get_session() -> ClientSession:
-        nonlocal _session
         if _session is None:
-            raise RuntimeError("Not connected to host")
+            raise RuntimeError("Not connected to host — reconnecting, please retry in a moment")
         return _session
 
     @server.list_tools()
@@ -52,7 +57,6 @@ def make_proxy_server(base_url: str, token: str) -> tuple:
         tools = []
         for t in result.tools:
             schema = t.inputSchema if t.inputSchema else {"type": "object", "properties": {}}
-            # Strip 'token' — proxy injects it automatically
             schema = dict(schema)
             props = dict(schema.get("properties", {}))
             props.pop("token", None)
@@ -72,39 +76,72 @@ def make_proxy_server(base_url: str, token: str) -> tuple:
     @server.call_tool()
     async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
         session = await _get_session()
-        # Inject token automatically
         arguments = {**arguments, "token": token}
-        log.debug(f"→ tool call: {name}({list(k for k in arguments if k != 'token')})")
+        log.debug(f"→ {name}({[k for k in arguments if k != 'token']})")
         try:
             result = await session.call_tool(name, arguments)
         except Exception as e:
-            log.error(f"✗ tool call {name} failed: {e}")
+            log.error(f"✗ {name} failed: {e}")
             raise
-        out = []
-        for item in result.content:
-            if item.type == "text":
-                out.append(types.TextContent(type="text", text=item.text))
+        out = [types.TextContent(type="text", text=item.text)
+               for item in result.content if item.type == "text"]
         if not out:
             out.append(types.TextContent(type="text", text=str(result)))
         log.debug(f"← {name} OK")
         return out
 
-    async def run(read_stream, write_stream):
+    async def _keepalive(session: ClientSession) -> None:
+        """Ping host every 30s so Cloudflare doesn't close the idle connection."""
+        while True:
+            await asyncio.sleep(_KEEPALIVE_INTERVAL)
+            try:
+                await session.call_tool("ping", {"token": token})
+                log.debug("keepalive ping OK")
+            except Exception as e:
+                log.debug(f"keepalive ping failed: {e}")
+                break  # session is dead — let the outer loop reconnect
+
+    async def _connect_loop(read_stream, write_stream) -> None:
         nonlocal _session
-        log.debug(f"Connecting to host at {url}")
-        try:
-            async with streamablehttp_client(url) as (host_read, host_write, _):
-                async with ClientSession(host_read, host_write) as session:
-                    await session.initialize()
-                    _session = session
-                    log.debug("Connected to host MCP server")
-                    await server.run(
-                        read_stream, write_stream,
-                        server.create_initialization_options(),
-                    )
-        except Exception as e:
-            log.error(f"Proxy connection failed: {e}")
-            raise
+        attempt = 0
+        first = True
+
+        while True:
+            try:
+                log.debug(f"Connecting to host at {url} (attempt {attempt + 1})")
+                async with streamablehttp_client(url) as (host_read, host_write, _):
+                    async with ClientSession(host_read, host_write) as session:
+                        await session.initialize()
+                        async with _session_lock:
+                            _session = session
+                        attempt = 0
+                        log.debug("Connected to host MCP server")
+
+                        if first:
+                            first = False
+                            # Start serving stdio on first connect
+                            asyncio.ensure_future(
+                                server.run(read_stream, write_stream,
+                                           server.create_initialization_options())
+                            )
+
+                        # Run keepalive until connection drops
+                        await _keepalive(session)
+
+            except Exception as e:
+                async with _session_lock:
+                    _session = None
+                if first:
+                    # Failed on very first attempt — bail out, Claude Code will show error
+                    log.error(f"Initial connection failed: {e}")
+                    raise
+                delay = _RECONNECT_DELAYS[min(attempt, len(_RECONNECT_DELAYS) - 1)]
+                attempt += 1
+                log.debug(f"Disconnected ({e}), retrying in {delay}s...")
+                await asyncio.sleep(delay)
+
+    async def run(read_stream, write_stream):
+        await _connect_loop(read_stream, write_stream)
 
     return server, run
 

letswork-2.0.5/letswork/tunnel.py

@@ -0,0 +1,52 @@
+import subprocess
+import shutil
+import re
+import time
+import threading
+
+
+def start_tunnel(port: int) -> tuple[str, subprocess.Popen]:
+    """Start a Cloudflare tunnel pointing to the local MCP server port. Returns the HTTPS URL and the subprocess handle."""
+    if shutil.which("cloudflared") is None:
+        raise RuntimeError("cloudflared is not installed. Install it from https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/")
+
+    command = ["cloudflared", "tunnel", "--url", f"http://localhost:{port}"]
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    url_found = threading.Event()
+    result: list[str] = []
+
+    def _read_stderr():
+        deadline = time.monotonic() + 60  # 60s timeout
+        while time.monotonic() < deadline:
+            line = process.stderr.readline()
+            if not line:
+                if process.poll() is not None:
+                    break
+                continue
+            text = line.decode("utf-8", errors="replace").strip()
+            match = re.search(r"https://[a-zA-Z0-9\-]+\.trycloudflare\.com", text)
+            if match:
+                result.append(match.group(0))
+                url_found.set()
+                return
+
+    reader = threading.Thread(target=_read_stderr, daemon=True)
+    reader.start()
+
+    if url_found.wait(timeout=60):
+        return result[0], process
+
+    process.terminate()
+    if process.poll() is None:
+        process.wait(timeout=5)
+    raise RuntimeError("Failed to start tunnel: could not find tunnel URL within 60 seconds")
+
+
+def stop_tunnel(process: subprocess.Popen) -> None:
+    """Gracefully terminate the cloudflared subprocess."""
+    process.terminate()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        process.kill()

{letswork-2.0.3 → letswork-2.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "letswork"
-version = "2.0.3"
+version = "2.0.5"
 description = "Real-time collaborative coding via MCP — two developers, one codebase"
 readme = "README.md"
 license = "MIT"

letswork-2.0.3/letswork/remote_client.py

@@ -1,115 +0,0 @@
-import asyncio
-import threading
-from mcp.client.streamable_http import streamablehttp_client
-from mcp import ClientSession
-
-_RECONNECT_DELAYS = [1, 2, 5, 10, 30]  # seconds between retries
-
-
-class RemoteClient:
-    """
-    Connects to Host MCP server over streamable-http,
-    exposes sync methods for TUI widgets.
-    Auto-reconnects if the connection drops.
-    """
-    def __init__(self, mcp_url: str, token: str):
-        self.mcp_url = mcp_url
-        self.token = token
-        self._session: ClientSession | None = None
-        self._loop: asyncio.AbstractEventLoop | None = None
-        self._thread: threading.Thread | None = None
-        self._connected = False
-        self._should_run = False
-        self._on_reconnect: callable | None = None
-
-    def on_reconnect(self, callback: callable) -> None:
-        """Register a callback invoked after each successful reconnect."""
-        self._on_reconnect = callback
-
-    def connect(self) -> bool:
-        self._should_run = True
-        loop = asyncio.new_event_loop()
-        self._loop = loop
-        ready_event = threading.Event()
-
-        async def _run_loop():
-            attempt = 0
-            while self._should_run:
-                try:
-                    async with streamablehttp_client(self.mcp_url) as (read, write, _):
-                        async with ClientSession(read, write) as session:
-                            await session.initialize()
-                            self._session = session
-                            self._connected = True
-                            attempt = 0
-                            ready_event.set()
-                            if self._on_reconnect:
-                                self._on_reconnect()
-                            while self._connected and self._should_run:
-                                await asyncio.sleep(0.1)
-                except Exception:
-                    self._connected = False
-                    self._session = None
-                    if not ready_event.is_set():
-                        # First connect failed — signal caller and stop retrying
-                        ready_event.set()
-                        return
-                    # Reconnect with backoff
-                    delay = _RECONNECT_DELAYS[min(attempt, len(_RECONNECT_DELAYS) - 1)]
-                    attempt += 1
-                    await asyncio.sleep(delay)
-
-        def thread_target():
-            loop.run_until_complete(_run_loop())
-
-        self._thread = threading.Thread(target=thread_target, daemon=True)
-        self._thread.start()
-
-        ready_event.wait(timeout=10)
-        return self._connected
-
-    def disconnect(self):
-        self._should_run = False
-        self._connected = False
-        if self._thread:
-            self._thread.join(timeout=5)
-        self._session = None
-        self._loop = None
-
-    def _run_async(self, coro) -> any:
-        if not self._connected or self._loop is None:
-            raise RuntimeError("Not connected")
-        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
-        return future.result(timeout=15)
-
-    def _call_tool(self, tool_name: str, arguments: dict) -> str:
-        if not self._connected or self._session is None:
-            return "Error: not connected"
-        try:
-            result = self._run_async(
-                self._session.call_tool(tool_name, arguments)
-            )
-            for item in result.content:
-                if item.type == "text":
-                    return item.text
-            return str(result)
-        except Exception as e:
-            return f"Error: {e}"
-
-    def list_files(self, path: str = ".") -> str:
-        return self._call_tool("list_files", {"token": self.token, "path": path})
-
-    def read_file(self, path: str) -> str:
-        return self._call_tool("read_file", {"token": self.token, "path": path})
-
-    def write_file(self, path: str, content: str) -> str:
-        return self._call_tool("write_file", {"token": self.token, "path": path, "content": content})
-
-    def lock_file(self, path: str) -> str:
-        return self._call_tool("lock_file", {"token": self.token, "path": path})
-
-    def unlock_file(self, path: str) -> str:
-        return self._call_tool("unlock_file", {"token": self.token, "path": path})
-
-    def get_status(self) -> str:
-        return self._call_tool("get_status", {"token": self.token})

letswork-2.0.3/letswork/tui/__init__.py

@@ -1 +0,0 @@
-"""LetsWork TUI dashboard."""