muse-cli 0.3.2__tar.gz → 0.3.4__tar.gz

{muse_cli-0.3.2 → muse_cli-0.3.4}/.gitignore

@@ -14,3 +14,6 @@ config.json
 
 # OS
 .DS_Store
+
+# Firebase local cache
+.firebase/

{muse_cli-0.3.2 → muse_cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: muse-cli
-Version: 0.3.2
+Version: 0.3.4
 Summary: Command-line client for your personal muse.ai AI agent: chat, automate, and manage side chats, feed, goals, ideas, and sessions from the terminal. No browser needed.
 Project-URL: Homepage, https://github.com/nikships/muse-cli
 Project-URL: Documentation, https://github.com/nikships/muse-cli#readme
@@ -46,11 +46,12 @@ Talk to your personal muse.ai AI agent from the terminal.
 [![Downloads](https://img.shields.io/pepy/dt/muse-cli?style=for-the-badge)](https://pepy.tech/project/muse-cli)
 [![License: MIT](https://img.shields.io/github/license/nikships/muse-cli?style=for-the-badge)](https://github.com/nikships/muse-cli/blob/main/LICENSE)
 [![GitHub stars](https://img.shields.io/github/stars/nikships/muse-cli?style=for-the-badge)](https://github.com/nikships/muse-cli/stargazers)
-
-![muse-cli hero](https://raw.githubusercontent.com/nikships/muse-cli/main/assets/hero.webp)
+[![Website](https://img.shields.io/badge/website-live-3fb950?style=for-the-badge)](https://muse-cli-site.web.app)
 
 </div>
 
+https://github.com/user-attachments/assets/8c9aefe8-c5a4-4e4b-9393-48e2325f99a9
+
 ## What is this?
 
 A command-line client for your personal muse.ai AI agent: chat from the terminal, automate it with scripts, and manage side chats, feed, goals, ideas, and sessions without opening a browser. It speaks the app's own gateway protocol directly: HTTPS auth, then an encrypted Noise-XX WebSocket to your personal VM.
@@ -60,6 +61,14 @@ A command-line client for your personal muse.ai AI agent: chat from the terminal
 - **Full coverage:** named commands for the common tasks, plus a `raw` escape hatch for all 258 gateway methods.
 - **Agent-ready:** ships an agent skill so coding agents can drive your muse.ai agent for you.
 
+## Agents driving agents
+
+Prompt a coding agent, it activates the muse-cli skill and runs read-only
+commands for you. Live session below: a Droid worker runs `muse-cli status`
+and `muse-cli goals`, then reports back.
+
+![Droid agent using muse-cli to check status and goals](https://raw.githubusercontent.com/nikships/muse-cli/main/assets/demo-agent.png)
+
 ## Quick Start
 
 ```bash
@@ -188,11 +197,17 @@ muse-cli status
 ## Usage
 
 ```bash
+muse-cli                                          # interactive chat (same as `muse-cli chat`)
 muse-cli threads                                  # main chat + side chats
 muse-cli history --limit 5                        # recent messages
 muse-cli history --thread <session-id> --limit 5  # one side chat
 muse-cli send "summarize my unread" --wait 120    # send + wait for the reply
 muse-cli watch --timeout 60                       # tail live agent events
+muse-cli files --limit 20                         # images/videos in recent messages
+muse-cli download <seq|message-id|sandbox://...> -o ./out   # save agent-made files
+muse-cli history --limit 3 --download ./out       # save files from these messages
+muse-cli send "make a cat video" --wait 300 --download ./out
+muse-cli watch --thread <session-id>              # tail one side chat
 
 muse-cli feed --limit 5
 muse-cli feed-react <unit-id> love
@@ -208,7 +223,11 @@ muse-cli wake
 muse-cli raw <method> --body '{}'                 # escape hatch: any of 258 gateway methods
 ```
 
-Every command prints JSON. Your VM is auto-discovered from your session, and a
+The interactive chat prints plain text, one message per line, so it works well
+with screen readers. It resumes the conversation you used last; type `/help`
+inside it for `/chats`, `/open N`, `/main`, `/new`, `/history`, and `/login`.
+
+Every other command prints JSON. Your VM is auto-discovered from your session, and a
 random device id is generated on first run.
 
 Pipe it into other tools:
@@ -242,6 +261,7 @@ found during reverse engineering.
 git clone https://github.com/nikships/muse-cli.git
 cd muse-cli
 uv run muse-cli --help
+uv run python -m unittest discover -s tests   # unit tests (no network)
 ```
 
 ```

{muse_cli-0.3.2 → muse_cli-0.3.4}/README.md

@@ -9,11 +9,12 @@ Talk to your personal muse.ai AI agent from the terminal.
 [![Downloads](https://img.shields.io/pepy/dt/muse-cli?style=for-the-badge)](https://pepy.tech/project/muse-cli)
 [![License: MIT](https://img.shields.io/github/license/nikships/muse-cli?style=for-the-badge)](https://github.com/nikships/muse-cli/blob/main/LICENSE)
 [![GitHub stars](https://img.shields.io/github/stars/nikships/muse-cli?style=for-the-badge)](https://github.com/nikships/muse-cli/stargazers)
-
-![muse-cli hero](https://raw.githubusercontent.com/nikships/muse-cli/main/assets/hero.webp)
+[![Website](https://img.shields.io/badge/website-live-3fb950?style=for-the-badge)](https://muse-cli-site.web.app)
 
 </div>
 
+https://github.com/user-attachments/assets/8c9aefe8-c5a4-4e4b-9393-48e2325f99a9
+
 ## What is this?
 
 A command-line client for your personal muse.ai AI agent: chat from the terminal, automate it with scripts, and manage side chats, feed, goals, ideas, and sessions without opening a browser. It speaks the app's own gateway protocol directly: HTTPS auth, then an encrypted Noise-XX WebSocket to your personal VM.
@@ -23,6 +24,14 @@ A command-line client for your personal muse.ai AI agent: chat from the terminal
 - **Full coverage:** named commands for the common tasks, plus a `raw` escape hatch for all 258 gateway methods.
 - **Agent-ready:** ships an agent skill so coding agents can drive your muse.ai agent for you.
 
+## Agents driving agents
+
+Prompt a coding agent, it activates the muse-cli skill and runs read-only
+commands for you. Live session below: a Droid worker runs `muse-cli status`
+and `muse-cli goals`, then reports back.
+
+![Droid agent using muse-cli to check status and goals](https://raw.githubusercontent.com/nikships/muse-cli/main/assets/demo-agent.png)
+
 ## Quick Start
 
 ```bash
@@ -151,11 +160,17 @@ muse-cli status
 ## Usage
 
 ```bash
+muse-cli                                          # interactive chat (same as `muse-cli chat`)
 muse-cli threads                                  # main chat + side chats
 muse-cli history --limit 5                        # recent messages
 muse-cli history --thread <session-id> --limit 5  # one side chat
 muse-cli send "summarize my unread" --wait 120    # send + wait for the reply
 muse-cli watch --timeout 60                       # tail live agent events
+muse-cli files --limit 20                         # images/videos in recent messages
+muse-cli download <seq|message-id|sandbox://...> -o ./out   # save agent-made files
+muse-cli history --limit 3 --download ./out       # save files from these messages
+muse-cli send "make a cat video" --wait 300 --download ./out
+muse-cli watch --thread <session-id>              # tail one side chat
 
 muse-cli feed --limit 5
 muse-cli feed-react <unit-id> love
@@ -171,7 +186,11 @@ muse-cli wake
 muse-cli raw <method> --body '{}'                 # escape hatch: any of 258 gateway methods
 ```
 
-Every command prints JSON. Your VM is auto-discovered from your session, and a
+The interactive chat prints plain text, one message per line, so it works well
+with screen readers. It resumes the conversation you used last; type `/help`
+inside it for `/chats`, `/open N`, `/main`, `/new`, `/history`, and `/login`.
+
+Every other command prints JSON. Your VM is auto-discovered from your session, and a
 random device id is generated on first run.
 
 Pipe it into other tools:
@@ -205,6 +224,7 @@ found during reverse engineering.
 git clone https://github.com/nikships/muse-cli.git
 cd muse-cli
 uv run muse-cli --help
+uv run python -m unittest discover -s tests   # unit tests (no network)
 ```
 
 ```

{muse_cli-0.3.2 → muse_cli-0.3.4}/docs/PROTOCOL.md

@@ -68,6 +68,13 @@ chat / feed / goals / ideas / sessions / ...
   the stateful Noise decrypt (fatal BAD_DECRYPT). `Gateway` serializes
   receives with a lock as a backstop, but callers must still keep exactly
   one frame consumer at a time (`send` makes sequential unary calls only).
+- **Agent files** (`sandbox://workspace/<p>` in `payload.data.videos[]` /
+  `images[]` / `fallback_text`): each entry carries `mime`, `byte_len` and
+  `variants.original = https://<vm>.metaaivm.com/media/raw/workspace/<p>`.
+  The bytes come from `GET /media/raw/workspace/<p>` on the VM. That route is
+  not in `routes.json`; sent as a raw-path daemon request over the Noise
+  tunnel it returns the file (body chunks). `Gateway.download_file()` wraps
+  this. `artifacts.fetch_url` is unrelated (needs `project_dir`).
 - `session.start`: `{method: "/api/session/start", params: {origin: "fresh",
   lifecycle: "persistent", title?}}`.
 - `session.rename`: flat `{session_id, title}`. pin/unpin/archive/unarchive/

{muse_cli-0.3.2 → muse_cli-0.3.4}/skills/muse-cli/SKILL.md

@@ -138,6 +138,11 @@ muse-cli history --thread <session-id> --limit 5        # one side chat
 muse-cli send "message" --wait 120                      # send + wait for the reply
 muse-cli send "message" --thread <session-id> --wait 0  # fire and forget to a side chat
 muse-cli watch --timeout 60                             # tail live agent events
+muse-cli watch --thread <session-id>                    # tail one side chat
+muse-cli files --limit 20                               # images/videos the agent produced
+muse-cli download <seq|message-id|sandbox://...> -o DIR # save them locally
+muse-cli history --limit 3 --download DIR               # save files from these messages
+muse-cli send "make an image of X" --wait 300 --download DIR
 muse-cli feed --limit 5
 muse-cli goals
 muse-cli ideas
@@ -169,6 +174,10 @@ only for methods with no wrapper.
   is matched as a genuine answer, not background chatter.
 - `send --wait 0` is fire-and-forget (no polling).
 - `history` without `--thread` reads the main chat only.
+- Agent media shows up as `sandbox://workspace/...` paths, often in a
+  separate `delta.presentation` event after the text reply. `download` looks
+  up a message id or seq in the last `--limit` messages (main chat unless
+  `--thread`); existing files are skipped unless `-f`.
 - The gateway API is unversioned. Whole classes of calls failing at once means
   the protocol drifted: see `docs/PROTOCOL.md` for the re-derivation notes,
   don't guess at crypto or framing.

{muse_cli-0.3.2 → muse_cli-0.3.4}/src/muse_cli/__init__.py

@@ -1,3 +1,3 @@
 """muse-cli: talk to your personal muse.ai AI agent from the terminal."""
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"

muse_cli-0.3.4/src/muse_cli/chat.py

@@ -0,0 +1,279 @@
+"""Interactive chat with your muse.ai agent: `muse-cli chat` (or bare `muse-cli`).
+
+Plain, line-by-line text so it reads well in a terminal and with a screen
+reader. Picks up the conversation you used last. Type /help for commands.
+"""
+import json
+import os
+import time
+# Enable GNU readline / libedit for line editing, history, and proper
+# CJK/wide-character deletion (wcwidth). It is a standard library C extension,
+# but unavailable on native Windows or stripped/minimal Python installations.
+try:
+    import readline
+except ImportError:
+    readline = None
+
+from .cli import CONFIG_DIR, cmd_auth_export, connect, fmt_event, load_config
+from .gateway import AuthError, GatewayError
+
+WAIT = 300   # seconds to wait for the first reply
+QUIET = 10   # seconds of silence after a reply before taking the next message
+POLL = 1     # seconds between history reads while waiting for a reply
+STATE = os.path.join(CONFIG_DIR, "chat.json")
+HISTFILE = os.path.join(CONFIG_DIR, "chat_history")
+
+HELP = """Commands:
+  /chats          list your conversations
+  /open N         switch to conversation number N from /chats
+  /main           switch to your main chat
+  /new [title]    start a new conversation
+  /history [N]    read the last N messages here (default 10)
+  /login          save your muse.ai login from Chrome again (same as `muse-cli auth export`)
+  /exit           quit (Ctrl+C works too)"""
+
+
+def load_state():
+    try:
+        return json.load(open(STATE))
+    except (OSError, ValueError):
+        return {"session_id": None, "title": "main chat"}
+
+
+def save_state(st):
+    os.makedirs(CONFIG_DIR, exist_ok=True)
+    json.dump(st, open(STATE, "w"), indent=2)
+
+
+def is_not_found(err):
+    """True if a GatewayError indicates a missing or deleted session."""
+    return isinstance(err, GatewayError) and (
+        err.status == 404 or "not_found" in str(err) or "session not found" in str(err)
+    )
+
+
+class Chat:
+    def __init__(self):
+        self.cfg = load_config()
+        self.st = load_state()
+        self.gw = connect(self.cfg)
+        self.listing = []
+
+    def scope(self):
+        return {"session_id": self.st["session_id"]} if self.st["session_id"] else {}
+
+    def events(self, limit):
+        evs = self.gw.call_json("chat.history", body={"limit": limit, **self.scope()})
+        return sorted(evs.get("chat_events", []), key=lambda e: e.get("seq", 0))
+
+    def messages(self, limit):
+        out = []
+        for ev in self.events(limit):
+            m = fmt_event(ev)
+            name = ev.get("event_name", "")
+            if m["text"] and name in ("message.user", "message.assistant"):
+                out.append(("You" if name == "message.user" else "Muse", m["text"]))
+        return out
+
+    def show_history(self, n=10):
+        try:
+            msgs = self.messages(n * 3)[-n:]
+        except GatewayError as e:
+            if is_not_found(e) and self.st.get("session_id"):
+                print(f"Chat '{self.st.get('title')}' was deleted. Switching to main chat.")
+                self.switch(None, "main chat")
+                return
+            raise
+        if not msgs:
+            print("No messages here yet.")
+        for who, text in msgs:
+            print(f"\n{who}: {text}")
+
+    def last_seq(self):
+        evs = self.events(1)
+        return evs[-1].get("seq", 0) if evs else 0
+
+    def new_replies(self, after):
+        found = []
+        for ev in self.events(15):
+            p = ev.get("payload") if isinstance(ev.get("payload"), dict) else {}
+            # Exclude background updates (same discriminator as cli.is_reply):
+            # events with reply_to_message_id are not genuine replies
+            if ev.get("reply_to_message_id") or p.get("reply_to_message_id"):
+                continue
+            if (ev.get("event_name") == "message.assistant" and ev.get("seq", 0) > after
+                    and p.get("status") and fmt_event(ev)["text"]):
+                found.append(ev)
+        return found
+
+    def send(self, text):
+        try:
+            seen = self.last_seq()
+            body = {"items": [{"type": "text", "text": text}],
+                    "node_id": self.cfg["node_id"], "capabilities": {}, **self.scope()}
+            self.gw._open("chat.stream", body=body)
+        except GatewayError as e:
+            if is_not_found(e) and self.st.get("session_id"):
+                print(f"Chat '{self.st.get('title')}' was deleted. Switching to main chat.")
+                self.switch(None, "main chat")
+                return
+            raise
+        print("Muse is thinking...")
+        deadline, got_any = time.time() + WAIT, False
+        while time.time() < deadline:
+            time.sleep(POLL)
+            try:
+                evs = self.new_replies(seen)
+            except (GatewayError, TimeoutError):
+                continue
+            for ev in evs:
+                print(f"\nMuse: {fmt_event(ev)['text']}")
+                seen = ev["seq"]
+            if evs:
+                got_any = True
+                # keep listening briefly: the agent often sends follow-ups
+                deadline = time.time() + QUIET
+        if not got_any:
+            print(f"(No reply within {WAIT} seconds. Type /history later to check.)")
+
+    def list_chats(self):
+        d = self.gw.call_json("sessions.list")
+        self.listing = [s for s in d.get("sessions", []) if not s.get("archived")]
+        for i, s in enumerate(self.listing, 1):
+            when = time.strftime("%Y-%m-%d %H:%M",
+                                 time.localtime(s.get("updated_at_ms", 0) / 1000))
+            main = "" if s.get("is_thread") else " (main chat)"
+            print(f"{i}. {s.get('title') or 'untitled'}{main}, updated {when}")
+        print("Type /open and a number to switch.")
+
+    def switch(self, session_id, title):
+        self.st = {"session_id": session_id, "title": title}
+        save_state(self.st)
+        print(f"Now in: {title}")
+        self.show_history(3)
+
+    def open_chat(self, arg):
+        if not self.listing:
+            self.list_chats()
+            return
+        try:
+            n = int(arg)
+        except ValueError:
+            print("Type /open and a number from /chats.")
+            return
+        if 1 <= n <= len(self.listing):
+            s = self.listing[n - 1]
+            self.switch(s["session_id"], s.get("title") or "untitled")
+        else:
+            print("No conversation with that number. Type /chats to see them.")
+
+    def new_chat(self, title):
+        params = {"origin": "fresh", "lifecycle": "persistent"}
+        if title:
+            params["title"] = title
+        d = self.gw.call_json("session.start",
+                              body={"method": "/api/session/start", "params": params})
+        self.switch(d.get("session_id") or d.get("id"), title or "new conversation")
+
+    def reconnect(self):
+        self.gw.close()
+        self.gw = connect(self.cfg)
+
+    def handle(self, line):
+        cmd, _, arg = line.partition(" ")
+        arg = arg.strip()
+        if cmd in ("/help", "/?"):
+            print(HELP)
+        elif cmd == "/chats":
+            self.list_chats()
+        elif cmd == "/open":
+            self.open_chat(arg)
+        elif cmd == "/main":
+            self.switch(None, "main chat")
+        elif cmd == "/new":
+            self.new_chat(arg)
+        elif cmd == "/history":
+            self.show_history(int(arg) if arg.isdigit() else 10)
+        elif cmd == "/login":
+            if login():
+                self.reconnect()
+                print("Signed in.")
+        else:
+            print("Unknown command. Type /help.")
+
+
+def login():
+    """Re-run `auth export`; True when fresh cookies were saved."""
+    try:
+        cmd_auth_export(None)
+        return True
+    except SystemExit:
+        return False
+
+
+def start():
+    try:
+        return Chat()
+    except AuthError as e:
+        print(f"Can't sign in to muse.ai: {e}")
+        if login():
+            return Chat()
+        raise
+
+
+def cmd_chat(_args):
+    if readline is not None:
+        try:
+            readline.read_history_file(HISTFILE)
+        except OSError:
+            pass
+    chat = start()
+    print(f"Muse chat, in: {chat.st['title']}. Type /help for commands, /exit to quit.")
+    try:
+        chat.show_history(3)
+    except GatewayError as e:
+        if is_not_found(e) and chat.st.get("session_id"):
+            print(f"Chat '{chat.st.get('title')}' was deleted. Switching to main chat.")
+            chat.switch(None, "main chat")
+        else:
+            print(f"(Could not load history: {e})")
+    except Exception as e:
+        print(f"(Could not load history: {e})")
+    try:
+        while True:
+            try:
+                line = input("\nYou: ").strip()
+            except EOFError:
+                break
+            if not line:
+                continue
+            if line.lower() in ("/exit", "/quit", "exit", "quit"):
+                break
+            try:
+                chat.handle(line) if line.startswith("/") else chat.send(line)
+            except AuthError:
+                print("Your login expired. Type /login to sign in again.")
+            except GatewayError as e:
+                if is_not_found(e) and chat.st.get("session_id"):
+                    print(f"Chat '{chat.st.get('title')}' was deleted. Switching to main chat.")
+                    chat.switch(None, "main chat")
+                else:
+                    print(f"Gateway error: {e}")
+            except Exception as e:  # dropped connection: reconnect so the next try works
+                print(f"Connection problem ({e}). Reconnected; please try again.")
+                try:
+                    chat.reconnect()
+                except Exception as e2:
+                    print(f"Still can't connect: {e2}")
+    except KeyboardInterrupt:
+        pass
+    finally:
+        if readline is not None:
+            try:
+                os.makedirs(CONFIG_DIR, exist_ok=True)
+                readline.set_history_length(1000)
+                readline.write_history_file(HISTFILE)
+            except OSError:
+                pass
+        chat.gw.close()
+    print("\nBye.")

{muse_cli-0.3.2 → muse_cli-0.3.4}/src/muse_cli/cli.py

@@ -11,6 +11,7 @@ Then: muse-cli status | muse-cli threads | muse-cli history | muse-cli send "hel
 import argparse
 import json
 import os
+import re
 import shutil
 import sys
 import time
@@ -337,6 +338,18 @@ def cmd_history(args):
             params["session_id"] = args.thread
         d = gw.call_json("chat.history", body=params)
         events = d.get("chat_events", [])
+        if args.download:
+            res = []
+            for e in events:
+                for r in event_resources(e):
+                    if r["path"] not in [x["path"] for x in res]:
+                        res.append(r)
+            d["downloads"] = save_resources(gw, res, args.download)
+            if not args.raw:
+                rows = [fmt_event(e) for e in events if (e.get("payload", {}) or {}).get("display_text")
+                        or (e.get("payload", {}) or {}).get("content")]
+                out({"messages": rows, "downloads": d["downloads"]})
+                return
         if args.raw:
             out(d)
             return
@@ -346,6 +359,135 @@ def cmd_history(args):
         gw.close()
 
 
+# -- files the agent produced -------------------------------------------------
+# Assistant messages carry media as payload.data.{videos,images,...}[]
+# entries ({path: "sandbox://workspace/...", mime, byte_len, variants:
+# {original: "https://<vm>.metaaivm.com/media/raw/..."}}), and as
+# sandbox:// links in fallback_text.
+_SANDBOX_RE = re.compile(r"sandbox://[^\s)\]\"'>]+")
+
+
+def event_resources(ev):
+    """List the downloadable files referenced by one history event."""
+    p = ev.get("payload", {}) if isinstance(ev.get("payload"), dict) else {}
+    found = {}
+
+    def add(item, kind):
+        if isinstance(item, str):
+            item = {"path": item}
+        if not isinstance(item, dict):
+            return
+        path = item.get("path") or (item.get("variants") or {}).get("original")
+        if not path or not (path.startswith("sandbox://") or "/media/raw/" in path):
+            return
+        if item.get("missing"):
+            return
+        r = found.setdefault(path, {"path": path})
+        r.setdefault("kind", kind)
+        for k in ("mime", "byte_len", "label", "variants"):
+            if item.get(k) is not None:
+                r[k] = item[k]
+
+    data = p.get("data") if isinstance(p.get("data"), dict) else {}
+    for key, val in data.items():
+        if isinstance(val, list):
+            for item in val:
+                add(item, key.rstrip("s"))
+    for src in (ev.get("resources"), p.get("resources")):
+        for item in src or []:
+            add(item, "resource")
+    for text in (p.get("fallback_text"), data.get("fallback_text"),
+                 p.get("display_text"), p.get("content")):
+        if isinstance(text, str):
+            for m in _SANDBOX_RE.findall(text):
+                add(m, "link")
+    return list(found.values())
+
+
+def _local_name(path, directory):
+    name = os.path.basename(path.split("?", 1)[0].rstrip("/")) or "download"
+    return os.path.join(directory, name)
+
+
+def save_resources(gw, resources, directory, overwrite=False):
+    """Download each resource into directory; return one result row each."""
+    os.makedirs(directory, exist_ok=True)
+    rows = []
+    for r in resources:
+        dest = _local_name(r["path"], directory)
+        row = {"path": r["path"], "file": os.path.abspath(dest)}
+        if os.path.exists(dest) and not overwrite:
+            row.update(skipped="exists", bytes=os.path.getsize(dest))
+            rows.append(row)
+            continue
+        try:
+            data = gw.download_file(r)
+        except (GatewayError, TimeoutError, ValueError) as e:
+            row["error"] = str(e)
+            rows.append(row)
+            continue
+        tmp = dest + ".part"
+        with open(tmp, "wb") as f:
+            f.write(data)
+        os.replace(tmp, dest)
+        row["bytes"] = len(data)
+        if r.get("byte_len") and r["byte_len"] != len(data):
+            row["warning"] = f"expected {r['byte_len']} bytes"
+        rows.append(row)
+    return rows
+
+
+def _history_events(gw, thread, limit):
+    params = {"limit": limit}
+    if thread:
+        params["session_id"] = thread
+    return gw.call_json("chat.history", body=params).get("chat_events", [])
+
+
+def cmd_files(args):
+    gw = connect(load_config())
+    try:
+        rows = []
+        for ev in _history_events(gw, args.thread, args.limit):
+            p = ev.get("payload", {}) if isinstance(ev.get("payload"), dict) else {}
+            for r in event_resources(ev):
+                rows.append({"seq": ev.get("seq"),
+                             "message_id": p.get("message_id") or ev.get("message_id"), **r})
+        out(rows)
+    finally:
+        gw.close()
+
+
+def cmd_download(args):
+    gw = connect(load_config())
+    try:
+        ref = args.ref
+        if ref.startswith("sandbox://") or "/media/raw/" in ref:
+            resources = [{"path": ref}]
+        else:
+            # A message id or history seq: collect that message's files.
+            resources = []
+            for ev in _history_events(gw, args.thread, args.limit):
+                p = ev.get("payload", {}) if isinstance(ev.get("payload"), dict) else {}
+                ids = {str(ev.get("seq")), str(p.get("message_id") or ""),
+                       str(ev.get("message_id") or ""), str(p.get("id") or "")}
+                if ref in ids:
+                    for r in event_resources(ev):
+                        if r["path"] not in [x["path"] for x in resources]:
+                            resources.append(r)
+            if not resources:
+                print(f"no files found for '{ref}' in the last {args.limit} messages"
+                      + (f" of thread {args.thread}" if args.thread else " of the main chat")
+                      + " (try --thread / --limit)", file=sys.stderr)
+                sys.exit(1)
+        rows = save_resources(gw, resources, args.output, overwrite=args.force)
+        out(rows)
+        if any("error" in r for r in rows):
+            sys.exit(3)
+    finally:
+        gw.close()
+
+
 def is_reply(ev, baseline):
     """True for a genuine assistant reply (not a proactive push).
 
@@ -362,11 +504,18 @@ def is_reply(ev, baseline):
         return False
     if not (p.get("display_text") or p.get("content")):
         return False
-    if "display_text_ready" in p and not p["display_text_ready"]:
+    # A reply still being written has no status yet (and display_text_ready
+    # is already true), so its text is cut short; wait for "completed".
+    if not p.get("status"):
         return False
     return True
 
 
+# How often a waiting send re-reads history. A history read is one small
+# unary call; at 4 s a finished reply sat unshown for up to 4 s.
+POLL = 1
+
+
 def cmd_send(args):
     cfg = load_config()
     gw = connect(cfg)
@@ -403,15 +552,32 @@ def cmd_send(args):
             try:
                 h = gw.call_json("chat.history", body={"limit": 10, **scope})
             except (GatewayError, TimeoutError):
-                time.sleep(4)
+                time.sleep(POLL)
                 continue
-            for ev in sorted(h.get("chat_events", []), key=lambda e: e.get("seq", 0)):
+            evs = sorted(h.get("chat_events", []), key=lambda e: e.get("seq", 0))
+            for ev in evs:
                 if is_reply(ev, baseline):
                     reply = fmt_event(ev)
                     break
             if reply is None:
-                time.sleep(4)
+                time.sleep(POLL)
         result = {"sent": True, "stream": stream_sid}
+        if reply and args.download:
+            # Media often lands as separate presentation events after the
+            # text reply; give them a moment, then save every file newer
+            # than the baseline.
+            time.sleep(min(3, max(0, deadline - time.time())))
+            try:
+                h = gw.call_json("chat.history", body={"limit": 20, **scope})
+                res = []
+                for ev in h.get("chat_events", []):
+                    if (ev.get("seq") or 0) > baseline:
+                        for r in event_resources(ev):
+                            if r["path"] not in [x["path"] for x in res]:
+                                res.append(r)
+                result["downloads"] = save_resources(gw, res, args.download)
+            except (GatewayError, TimeoutError) as e:
+                result["download_error"] = str(e)
         if reply:
             result["reply"] = reply
         else:
@@ -421,22 +587,34 @@ def cmd_send(args):
         gw.close()
 
 
+def _print_watch_row(line, show_all):
+    try:
+        ev = json.loads(line)
+    except json.JSONDecodeError:
+        return
+    et = ev.get("event", ev.get("type"))
+    if et in ("agent.status",) and not show_all:
+        return
+    p = ev.get("payload", {}) if isinstance(ev.get("payload"), dict) else {}
+    row = {"event": et, "seq": ev.get("seq")}
+    for k in ("display_text", "content", "text", "activity_text", "status"):
+        if p.get(k):
+            row[k] = str(p[k])[:300]
+    print(json.dumps(row, ensure_ascii=False), flush=True)
+
+
 def cmd_watch(args):
     gw = connect(load_config())
     try:
-        recs = gw.subscribe_json("chat.subscribe", body={"capabilities": {}},
-                                 max_records=args.n, idle_timeout=8,
-                                 overall_timeout=args.timeout)
-        for ev in recs:
-            et = ev.get("event", ev.get("type"))
-            if et in ("agent.status",) and not args.all:
-                continue
-            p = ev.get("payload", {}) if isinstance(ev.get("payload"), dict) else {}
-            row = {"event": et, "seq": ev.get("seq")}
-            for k in ("display_text", "content", "text", "activity_text", "status"):
-                if p.get(k):
-                    row[k] = str(p[k])[:300]
-            print(json.dumps(row, ensure_ascii=False), flush=True)
+        # Subscribe the way the web client does: capabilities as a list, and
+        # a thread's own session id when watching a side chat.
+        body = {"capabilities": ["chat_cancel", "delta_stream"]}
+        if args.thread:
+            body["session_id"] = args.thread
+        # Rows print as each event arrives, not after the stream ends.
+        gw.subscribe_raw("chat.subscribe", body=body, max_records=args.n,
+                         idle_timeout=args.timeout, overall_timeout=args.timeout,
+                         on_record=lambda line: _print_watch_row(line, args.all))
     finally:
         gw.close()
 
@@ -622,10 +800,15 @@ def cmd_raw(args):
         gw.close()
 
 
+def _chat(args):
+    from .chat import cmd_chat
+    cmd_chat(args)
+
+
 def main():
     ap = argparse.ArgumentParser(prog="muse-cli", description="CLI for your personal muse.ai agent")
     ap.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
-    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub = ap.add_subparsers(dest="cmd")
 
     p = sub.add_parser("auth", help="auth helpers"); a = p.add_subparsers(dest="op", required=True)
     export_help = (
@@ -655,20 +838,37 @@ def main():
         formatter_class=argparse.RawDescriptionHelpFormatter,
     ).set_defaults(fn=cmd_auth_export)
 
+    sub.add_parser("chat", help="interactive chat (the default with no command)").set_defaults(fn=_chat)
     sub.add_parser("status", help="VM, session count, unread, identity").set_defaults(fn=cmd_status)
     p = sub.add_parser("threads", help="list chats and side chats")
     p.add_argument("--all", dest="archived", action="store_true", help="include archived")
     p.set_defaults(fn=cmd_threads)
     p = sub.add_parser("history", help="read chat messages")
     p.add_argument("--thread", default=None); p.add_argument("--limit", type=int, default=10)
-    p.add_argument("--raw", action="store_true"); p.set_defaults(fn=cmd_history)
+    p.add_argument("--raw", action="store_true")
+    p.add_argument("--download", metavar="DIR", default=None,
+                   help="also save files (images/videos) from these messages into DIR")
+    p.set_defaults(fn=cmd_history)
     p = sub.add_parser("send", help="send the agent a message")
     p.add_argument("text"); p.add_argument("--thread", default=None)
     p.add_argument("--wait", type=int, default=90, help="seconds to wait for reply (0 = don't)")
+    p.add_argument("--download", metavar="DIR", default=None,
+                   help="save files the reply produced into DIR (needs --wait)")
     p.set_defaults(fn=cmd_send)
+    p = sub.add_parser("files", help="list files (images/videos) in recent messages")
+    p.add_argument("--thread", default=None); p.add_argument("--limit", type=int, default=20)
+    p.set_defaults(fn=cmd_files)
+    p = sub.add_parser("download", help="download a file the agent produced")
+    p.add_argument("ref", help="sandbox:// path, media URL, message id, or history seq")
+    p.add_argument("-o", "--output", default=".", help="directory to save into (default .)")
+    p.add_argument("--thread", default=None, help="side chat to search for a message id/seq")
+    p.add_argument("--limit", type=int, default=50, help="messages to search for a message id/seq")
+    p.add_argument("-f", "--force", action="store_true", help="overwrite existing files")
+    p.set_defaults(fn=cmd_download)
     p = sub.add_parser("watch", help="tail live agent events")
     p.add_argument("--timeout", type=int, default=60); p.add_argument("--n", type=int, default=50)
-    p.add_argument("--all", action="store_true"); p.set_defaults(fn=cmd_watch)
+    p.add_argument("--all", action="store_true"); p.add_argument("--thread", default=None)
+    p.set_defaults(fn=cmd_watch)
     p = sub.add_parser("feed", help="list feed units")
     p.add_argument("--limit", type=int, default=None); p.add_argument("--raw", action="store_true")
     p.set_defaults(fn=cmd_feed)
@@ -704,6 +904,8 @@ def main():
     p.add_argument("--timeout", type=int, default=30); p.set_defaults(fn=cmd_raw)
 
     args = ap.parse_args()
+    if args.cmd is None:
+        args.cmd, args.fn = "chat", _chat
     # A piped command prints JSON. The notice stays off unless both streams
     # are a terminal, and `update` is already doing the upgrade.
     notice = None if args.cmd == "update" else start_update_check()

{muse_cli-0.3.2 → muse_cli-0.3.4}/src/muse_cli/gateway.py

@@ -51,6 +51,28 @@ class AuthError(RuntimeError):
     pass
 
 
+def media_path(ref):
+    """Map a sandbox path / media URL / resource dict to a /media/raw/... path."""
+    if isinstance(ref, dict):
+        ref = (ref.get("variants") or {}).get("original") or ref.get("path") or ref.get("url")
+        if not ref:
+            raise ValueError("resource has no path or variants.original")
+    ref = str(ref)
+    if ref.startswith("sandbox://"):
+        rel = ref[len("sandbox://"):]
+    elif ref.startswith(("https://", "http://")):
+        rel = urllib.parse.urlsplit(ref).path
+    else:
+        rel = ref
+    rel = rel.lstrip("/")
+    if rel.startswith("media/raw/"):
+        rel = rel[len("media/raw/"):]
+    rel = urllib.parse.unquote(rel)
+    if not rel or ".." in rel.split("/"):
+        raise ValueError(f"bad sandbox path: {ref!r}")
+    return "/media/raw/" + urllib.parse.quote(rel, safe="/")
+
+
 class GatewayError(RuntimeError):
     def __init__(self, status, payload):
         super().__init__(f"gateway status={status} payload={payload!r}")
@@ -198,8 +220,8 @@ class Gateway:
         sf.ParseFromString(sr.payload)
         return sf
 
-    def _open(self, method, path_params=None, body=None, query=None):
-        route = ROUTES[method]
+    def _open(self, method, path_params=None, body=None, query=None, route=None):
+        route = route or ROUTES[method]
         path = route["path"]
         for k, v in (path_params or {}).items():
             path = path.replace("{" + k + "}", urllib.parse.quote(str(v), safe=""))
@@ -225,11 +247,11 @@ class Gateway:
         return sid
 
     # -- unary request/response --------------------------------------------
-    def request(self, method, path_params=None, body=None, query=None, timeout=30):
-        route = ROUTES[method]
+    def request(self, method, path_params=None, body=None, query=None, timeout=30, route=None):
+        route = route or ROUTES[method]
         if route["http"] == "GET" and body is not None and query is None:
             query, body = body, None
-        sid = self._open(method, path_params, body, query)
+        sid = self._open(method, path_params, body, query, route=route)
         status, chunks, deadline = None, [], time.time() + timeout
         while time.time() < deadline:
             sf = self._read_frame()
@@ -255,6 +277,21 @@ class Gateway:
             raise GatewayError(status, payload[:500].decode("utf-8", "replace"))
         return payload
 
+    # -- files the agent produced (sandbox://...) ---------------------------
+    def download_file(self, ref, timeout=300):
+        """Return the bytes of a file in the agent's sandbox.
+
+        `ref` is a `sandbox://workspace/...` path, a media URL from a
+        resource's `variants` (https://<vm>.metaaivm.com/media/raw/...), a
+        bare `/media/raw/...` path, or a resource dict with `path`/`variants`.
+        The web app loads these from GET /media/raw/<path> on the VM; here
+        the same request rides the Noise tunnel (plain TLS to the per-VM
+        host is reset at the edge).
+        """
+        path = media_path(ref)
+        route = {"method": "media.raw", "http": "GET", "path": path}
+        return self.request("media.raw", timeout=timeout, route=route)
+
     def call_json(self, method, path_params=None, body=None, query=None, timeout=30):
         raw = self.request(method, path_params, body, query, timeout)
         try:
@@ -267,8 +304,13 @@ class Gateway:
 
     # -- subscriptions (ndjson event streams) -------------------------------
     def subscribe_raw(self, method, path_params=None, body=None, query=None,
-                      max_records=100, idle_timeout=10, overall_timeout=120):
-        """Open a subscription; returns list of raw record bytes."""
+                      max_records=100, idle_timeout=10, overall_timeout=120,
+                      on_record=None):
+        """Open a subscription; returns list of raw record bytes.
+
+        ``on_record`` is called with each record the moment it arrives, for
+        callers that show events live instead of after the stream ends.
+        """
         sid = self._open(method, path_params, body, query)
         buf, records = b"", []
         q: queue_mod.Queue = queue_mod.Queue()
@@ -313,6 +355,8 @@ class Gateway:
                     line, buf = buf.split(b"\n", 1)
                     if line.strip():
                         records.append(line)
+                        if on_record:
+                            on_record(line)
                         if len(records) >= max_records:
                             break
         finally:
@@ -320,6 +364,8 @@ class Gateway:
             stop = nonlocal_stop
         if buf.strip():
             records.append(buf)
+            if on_record:
+                on_record(buf)
         return records
 
     def subscribe_json(self, *a, **kw):