letswork 2.0.2__tar.gz → 2.0.4__tar.gz

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

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

{letswork-2.0.2 → letswork-2.0.4}/letswork/approval.py

@@ -25,6 +25,14 @@ class ApprovalQueue:
         self.project_root = project_root
         self._pending: dict[str, PendingChange] = {}
         self._history: list[PendingChange] = []
+        self._on_approved = None
+        self._on_rejected = None
+
+    def on_approved(self, callback) -> None:
+        self._on_approved = callback
+
+    def on_rejected(self, callback) -> None:
+        self._on_rejected = callback
 
     def submit(self, user_id: str, path: str, new_content: str) -> PendingChange:
         change_id = str(uuid.uuid4())[:8]
@@ -69,16 +77,20 @@ class ApprovalQueue:
         change.status = ApprovalStatus.APPROVED
         self._history.append(change)
         del self._pending[change_id]
+        if self._on_approved:
+            self._on_approved(change)
         return True
 
     def reject(self, change_id: str) -> bool:
         if change_id not in self._pending:
             return False
-            
+
         change = self._pending[change_id]
         change.status = ApprovalStatus.REJECTED
         self._history.append(change)
         del self._pending[change_id]
+        if self._on_rejected:
+            self._on_rejected(change)
         return True
 
     def get_pending(self) -> list[PendingChange]:

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

@@ -33,7 +33,19 @@ def start(port, debug):
 
     event_log = EventLog()
     server_module.event_log = event_log
-    server_module.approval_queue = ApprovalQueue(project_root)
+    approval_queue = ApprovalQueue(project_root)
+    server_module.approval_queue = approval_queue
+
+    def _on_approved(change):
+        event_log.emit(EventType.FILE_WRITE, change.user_id,
+                       {"path": change.path, "status": "approved"})
+
+    def _on_rejected(change):
+        event_log.emit(EventType.FILE_WRITE, change.user_id,
+                       {"path": change.path, "status": "rejected"})
+
+    approval_queue.on_approved(_on_approved)
+    approval_queue.on_rejected(_on_rejected)
 
     # Start tunnel
     try:
@@ -99,31 +111,53 @@ def start(port, debug):
     # Open Claude Code in a new Terminal window
     launch_claude_code(project_root, url, host_token)
 
+    join_cmd = f"letswork join {url} --token {guest_token}"
+
     # Print session info
     click.echo("")
-    click.echo("╔══════════════════════════════════════════════════╗")
-    click.echo("║  🤝 LetsWork Session Active                      ║")
-    click.echo("║                                                  ║")
-    click.echo(f"║  URL:         {url}")
-    click.echo(f"║  Guest token: {guest_token}")
-    click.echo("║                                                  ║")
-    click.echo("║  Share URL + Guest token with your collaborator. ║")
-    click.echo("║  Press Ctrl+C to stop.                           ║")
-    click.echo("╚══════════════════════════════════════════════════╝")
+    click.echo("╔══════════════════════════════════════════════════════════════════════╗")
+    click.echo("║  🤝 LetsWork Session Active                                          ║")
+    click.echo("║                                                                      ║")
+    click.echo("║  Send this command to your collaborator:                             ║")
+    click.echo(f"║  {join_cmd}")
+    click.echo("║                                                                      ║")
+    click.echo("║  Press Ctrl+C to stop.                                               ║")
+    click.echo("╚══════════════════════════════════════════════════════════════════════╝")
+    click.echo("")
+    click.echo("── Notifications ───────────────────────────────────────────────────────")
     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("")
+    # Always-on notifications — important events only
+    def _notify(event):
+        ts = event.timestamp.strftime("%H:%M:%S")
+        if event.event_type == EventType.FILE_WRITE:
+            status = event.data.get("status")
+            path = event.data.get("path", "?")
+            change_id = event.data.get("change_id", "")
+            user = event.user_id
+            if status == "pending_approval":
+                click.echo(f"  [{ts}] 📝 {user} submitted change to {path} (ID: {change_id})")
+                click.echo(f"         → run: get_pending_changes in Claude Code to review")
+            elif status == "approved":
+                click.echo(f"  [{ts}] ✅ Change to {path} approved and written to disk")
+            elif status == "rejected":
+                click.echo(f"  [{ts}] ❌ Change to {path} rejected")
+            else:
+                click.echo(f"  [{ts}] ✏️  {user} wrote {path}")
+        elif event.event_type == EventType.CONNECTION:
+            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}")
+
+    event_log.on_event(_notify)
 
     try:
         while True:

{letswork-2.0.2 → letswork-2.0.4}/letswork/events.py

@@ -10,8 +10,8 @@ class EventType(str, Enum):
     FILE_WRITE = "file_write"
     FILE_LOCK = "file_lock"
     FILE_UNLOCK = "file_unlock"
-    CHAT_MESSAGE = "chat_message"
     FILE_TREE_REQUEST = "file_tree_request"
+    PING = "ping"
     ERROR = "error"
 
 @dataclass
@@ -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.2 → letswork-2.0.4}/letswork/launcher.py

@@ -15,12 +15,12 @@ def _open_terminal(command: str, project_root: str) -> bool:
         return True
 
     if sys.platform.startswith("linux"):
-        # Try common Linux terminal emulators in order of preference
+        quoted = shlex.quote(project_root)
         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'"]),
+            ("gnome-terminal", ["--", "bash", "-c", f"cd {quoted} && {command}; exec bash"]),
+            ("xfce4-terminal", ["-e", f"bash -c 'cd {quoted} && {command}; exec bash'"]),
+            ("konsole", ["--noclose", "-e", "bash", "-c", f"cd {quoted} && {command}"]),
+            ("xterm", ["-e", f"bash -c 'cd {quoted} && {command}; exec bash'"]),
         ]:
             if shutil.which(term):
                 subprocess.Popen([term] + args)
@@ -107,6 +107,7 @@ def launch_guest_claude_code(project_root: str, url: str, token: str) -> None:
 
     launched = _open_terminal(_make_banner(url, token), project_root)
     if not launched:
-        print("Open a new terminal, cd to your project, and run: claude")
+        print(f"\n✅ MCP registered. Now open a new terminal and run:")
+        print(f"   cd {project_root} && claude")
 
 

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

@@ -42,11 +42,45 @@ def ping(token: str) -> str:
     if not check_auth(token):
         raise ValueError("Unauthorized: invalid token")
     user_id = get_user(token)
+    event_log.emit(EventType.PING, user_id, {})
     return f"pong — connected to {project_root} as {user_id}"
 
 
 @app.tool()
-def list_files(token: str, path: str = ".") -> str:
+def get_notifications(token: str) -> str:
+    """Returns a summary of what needs attention right now."""
+    if not check_auth(token):
+        raise ValueError("Unauthorized: invalid token")
+    user_id = get_user(token)
+    lines = []
+
+    if approval_queue is not None:
+        pending = approval_queue.get_pending()
+        if pending:
+            lines.append(f"⏳ {len(pending)} change(s) pending approval:")
+            for change in pending:
+                lines.append(f"   • [{change.id}] {change.path} — submitted by {change.user_id}")
+            if user_id == "host":
+                lines.append("   → use approve_change or reject_change to action them")
+            else:
+                lines.append("   → waiting for host to review")
+        else:
+            lines.append("✅ No pending changes")
+
+    locks = lock_manager.get_locks()
+    if locks:
+        lines.append(f"🔒 {len(locks)} active lock(s):")
+        for path, holder in sorted(locks.items()):
+            lines.append(f"   • {path} — locked by {holder}")
+
+    if not lines:
+        lines.append("✅ All clear — nothing needs attention")
+
+    return "\n".join(lines)
+
+
+@app.tool()
+def list_files(token: str, path: str = ".", recursive: bool = False) -> str:
     if not check_auth(token):
         raise ValueError("Unauthorized: invalid token")
     user_id = get_user(token)
@@ -59,28 +93,34 @@ def list_files(token: str, path: str = ".") -> str:
 
     if not os.path.exists(resolved_path):
         raise ValueError(f"Path not found: {path}")
-
     if not os.path.isdir(resolved_path):
         raise ValueError(f"Not a directory: {path}")
-        
-    listing = os.listdir(resolved_path)
-    listing.sort()
-    
-    if not listing:
-        return "Directory is empty"
-        
+
     result_lines = []
-    for entry in listing:
-        full_entry_path = os.path.join(resolved_path, entry)
-        relative_path = os.path.relpath(full_entry_path, project_root)
-        entry_type = "[dir]" if os.path.isdir(full_entry_path) else "[file]"
-        
-        is_locked, holder = lock_manager.is_locked(relative_path)
-        lock_info = f" [locked by {holder}]" if is_locked else ""
-        
-        result_lines.append(f"{entry_type} {relative_path}{lock_info}")
-        
-    return "\n".join(result_lines)
+
+    if recursive:
+        for root_dir, dirs, files in os.walk(resolved_path):
+            # Skip hidden dirs and common noise
+            dirs[:] = sorted(d for d in dirs if not d.startswith(".") and d not in ("__pycache__", "node_modules", ".venv", "venv"))
+            for fname in sorted(files):
+                if fname.startswith("."):
+                    continue
+                full = os.path.join(root_dir, fname)
+                rel = os.path.relpath(full, project_root)
+                is_locked, holder = lock_manager.is_locked(rel)
+                lock_info = f" [locked by {holder}]" if is_locked else ""
+                result_lines.append(f"[file] {rel}{lock_info}")
+    else:
+        listing = sorted(os.listdir(resolved_path))
+        for entry in listing:
+            full_entry_path = os.path.join(resolved_path, entry)
+            relative_path = os.path.relpath(full_entry_path, project_root)
+            entry_type = "[dir]" if os.path.isdir(full_entry_path) else "[file]"
+            is_locked, holder = lock_manager.is_locked(relative_path)
+            lock_info = f" [locked by {holder}]" if is_locked else ""
+            result_lines.append(f"{entry_type} {relative_path}{lock_info}")
+
+    return "\n".join(result_lines) if result_lines else "Directory is empty"
 
 
 @app.tool()
@@ -203,18 +243,45 @@ def get_status(token: str) -> str:
         raise ValueError("Unauthorized: invalid token")
     status_lines = []
     status_lines.append(f"Project root: {project_root}")
-    
+
+    users = list(set(token_to_user.values()))
+    status_lines.append(f"Connected users: {', '.join(users) if users else 'none'}")
+
     locks = lock_manager.get_locks()
     if not locks:
         status_lines.append("Active locks: none")
     else:
         status_lines.append("Active locks:")
-        for path, user_id in sorted(locks.items()):
-            status_lines.append(f"  {path} — locked by {user_id}")
-            
+        for path, uid in sorted(locks.items()):
+            status_lines.append(f"  {path} — locked by {uid}")
+
+    if approval_queue is not None:
+        pending = approval_queue.get_pending()
+        if pending:
+            status_lines.append(f"Pending approvals: {len(pending)}")
+            for change in pending:
+                status_lines.append(f"  [{change.id}] {change.path} by {change.user_id}")
+
     return "\n".join(status_lines)
 
 
+@app.tool()
+def my_pending_changes(token: str) -> str:
+    """Show only your own pending changes awaiting approval."""
+    if not check_auth(token):
+        raise ValueError("Unauthorized: invalid token")
+    user_id = get_user(token)
+    if approval_queue is None:
+        return "No approval system active"
+    pending = [c for c in approval_queue.get_pending() if c.user_id == user_id]
+    if not pending:
+        return "You have no pending changes"
+    lines = [f"{len(pending)} change(s) pending approval:"]
+    for change in pending:
+        lines.append(f"  [{change.id}] {change.path}")
+    return "\n".join(lines)
+
+
 @app.tool()
 def get_pending_changes(token: str) -> str:
     if not check_auth(token):

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

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