letswork 2.0.4__tar.gz → 2.0.6__tar.gz

{letswork-2.0.4 → letswork-2.0.6}/PKG-INFO

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

{letswork-2.0.4 → letswork-2.0.6}/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.6/letswork/proxy.py

@@ -0,0 +1,109 @@
+"""
+LetsWork stdio MCP proxy.
+
+Claude Code connects to this as a stdio MCP server (reliable, no streaming issues).
+This proxy forwards all tool calls to the host's HTTP MCP server over Cloudflare.
+
+Usage (done automatically by `letswork join`):
+    claude mcp add letswork -- letswork-proxy --url <URL> --token <TOKEN>
+"""
+import sys
+import asyncio
+import argparse
+import httpx
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp import types
+
+
+def make_proxy_server(base_url: str, token: str) -> Server:
+    """Create an MCP Server that forwards calls to the remote host."""
+    # Ensure URL ends with /mcp
+    url = base_url.rstrip("/")
+    if not url.endswith("/mcp"):
+        url = url + "/mcp"
+
+    server = Server("letswork-proxy")
+
+    async def _http_post(payload: dict) -> dict:
+        async with httpx.AsyncClient(timeout=30) as client:
+            r = await client.post(
+                url,
+                json=payload,
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/event-stream",
+                },
+            )
+            r.raise_for_status()
+            # Parse SSE response: find 'data: {...}' line
+            for line in r.text.splitlines():
+                if line.startswith("data: "):
+                    import json
+                    return json.loads(line[6:])
+        raise RuntimeError("No data in response")
+
+    @server.list_tools()
+    async def list_tools() -> list[types.Tool]:
+        resp = await _http_post({
+            "jsonrpc": "2.0", "id": 1,
+            "method": "tools/list", "params": {},
+        })
+        tools = []
+        for t in resp.get("result", {}).get("tools", []):
+            schema = t.get("inputSchema", {"type": "object", "properties": {}})
+            # Strip 'token' from schema — proxy injects it automatically
+            schema = dict(schema)
+            props = dict(schema.get("properties", {}))
+            props.pop("token", None)
+            schema["properties"] = props
+            required = [r for r in schema.get("required", []) if r != "token"]
+            if required:
+                schema["required"] = required
+            elif "required" in schema:
+                del schema["required"]
+            tools.append(types.Tool(
+                name=t["name"],
+                description=t.get("description", ""),
+                inputSchema=schema,
+            ))
+        return tools
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
+        # Inject token automatically so guest doesn't have to think about it
+        arguments = {**arguments, "token": token}
+        resp = await _http_post({
+            "jsonrpc": "2.0", "id": 1,
+            "method": "tools/call",
+            "params": {"name": name, "arguments": arguments},
+        })
+        result = resp.get("result", {})
+        content = result.get("content", [])
+        out = []
+        for item in content:
+            if item.get("type") == "text":
+                out.append(types.TextContent(type="text", text=item["text"]))
+        if not out:
+            out.append(types.TextContent(type="text", text=str(result)))
+        return out
+
+    return server
+
+
+async def _run(url: str, token: str) -> None:
+    server = make_proxy_server(url, token)
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="LetsWork MCP stdio proxy")
+    parser.add_argument("--url", required=True, help="Host MCP URL")
+    parser.add_argument("--token", required=True, help="Session token")
+    args = parser.parse_args()
+    asyncio.run(_run(args.url, args.token))
+
+
+if __name__ == "__main__":
+    main()

letswork-2.0.6/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.4 → letswork-2.0.6}/pyproject.toml

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

letswork-2.0.4/letswork/proxy.py

@@ -1,130 +0,0 @@
-"""
-LetsWork stdio MCP proxy.
-
-Claude Code connects to this as a stdio MCP server (reliable, no streaming issues).
-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).
-
-Usage (done automatically by `letswork join`):
-    claude mcp add letswork -- letswork-proxy --url <URL> --token <TOKEN>
-"""
-import sys
-import asyncio
-import argparse
-import logging
-from mcp.server import Server
-from mcp.server.stdio import stdio_server
-from mcp.client.streamable_http import streamablehttp_client
-from mcp import ClientSession, types
-
-log = logging.getLogger("letswork.proxy")
-
-
-def _setup_logging(debug: bool) -> None:
-    level = logging.DEBUG if debug else logging.WARNING
-    logging.basicConfig(
-        stream=sys.stderr,
-        level=level,
-        format="[proxy %(levelname)s] %(message)s",
-    )
-
-
-def make_proxy_server(base_url: str, token: str) -> tuple:
-    """Create an MCP Server that forwards calls to the remote host via a proper session."""
-    url = base_url.rstrip("/")
-    if not url.endswith("/mcp"):
-        url = url + "/mcp"
-
-    server = Server("letswork-proxy")
-    # Shared session state — populated once the client connects
-    _session: ClientSession | None = None
-
-    async def _get_session() -> ClientSession:
-        nonlocal _session
-        if _session is None:
-            raise RuntimeError("Not connected to host")
-        return _session
-
-    @server.list_tools()
-    async def list_tools() -> list[types.Tool]:
-        session = await _get_session()
-        result = await session.list_tools()
-        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)
-            schema["properties"] = props
-            required = [r for r in schema.get("required", []) if r != "token"]
-            if required:
-                schema["required"] = required
-            elif "required" in schema:
-                del schema["required"]
-            tools.append(types.Tool(
-                name=t.name,
-                description=t.description or "",
-                inputSchema=schema,
-            ))
-        return tools
-
-    @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')})")
-        try:
-            result = await session.call_tool(name, arguments)
-        except Exception as e:
-            log.error(f"✗ tool call {name} failed: {e}")
-            raise
-        out = []
-        for item in result.content:
-            if item.type == "text":
-                out.append(types.TextContent(type="text", text=item.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):
-        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
-
-    return server, run
-
-
-async def _main(url: str, token: str, debug: bool) -> None:
-    _setup_logging(debug)
-    log.debug(f"Starting proxy → {url}")
-    _server, run = make_proxy_server(url, token)
-    async with stdio_server() as (read_stream, write_stream):
-        await run(read_stream, write_stream)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="LetsWork MCP stdio proxy")
-    parser.add_argument("--url", required=True, help="Host MCP URL")
-    parser.add_argument("--token", required=True, help="Session token")
-    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
-    args = parser.parse_args()
-    asyncio.run(_main(args.url, args.token, args.debug))
-
-
-if __name__ == "__main__":
-    main()

letswork-2.0.4/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.4/letswork/tui/__init__.py

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