letswork 2.0.0__tar.gz → 2.0.2__tar.gz

{letswork-2.0.0 → letswork-2.0.2}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.4
 Name: letswork
-Version: 2.0.0
+Version: 2.0.2
 Summary: Real-time collaborative coding via MCP — two developers, one codebase
 Author: Sai Charan Rajoju
 License-Expression: MIT
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1.0
+Requires-Dist: httpx>=0.27.0
 Requires-Dist: mcp[cli]>=1.0.0
-Requires-Dist: textual[syntax]>=0.50.0
-Requires-Dist: websockets>=12.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: types-requests; extra == 'dev'

{letswork-2.0.0 → letswork-2.0.2}/letswork/cli.py

@@ -15,13 +15,13 @@ def cli():
 
 @cli.command()
 @click.option("--port", default=8000, type=int, help="Port for the MCP server")
-def start(port):
+@click.option("--debug", is_flag=True, help="Show live tool call activity")
+def start(port, debug):
     """Start a LetsWork collaboration session."""
-    from letswork.events import EventLog
+    import logging
+    from letswork.events import EventLog, EventType
     from letswork.approval import ApprovalQueue
-    from letswork.launcher import launch_claude_code, launch_chat_window, register_guest_mcp
-
-    name = click.prompt("What's your name?")
+    from letswork.launcher import launch_claude_code, register_guest_mcp
 
     project_root = os.getcwd()
     server_module.project_root = project_root
@@ -31,20 +31,20 @@ def start(port):
     server_module.register_user(host_token, "host")
     server_module.register_user(guest_token, "guest")
 
-    server_module.event_log = EventLog()
+    event_log = EventLog()
+    server_module.event_log = event_log
     server_module.approval_queue = ApprovalQueue(project_root)
 
     # Start tunnel
     try:
         url, tunnel_process = start_tunnel(port)
     except RuntimeError as e:
-        click.echo(f"Error: {e}")
+        click.echo(f"[ERROR] Tunnel failed: {e}")
         return
 
     mcp_url = f"{url}/mcp"
 
-    # Silence MCP and uvicorn loggers before server starts
-    import logging
+    # Silence MCP and uvicorn loggers
     for _name in ("uvicorn", "uvicorn.access", "uvicorn.error", "mcp", "mcp.server",
                   "mcp.server.streamable_http", "asyncio"):
         logging.getLogger(_name).setLevel(logging.CRITICAL)
@@ -54,8 +54,7 @@ def start(port):
             and server_module.app.settings.transport_security):
         server_module.app.settings.transport_security.enable_dns_rebinding_protection = False
 
-    # Start MCP server in background thread — run uvicorn directly so we can
-    # pass log_config=None, which fully disables all uvicorn request logging.
+    # Start MCP server in background thread
     def run_server():
         import anyio
         import uvicorn
@@ -75,9 +74,10 @@ def start(port):
 
     threading.Thread(target=run_server, daemon=True).start()
 
-    # Wait until the server is actually responding (any HTTP response means it's up)
+    # Wait until server is up
     import urllib.request
     import urllib.error
+    click.echo("[letswork] Starting MCP server...", err=True)
     for _ in range(20):
         try:
             urllib.request.urlopen(f"http://127.0.0.1:{port}/mcp", timeout=1)
@@ -85,61 +85,75 @@ def start(port):
             break  # Got an HTTP response — server is up
         except Exception:
             time.sleep(0.5)
+    else:
+        click.echo("[ERROR] MCP server did not start in time. Try again.", err=True)
+        stop_tunnel(tunnel_process)
+        return
+
+    click.echo(f"[letswork] MCP server running on port {port}", err=True)
 
     # Register letswork MCP for the host (needed for approvals)
+    click.echo("[letswork] Registering host MCP...", err=True)
     register_guest_mcp(mcp_url, host_token)
 
     # Open Claude Code in a new Terminal window
     launch_claude_code(project_root, url, host_token)
 
-    # Open chat window in a separate terminal (uses local URL for reliability)
-    launch_chat_window(f"http://127.0.0.1:{port}/mcp", host_token, "host", name, project_root)
-
-    # Print session info — share guest_token with collaborator
+    # Print session info
     click.echo("")
     click.echo("╔══════════════════════════════════════════════════╗")
     click.echo("║  🤝 LetsWork Session Active                      ║")
     click.echo("║                                                  ║")
-    click.echo(f"║  MCP URL: {mcp_url}")
-    click.echo(f"║  Token:   {guest_token}")
+    click.echo(f"║  URL:         {url}")
+    click.echo(f"║  Guest token: {guest_token}")
     click.echo("║                                                  ║")
-    click.echo("║  Share the URL + Token with your collaborator.   ║")
-    click.echo("║  Press Ctrl+C to stop the session.               ║")
+    click.echo("║  Share URL + Guest token with your collaborator. ║")
+    click.echo("║  Press Ctrl+C to stop.                           ║")
     click.echo("╚══════════════════════════════════════════════════╝")
     click.echo("")
 
+    if debug:
+        click.echo("[debug] Live activity log:")
+
+        def _log_event(event):
+            ts = event.timestamp.strftime("%H:%M:%S")
+            etype = event.event_type.value
+            click.echo(f"  [{ts}] {etype} — {event.data}")
+
+        event_log.on_event(_log_event)
+    else:
+        click.echo("Tip: run with --debug to see live tool activity.")
+        click.echo("")
+
     try:
         while True:
             time.sleep(1)
     except KeyboardInterrupt:
-        click.echo("\nShutting down...")
+        click.echo("\n[letswork] Shutting down...")
     finally:
         stop_tunnel(tunnel_process)
-        click.echo("Session ended.")
+        click.echo("[letswork] Session ended.")
 
 
 @cli.command()
 @click.argument("url")
-@click.option("--token", prompt="Enter session token", help="Secret token from the host")
+@click.option("--token", prompt="Enter session token", help="Guest token from the host")
 def join(url, token):
     """Join a LetsWork session as a guest."""
-    from letswork.launcher import register_guest_mcp, launch_guest_claude_code, launch_chat_window
-
-    name = click.prompt("What's your name?")
+    from letswork.launcher import register_guest_mcp, launch_guest_claude_code
 
     if not url.endswith("/mcp"):
-        url = url.rstrip("/") + "/mcp"
-
-    click.echo(f"\nConnecting to {url} as {name}...")
+        mcp_url = url.rstrip("/") + "/mcp"
+    else:
+        mcp_url = url
 
-    # Register MCP with Claude Code (via stdio proxy — reliable over Cloudflare)
-    register_guest_mcp(url, token)
+    click.echo(f"\n[letswork] Connecting to {mcp_url}...")
 
-    # Open Claude Code in a new Terminal window (banner shows token for reference)
-    launch_guest_claude_code(os.getcwd(), url, token)
+    # Register MCP with Claude Code (via stdio proxy)
+    register_guest_mcp(mcp_url, token)
 
-    # Open chat window in a separate terminal
-    launch_chat_window(url, token, "guest", name, os.getcwd())
+    # Open Claude Code in a new Terminal window
+    launch_guest_claude_code(os.getcwd(), mcp_url, token)
 
     click.echo("✅ Claude Code is opening with LetsWork MCP connected.")
     click.echo("   You can close this terminal.")

{letswork-2.0.0 → letswork-2.0.2}/letswork/launcher.py

@@ -74,8 +74,13 @@ def register_guest_mcp(url: str, token: str) -> None:
     Uses stdio transport (always works) rather than HTTP transport (unreliable
     over Cloudflare SSE). The proxy forwards tool calls to the host via HTTP.
     """
+    if not shutil.which("claude"):
+        print("⚠️  Claude Code not found. Install: npm install -g @anthropic-ai/claude-code")
+        return
+
     proxy_path = shutil.which("letswork-proxy")
     if not proxy_path:
+        print("⚠️  letswork-proxy not found. Try: pip install --upgrade letswork")
         return
 
     # Remove any stale entry from all scopes
@@ -105,22 +110,3 @@ def launch_guest_claude_code(project_root: str, url: str, token: str) -> None:
         print("Open a new terminal, cd to your project, and run: claude")
 
 
-def launch_chat_window(url: str, token: str, role: str, name: str, project_root: str) -> None:
-    """Open a new terminal window running the LetsWork chat window."""
-    args = (
-        f" --url {shlex.quote(url)}"
-        f" --token {shlex.quote(token)}"
-        f" --role {role}"
-        f" --name {shlex.quote(name)}"
-    )
-    # Prefer the installed script (resolves correctly when venv is active).
-    # Fall back to the Python that's running this process.
-    chat_bin = shutil.which("letswork-chat")
-    if chat_bin:
-        cmd = shlex.quote(chat_bin) + args
-    else:
-        python = shlex.quote(sys.executable)
-        cmd = f"{python} -m letswork.tui.chat_app{args}"
-    launched = _open_terminal(cmd, project_root)
-    if not launched:
-        print(f"Run in a new terminal: {cmd}")

letswork-2.0.2/letswork/proxy.py

@@ -0,0 +1,130 @@
+"""
+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.0 → letswork-2.0.2}/letswork/remote_client.py

@@ -111,14 +111,5 @@ class RemoteClient:
     def unlock_file(self, path: str) -> str:
         return self._call_tool("unlock_file", {"token": self.token, "path": path})
 
-    def register_name(self, display_name: str) -> str:
-        return self._call_tool("register_name", {"token": self.token, "display_name": display_name})
-
-    def send_message(self, message: str) -> str:
-        return self._call_tool("send_message", {"token": self.token, "message": message})
-
-    def get_events(self, since_index: int = 0) -> str:
-        return self._call_tool("get_events", {"token": self.token, "since_index": since_index})
-
     def get_status(self) -> str:
         return self._call_tool("get_status", {"token": self.token})

{letswork-2.0.0 → letswork-2.0.2}/letswork/server.py

@@ -37,6 +37,14 @@ def safe_resolve(path: str, root: str) -> str:
         raise ValueError("Access denied: path outside project directory")
     return resolved
 
+@app.tool()
+def ping(token: str) -> str:
+    if not check_auth(token):
+        raise ValueError("Unauthorized: invalid token")
+    user_id = get_user(token)
+    return f"pong — connected to {project_root} as {user_id}"
+
+
 @app.tool()
 def list_files(token: str, path: str = ".") -> str:
     if not check_auth(token):
@@ -207,43 +215,6 @@ def get_status(token: str) -> str:
     return "\n".join(status_lines)
 
 
-@app.tool()
-def register_name(token: str, display_name: str) -> str:
-    if not check_auth(token):
-        raise ValueError("Unauthorized: invalid token")
-    user_id = get_user(token)
-    token_to_user[token] = display_name
-    event_log.emit(EventType.CONNECTION, display_name, {})
-    return f"Registered as {display_name} (was {user_id})"
-
-
-@app.tool()
-def send_message(token: str, message: str) -> str:
-    if not check_auth(token):
-        raise ValueError("Unauthorized: invalid token")
-    user_id = get_user(token)
-    if not message.strip():
-        raise ValueError("Message cannot be empty")
-    event_log.emit(EventType.CHAT_MESSAGE, user_id, {"message": message})
-    return f"Message sent by {user_id}"
-
-
-@app.tool()
-def get_events(token: str, since_index: int = 0) -> str:
-    if not check_auth(token):
-        raise ValueError("Unauthorized: invalid token")
-    if since_index >= len(event_log._events):
-        return "no_new_events"
-    
-    new_events = event_log._events[since_index:]
-    result_lines = []
-    for event in new_events:
-        result_lines.append(event.message)
-        
-    result_lines.append(f"__INDEX__:{len(event_log._events)}")
-    return "\n".join(result_lines)
-
-
 @app.tool()
 def get_pending_changes(token: str) -> str:
     if not check_auth(token):

{letswork-2.0.0 → letswork-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "letswork"
-version = "2.0.0"
+version = "2.0.2"
 description = "Real-time collaborative coding via MCP — two developers, one codebase"
 readme = "README.md"
 license = "MIT"
@@ -13,14 +13,12 @@ authors = [{ name = "Sai Charan Rajoju" }]
 dependencies = [
     "mcp[cli]>=1.0.0",
     "click>=8.1.0",
-    "textual[syntax]>=0.50.0",
-    "websockets>=12.0"
+    "httpx>=0.27.0",
 ]
 
 [project.scripts]
 letswork = "letswork.cli:cli"
 letswork-proxy = "letswork.proxy:main"
-letswork-chat = "letswork.tui.chat_app:main"
 
 [tool.hatch.build.targets.wheel]
 packages = ["letswork"]

letswork-2.0.0/letswork/proxy.py

@@ -1,109 +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 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()