letswork 0.1.3__tar.gz → 2.0.0__tar.gz

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

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

letswork-2.0.0/letswork/cli.py

@@ -0,0 +1,159 @@
+import os
+import time
+import click
+import threading
+import letswork.server as server_module
+from letswork.auth import generate_token
+from letswork.tunnel import start_tunnel, stop_tunnel
+
+
+@click.group()
+def cli():
+    """LetsWork — real-time collaborative coding via MCP."""
+    pass
+
+
+@cli.command()
+@click.option("--port", default=8000, type=int, help="Port for the MCP server")
+def start(port):
+    """Start a LetsWork collaboration session."""
+    from letswork.events import EventLog
+    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?")
+
+    project_root = os.getcwd()
+    server_module.project_root = project_root
+
+    host_token = generate_token()
+    guest_token = generate_token()
+    server_module.register_user(host_token, "host")
+    server_module.register_user(guest_token, "guest")
+
+    server_module.event_log = EventLog()
+    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}")
+        return
+
+    mcp_url = f"{url}/mcp"
+
+    # Silence MCP and uvicorn loggers before server starts
+    import logging
+    for _name in ("uvicorn", "uvicorn.access", "uvicorn.error", "mcp", "mcp.server",
+                  "mcp.server.streamable_http", "asyncio"):
+        logging.getLogger(_name).setLevel(logging.CRITICAL)
+
+    # Disable DNS rebinding protection so Cloudflare tunnel host header is accepted
+    if (hasattr(server_module.app.settings, "transport_security")
+            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.
+    def run_server():
+        import anyio
+        import uvicorn
+
+        async def _serve():
+            starlette_app = server_module.app.streamable_http_app()
+            config = uvicorn.Config(
+                starlette_app,
+                host="127.0.0.1",
+                port=port,
+                log_config=None,
+                log_level="critical",
+            )
+            await uvicorn.Server(config).serve()
+
+        anyio.run(_serve)
+
+    threading.Thread(target=run_server, daemon=True).start()
+
+    # Wait until the server is actually responding (any HTTP response means it's up)
+    import urllib.request
+    import urllib.error
+    for _ in range(20):
+        try:
+            urllib.request.urlopen(f"http://127.0.0.1:{port}/mcp", timeout=1)
+        except urllib.error.HTTPError:
+            break  # Got an HTTP response — server is up
+        except Exception:
+            time.sleep(0.5)
+
+    # Register letswork MCP for the host (needed for approvals)
+    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
+    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("║                                                  ║")
+    click.echo("║  Share the URL + Token with your collaborator.   ║")
+    click.echo("║  Press Ctrl+C to stop the session.               ║")
+    click.echo("╚══════════════════════════════════════════════════╝")
+    click.echo("")
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        click.echo("\nShutting down...")
+    finally:
+        stop_tunnel(tunnel_process)
+        click.echo("Session ended.")
+
+
+@cli.command()
+@click.argument("url")
+@click.option("--token", prompt="Enter session token", help="Secret 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?")
+
+    if not url.endswith("/mcp"):
+        url = url.rstrip("/") + "/mcp"
+
+    click.echo(f"\nConnecting to {url} as {name}...")
+
+    # Register MCP with Claude Code (via stdio proxy — reliable over Cloudflare)
+    register_guest_mcp(url, token)
+
+    # Open Claude Code in a new Terminal window (banner shows token for reference)
+    launch_guest_claude_code(os.getcwd(), url, token)
+
+    # Open chat window in a separate terminal
+    launch_chat_window(url, token, "guest", name, os.getcwd())
+
+    click.echo("✅ Claude Code is opening with LetsWork MCP connected.")
+    click.echo("   You can close this terminal.")
+
+
+@cli.command()
+def stop():
+    click.echo("Use Ctrl+C in the terminal running 'letswork start' to stop.")
+
+
+@cli.command()
+def status():
+    click.echo("Use the get_status MCP tool inside Claude Code to check session status.")
+
+
+if __name__ == "__main__":
+    cli()

letswork-2.0.0/letswork/launcher.py

@@ -0,0 +1,126 @@
+import shlex
+import subprocess
+import shutil
+import sys
+
+
+def _open_terminal(command: str, project_root: str) -> bool:
+    """
+    Open a new terminal window running `command` in `project_root`.
+    Returns True if a terminal was launched, False if we fell back to printing.
+    """
+    if sys.platform == "darwin":
+        script = f'tell application "Terminal" to do script "cd {shlex.quote(project_root)} && {command}"'
+        subprocess.Popen(["osascript", "-e", script])
+        return True
+
+    if sys.platform.startswith("linux"):
+        # Try common Linux terminal emulators in order of preference
+        for term, args in [
+            ("gnome-terminal", ["--", "bash", "-c", f"cd {project_root} && {command}; exec bash"]),
+            ("xfce4-terminal", ["-e", f"bash -c 'cd {project_root} && {command}; exec bash'"]),
+            ("konsole", ["--noclose", "-e", "bash", "-c", f"cd {project_root} && {command}"]),
+            ("xterm", ["-e", f"bash -c 'cd {project_root} && {command}; exec bash'"]),
+        ]:
+            if shutil.which(term):
+                subprocess.Popen([term] + args)
+                return True
+        return False
+
+    if sys.platform == "win32":
+        # Windows Terminal (wt) or fallback to cmd
+        if shutil.which("wt"):
+            subprocess.Popen(["wt", "new-tab", "--title", "LetsWork",
+                              "cmd", "/k", f"cd /d {project_root} && {command}"])
+        else:
+            subprocess.Popen(["cmd", "/c", "start", "cmd", "/k",
+                              f"cd /d {project_root} && {command}"])
+        return True
+
+    return False
+
+
+def _make_banner(mcp_url: str, token: str) -> str:
+    """Shell command that prints the LetsWork banner then launches claude."""
+    return (
+        f"clear && "
+        f"echo '╔══════════════════════════════════════════════════╗' && "
+        f"echo '║  Claude Code — Connected to LetsWork             ║' && "
+        f"echo '║                                                  ║' && "
+        f"echo '║  MCP URL: {mcp_url}' && "
+        f"echo '║  Token:   {token}' && "
+        f"echo '║                                                  ║' && "
+        f"echo '║  Try: list_files, read_file, write_file          ║' && "
+        f"echo '╚══════════════════════════════════════════════════╝' && "
+        f"echo '' && claude"
+    )
+
+
+def launch_claude_code(project_root: str, tunnel_url: str, token: str) -> None:
+    """Open a new terminal window with Claude Code for the host."""
+    if not shutil.which("claude"):
+        print("⚠️  Claude Code not found. Install: npm install -g @anthropic-ai/claude-code")
+        return
+
+    mcp_url = f"{tunnel_url}/mcp"
+    launched = _open_terminal(_make_banner(mcp_url, token), project_root)
+    if not launched:
+        print("Open a new terminal, cd to your project, and run: claude")
+
+
+def register_guest_mcp(url: str, token: str) -> None:
+    """Register LetsWork as a stdio proxy MCP with Claude Code (blocking).
+
+    Uses stdio transport (always works) rather than HTTP transport (unreliable
+    over Cloudflare SSE). The proxy forwards tool calls to the host via HTTP.
+    """
+    proxy_path = shutil.which("letswork-proxy")
+    if not proxy_path:
+        return
+
+    # Remove any stale entry from all scopes
+    for scope in ("user", "local", "project"):
+        subprocess.run(
+            ["claude", "mcp", "remove", "letswork", "--scope", scope],
+            check=False, capture_output=True, text=True,
+        )
+    subprocess.run(
+        [
+            "claude", "mcp", "add", "letswork",
+            "--scope", "user",
+            "--", proxy_path, "--url", url, "--token", token,
+        ],
+        check=False, capture_output=True, text=True,
+    )
+
+
+def launch_guest_claude_code(project_root: str, url: str, token: str) -> None:
+    """Open a new terminal window with Claude Code for the guest."""
+    if not shutil.which("claude"):
+        print("⚠️  Claude Code not found. Install: npm install -g @anthropic-ai/claude-code")
+        return
+
+    launched = _open_terminal(_make_banner(url, token), project_root)
+    if not launched:
+        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.0/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-0.1.3 → letswork-2.0.0}/letswork/remote_client.py

@@ -3,10 +3,14 @@ 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, 
+    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
@@ -15,44 +19,57 @@ class RemoteClient:
         self._loop: asyncio.AbstractEventLoop | None = None
         self._thread: threading.Thread | None = None
         self._connected = False
-        self._read_stream = None
-        self._write_stream = None
-        self._cm_exit = None
-        
+        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()
-        error_event = threading.Event()
-        
+
         async def _run_loop():
-            try:
-                async with streamablehttp_client(self.mcp_url) as (read, write, _session_id):
-                    self._read_stream = read
-                    self._write_stream = write
-                    async with ClientSession(read, write) as session:
-                        await session.initialize()
-                        self._session = session
-                        self._connected = True
+            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()
-                        while self._connected:
-                            await asyncio.sleep(0.1)
-            except Exception as e:
-                self._connected = False
-                error_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)
-        if error_event.is_set() or not ready_event.is_set():
-            return False
-        return True
+        return self._connected
 
     def disconnect(self):
+        self._should_run = False
         self._connected = False
         if self._thread:
             self._thread.join(timeout=5)
@@ -94,6 +111,9 @@ 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})
 

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

@@ -9,19 +9,20 @@ app = FastMCP("letswork")
 lock_manager = LockManager()
 event_log = EventLog()
 approval_queue: ApprovalQueue | None = None
-session_token: str = ""
+valid_tokens: set[str] = set()
 project_root: str = ""
 token_to_user: dict[str, str] = {}
 
 
 def check_auth(provided_token: str) -> bool:
-    """Validates a provided token against the session token. Returns False if invalid."""
-    return validate_token(provided_token, session_token)
+    """Validates a provided token against all registered tokens."""
+    return any(validate_token(provided_token, t) for t in valid_tokens)
 
 
 def register_user(token: str, user_id: str) -> None:
-    """Associate a token with a user_id."""
+    """Associate a token with a user_id and mark it as valid."""
     token_to_user[token] = user_id
+    valid_tokens.add(token)
 
 
 def get_user(token: str) -> str:
@@ -206,6 +207,16 @@ 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):

letswork-2.0.0/letswork/tui/chat_app.py

@@ -0,0 +1,145 @@
+"""Standalone LetsWork chat window — simple Textual UI."""
+import argparse
+import threading
+
+from textual.app import App, ComposeResult
+from textual.widgets import Header, Footer, RichLog, Input
+
+from letswork.remote_client import RemoteClient
+
+
+class ChatApp(App):
+    TITLE = "LetsWork Chat"
+    CSS = """
+    Screen { layout: vertical; }
+    #messages {
+        height: 1fr;
+        border: solid $accent;
+        padding: 0 1;
+    }
+    #chat-input { height: 3; dock: bottom; }
+    """
+    BINDINGS = [("ctrl+q", "quit", "Quit")]
+
+    def __init__(self, url: str, token: str, role: str, name: str, **kwargs):
+        super().__init__(**kwargs)
+        self.url = url
+        self.token = token
+        self.role = role.lower()
+        self.display_name = name
+        self._client = RemoteClient(url, token)
+        self._connected = False
+        self._last_index = 0
+        self._poll_in_progress = False
+
+    @property
+    def role_label(self) -> str:
+        return "HOST" if self.role == "host" else "GUEST"
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        yield RichLog(id="messages", markup=True, wrap=True)
+        yield Input(
+            placeholder=f"[{self.role_label}] {self.display_name}: type here and press Enter",
+            id="chat-input",
+        )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.sub_title = f"[{self.role_label}] {self.display_name}"
+        log = self.query_one("#messages", RichLog)
+        log.write("[bold]─── LetsWork Chat ──────────────────────────────────────────[/bold]")
+        threading.Thread(target=self._connect, daemon=True).start()
+
+    def _connect(self) -> None:
+        self._connected = self._client.connect()
+        if self._connected:
+            self._client.register_name(self.display_name)
+
+        def _update():
+            log = self.query_one("#messages", RichLog)
+            if self._connected:
+                log.write("[dim]connected — start chatting[/dim]")
+                self.set_interval(1.0, self._poll)
+            else:
+                log.write("[bold red]❌ Failed to connect to MCP server[/bold red]")
+
+        self.call_from_thread(_update)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        text = event.value.strip()
+        if not text or not self._connected:
+            return
+        msg = f"[{self.role_label}] {self.display_name}: {text}"
+        event.input.value = ""
+        threading.Thread(target=self._send, args=(msg,), daemon=True).start()
+
+    def _send(self, message: str) -> None:
+        self._client.send_message(message)
+
+    def _poll(self) -> None:
+        if self._poll_in_progress:
+            return
+        self._poll_in_progress = True
+        threading.Thread(target=self._fetch_events, daemon=True).start()
+
+    def _fetch_events(self) -> None:
+        try:
+            result = self._client.get_events(self._last_index)
+            if not result or result == "no_new_events" or result.startswith("Error"):
+                return
+
+            lines = result.strip().split("\n")
+            new_index = self._last_index
+            chat_lines = []
+
+            for line in lines:
+                if line.startswith("__INDEX__:"):
+                    try:
+                        new_index = int(line.split(":", 1)[1])
+                    except (ValueError, IndexError):
+                        pass
+                elif "💬" in line:
+                    # Format: "[HH:MM:SS] 💬 user_id: [ROLE] Name: text"
+                    try:
+                        after_emoji = line.split("💬 ", 1)[1]    # "user_id: [ROLE] Name: text"
+                        content = after_emoji.split(": ", 1)[1]   # "[ROLE] Name: text"
+                        if content.startswith("[HOST]"):
+                            chat_lines.append(f"  [bold blue]{content}[/bold blue]")
+                        elif content.startswith("[GUEST]"):
+                            chat_lines.append(f"  [bold green]{content}[/bold green]")
+                        else:
+                            chat_lines.append(f"  {content}")
+                    except (IndexError, ValueError):
+                        pass
+
+            def _update():
+                self._last_index = new_index
+                if chat_lines:
+                    log = self.query_one("#messages", RichLog)
+                    for line in chat_lines:
+                        log.write(line)
+
+            self.call_from_thread(_update)
+        except Exception:
+            pass
+        finally:
+            self._poll_in_progress = False
+
+    def action_quit(self) -> None:
+        self._client.disconnect()
+        self.exit()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="LetsWork Chat Window")
+    parser.add_argument("--url", required=True, help="MCP server URL")
+    parser.add_argument("--token", required=True, help="Session token")
+    parser.add_argument("--role", required=True, choices=["host", "guest"])
+    parser.add_argument("--name", required=True, help="Your display name")
+    args = parser.parse_args()
+    ChatApp(url=args.url, token=args.token, role=args.role, name=args.name).run()
+
+
+if __name__ == "__main__":
+    main()

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "letswork"
-version = "0.1.3"
+version = "2.0.0"
 description = "Real-time collaborative coding via MCP — two developers, one codebase"
 readme = "README.md"
 license = "MIT"
@@ -19,6 +19,8 @@ dependencies = [
 
 [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-0.1.3/letswork/cli.py

@@ -1,162 +0,0 @@
-import os
-import click
-import letswork.server as server_module
-from letswork.auth import generate_token
-from letswork.tunnel import start_tunnel, stop_tunnel
-
-
-@click.group()
-def cli():
-    """LetsWork — real-time collaborative coding via MCP."""
-    pass
-
-
-@cli.command()
-@click.option("--port", default=8000, type=int, help="Port for the MCP server")
-def start(port):
-    """Start a LetsWork collaboration session."""
-    import threading
-    from letswork.events import EventLog
-    from letswork.launcher import launch_with_claude_code
-
-    # Set up project root
-    project_root = os.getcwd()
-    server_module.project_root = project_root
-
-    # Generate token and register host
-    token = generate_token()
-    server_module.session_token = token
-    server_module.register_user(token, "host")
-
-    # Set up event log
-    event_log = EventLog()
-    server_module.event_log = event_log
-
-    # Set up approval queue
-    from letswork.approval import ApprovalQueue
-    approval_queue = ApprovalQueue(project_root)
-    server_module.approval_queue = approval_queue
-
-    # Start tunnel
-    try:
-        url, tunnel_process = start_tunnel(port)
-    except RuntimeError as e:
-        click.echo(f"Error: {e}")
-        return
-
-    # Print session info
-    click.echo("")
-    click.echo("╔══════════════════════════════════════════════════╗")
-    click.echo("║  LetsWork Session Active                        ║")
-    click.echo("║                                                 ║")
-    click.echo(f"║  URL:   {url}/mcp")
-    click.echo(f"║  Token: {token}")
-    click.echo("║                                                 ║")
-    click.echo("║  Share both with your collaborator.             ║")
-    click.echo("╚══════════════════════════════════════════════════╝")
-    click.echo("")
-
-    # Suppress uvicorn access logs before server starts
-    import logging
-    for _log_name in ("uvicorn", "uvicorn.access", "uvicorn.error", "uvicorn.asgi"):
-        _l = logging.getLogger(_log_name)
-        _l.setLevel(logging.CRITICAL)
-        _l.propagate = False
-    logging.getLogger("httpx").setLevel(logging.CRITICAL)
-
-    # Start MCP server in a background thread
-    def run_server():
-        import logging as _logging
-        import uvicorn.config as _uvc
-
-        # Replace the entire logging config so uvicorn installs no console handlers
-        _uvc.LOGGING_CONFIG = {
-            "version": 1,
-            "disable_existing_loggers": False,
-            "handlers": {
-                "null": {"class": "logging.NullHandler"},
-            },
-            "loggers": {
-                "uvicorn": {"handlers": ["null"], "level": "CRITICAL", "propagate": False},
-                "uvicorn.error": {"handlers": ["null"], "level": "CRITICAL", "propagate": False},
-                "uvicorn.access": {"handlers": ["null"], "level": "CRITICAL", "propagate": False},
-            },
-        }
-
-        server_module.app.settings.host = "127.0.0.1"
-        server_module.app.settings.port = port
-        server_module.app.settings.stateless_http = True
-        if hasattr(server_module.app.settings, "transport_security") and server_module.app.settings.transport_security:
-            server_module.app.settings.transport_security.enable_dns_rebinding_protection = False
-        server_module.app.run(transport="streamable-http")
-
-    server_thread = threading.Thread(target=run_server, daemon=True)
-    server_thread.start()
-
-    # Give server a moment to start
-    import time
-    time.sleep(2)
-
-    # Launch tmux split with TUI + Claude Code
-    try:
-        launch_with_claude_code(project_root, url, token, port)
-    except KeyboardInterrupt:
-        click.echo("\nShutting down...")
-    finally:
-        stop_tunnel(tunnel_process)
-        click.echo("Session ended.")
-
-
-@cli.command()
-@click.argument("url")
-@click.option("--token", prompt="Enter session token", help="Secret token from the host")
-@click.option("--user", default="guest", help="Your username")
-def join(url, token, user):
-    """Join a LetsWork session as a guest."""
-    if not url.endswith("/mcp"):
-        url = url.rstrip("/") + "/mcp"
-    from letswork.events import EventLog
-    from letswork.filelock import LockManager
-    from letswork.tui.app import LetsWorkApp
-    from letswork.launcher import launch_guest_claude_code
-
-    click.echo(f"Connecting to {url}...")
-    click.echo(f"User: {user}")
-    click.echo("")
-
-    # Guest TUI uses a local event log for display
-    event_log = EventLog()
-    lock_manager = LockManager()
-    
-    # Guest doesn't have local project root — use a temp dir
-    # Files are accessed remotely through MCP tools
-    project_root = os.getcwd()
-
-    launch_guest_claude_code(url, token)
-
-    app = LetsWorkApp(
-        project_root=project_root,
-        lock_manager=lock_manager,
-        event_log=event_log,
-        approval_queue=None,
-        guest_mode=True,
-        mcp_url=url,
-        mcp_token=token,
-        user_id=user,
-    )
-    app.run()
-
-
-@cli.command()
-def stop():
-    click.echo("In v1, use Ctrl+C in the terminal running 'letswork start' to stop the session.")
-
-
-@cli.command()
-def status():
-    click.echo("In v1, use the get_status MCP tool to check session status.")
-    click.echo("A standalone status command will be available in v2.")
-
-
-if __name__ == "__main__":
-    cli()

letswork-0.1.3/letswork/launcher.py

@@ -1,55 +0,0 @@
-import subprocess
-import shutil
-import sys
-
-
-def launch_with_claude_code(project_root: str, tunnel_url: str, token: str, port: int) -> None:
-    """Open a new Terminal tab with Claude Code, then launch TUI in current terminal."""
-
-    if sys.platform == "darwin":
-        # Mac: open new Terminal tab with Claude Code
-        claude_path = shutil.which("claude")
-        if claude_path:
-            apple_script = f'''
-            tell application "Terminal"
-                activate
-                do script "cd {project_root} && clear && echo '╔══════════════════════════════════════════════════╗' && echo '║  🤖 Claude Code — Connected to LetsWork          ║' && echo '║                                                  ║' && echo '║  MCP URL: {tunnel_url}/mcp' && echo '║  Token: {token}' && echo '║                                                  ║' && echo '║  Try: list_files, read_file, write_file           ║' && echo '╚══════════════════════════════════════════════════╝' && echo '' && claude"
-            end tell
-            '''
-            subprocess.Popen(["osascript", "-e", apple_script])
-        else:
-            print("⚠️  Claude Code not found. Install with: npm install -g @anthropic-ai/claude-code")
-            print("   Open a second terminal and run: claude")
-    else:
-        # Linux/Windows: just print instructions
-        print("Open a second terminal and run:")
-        print(f"  cd {project_root}")
-        print("  claude")
-        print("Claude Code will connect to your LetsWork MCP server automatically.")
-
-    # Launch TUI in current terminal
-    import letswork.server as server_module
-    from letswork.tui.app import LetsWorkApp
-
-    app = LetsWorkApp(
-        project_root=project_root,
-        lock_manager=server_module.lock_manager,
-        event_log=server_module.event_log,
-        approval_queue=server_module.approval_queue,
-    )
-    app.run()
-
-
-def launch_guest_claude_code(url: str, token: str) -> None:
-    import threading
-
-    def _configure():
-        subprocess.run(
-            ["claude", "mcp", "add", "letswork", "--transport", "http", url],
-            check=False,
-            capture_output=True,
-            text=True,
-        )
-
-    threading.Thread(target=_configure, daemon=True).start()
-