muse-cli 0.3.6__tar.gz → 0.3.7__tar.gz

{muse_cli-0.3.6 → muse_cli-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: muse-cli
-Version: 0.3.6
+Version: 0.3.7
 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
@@ -206,13 +206,13 @@ 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 send "make a cat video" --wait 300 --download ./out   # waits for the chat to go quiet (15 s), at most --wait
 muse-cli watch --thread <session-id>              # tail one side chat
 
 muse-cli unread                                   # unread counts
 muse-cli feed --limit 5
 muse-cli feed-status                              # also: feed-prompt
-muse-cli feed-react <unit-id> love
+muse-cli feed-react <unit-id> love                # or like, dislike
 muse-cli goals                                    # one goal: muse-cli goal <id>
 muse-cli ideas                                    # one idea: muse-cli idea <id>
 muse-cli idea-exec <idea-id>                      # agent acts on the idea

{muse_cli-0.3.6 → muse_cli-0.3.7}/README.md

@@ -169,13 +169,13 @@ 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 send "make a cat video" --wait 300 --download ./out   # waits for the chat to go quiet (15 s), at most --wait
 muse-cli watch --thread <session-id>              # tail one side chat
 
 muse-cli unread                                   # unread counts
 muse-cli feed --limit 5
 muse-cli feed-status                              # also: feed-prompt
-muse-cli feed-react <unit-id> love
+muse-cli feed-react <unit-id> love                # or like, dislike
 muse-cli goals                                    # one goal: muse-cli goal <id>
 muse-cli ideas                                    # one idea: muse-cli idea <id>
 muse-cli idea-exec <idea-id>                      # agent acts on the idea

{muse_cli-0.3.6 → muse_cli-0.3.7}/docs/PROTOCOL.md

@@ -54,6 +54,9 @@ chat / feed / goals / ideas / sessions / ...
 - Genuine assistant replies have an **empty `reply_to_message_id`**; proactive
   pushes (Telegram drafts, background task updates) are self-referential
   there. That is how `send` tells a reply apart from background chatter.
+- Generated media arrives as a **separate** assistant event after the text
+  reply, ~20 s later for an image. `send --download` therefore waits until
+  the history seq has been quiet for `SETTLE` seconds before collecting files.
 - Live `chat.subscribe` events use **different shapes** (`delta.text_append`
   with `message_seq` + text chunks, `delta.message_done` with the full
   transcript) and only cover main-chat traffic: threaded replies never arrive
@@ -76,10 +79,15 @@ chat / feed / goals / ideas / sessions / ...
   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?}}`.
+  lifecycle: "persistent"}}`. A `title` param is accepted but ignored (the
+  chat stays untitled), so `start_session` follows up with `session.rename`.
 - `session.rename`: flat `{session_id, title}`. pin/unpin/archive/unarchive/
   delete: `{method: "/api/session/<op>", session_id}`.
-- `api.idea-cards.execute`: `{ideaCardId, mode: "full"}` plus path param.
+- `feed.unit.reaction`: `{reaction}` must be `like`, `love` or `dislike` (the
+  server's 400 lists them).
+- `api.idea-cards.execute`: `{ideaCardId, mode: "full"}` plus path param. A
+  `session_id` in the body did not move the run into that side chat; the
+  user message and the agent's reply landed in the main chat.
 - POSTs to muse.ai need browser `Sec-Fetch-*` headers or they return 403.
 - `auth export` reads cookies from the user's own Google Chrome through
   agent-browser `--auto-connect`. Chrome 144+ shares that profile only after

{muse_cli-0.3.6 → muse_cli-0.3.7}/skills/muse-cli/SKILL.md

@@ -174,6 +174,13 @@ only for methods with no wrapper.
   than the wait: the message still landed, confirm with `history`. The reply
   is matched as a genuine answer, not background chatter.
 - `send --wait 0` is fire-and-forget (no polling).
+- `send --download DIR` keeps waiting after the reply until the thread has been
+  quiet for 15 s (so it always takes at least that long), because generated
+  images and videos arrive as separate messages after the text. The wait stops
+  at `--wait`; if that comes first the result has a `download_note` and files
+  may be missing.
+- `idea-exec --thread` may be ignored by the server; the run can land in the
+  main chat.
 - Running `muse-cli` with no command opens the interactive chat and blocks on
   stdin. From an agent, always pass an explicit command such as `status` or
   `send`.

{muse_cli-0.3.6 → muse_cli-0.3.7}/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.6"
+__version__ = "0.3.7"

{muse_cli-0.3.6 → muse_cli-0.3.7}/src/muse_cli/chat.py

@@ -14,7 +14,7 @@ try:
 except ImportError:
     readline = None
 
-from .cli import CONFIG_DIR, cmd_auth_export, connect, fmt_event, load_config
+from .cli import CONFIG_DIR, cmd_auth_export, connect, fmt_event, load_config, start_session
 from .gateway import AuthError, GatewayError
 
 WAIT = 300   # seconds to wait for the first reply
@@ -168,11 +168,7 @@ class Chat:
             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})
+        d = start_session(self.gw, title)
         self.switch(d.get("session_id") or d.get("id"), title or "new conversation")
 
     def reconnect(self):

{muse_cli-0.3.6 → muse_cli-0.3.7}/src/muse_cli/cli.py

@@ -522,6 +522,11 @@ def is_reply(ev, baseline):
 # unary call; at 4 s a finished reply sat unshown for up to 4 s.
 POLL = 1
 
+# With --download, how long the thread must stay quiet after the reply before
+# send collects files. Generated media arrives as separate events well after
+# the text (an image took ~20 s), so a short fixed sleep missed it.
+SETTLE = 15
+
 
 def cmd_send(args):
     cfg = load_config()
@@ -571,9 +576,26 @@ def cmd_send(args):
         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())))
+            # text reply; wait for the thread to go quiet, then save every
+            # file newer than the baseline.
+            last_seq, quiet_since, settled = reply["seq"] or 0, time.time(), False
+            while time.time() < deadline:
+                if time.time() - quiet_since >= SETTLE:
+                    settled = True
+                    break
+                time.sleep(POLL)
+                try:
+                    h = gw.call_json("chat.history", body={"limit": 20, **scope})
+                except (GatewayError, TimeoutError):
+                    continue
+                except AuthError:
+                    break
+                seq = max([e.get("seq") or 0 for e in h.get("chat_events", [])] or [0])
+                if seq > last_seq:
+                    last_seq, quiet_since = seq, time.time()
+            if not settled:
+                result["download_note"] = ("stopped waiting before the thread went quiet; "
+                                           "files may be missing, check `muse-cli history --download`")
             try:
                 h = gw.call_json("chat.history", body={"limit": 20, **scope})
                 res = []
@@ -583,7 +605,7 @@ def cmd_send(args):
                             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:
+            except (AuthError, GatewayError, TimeoutError) as e:
                 result["download_error"] = str(e)
         if reply:
             result["reply"] = reply
@@ -738,14 +760,27 @@ def cmd_seen(args):
         gw.close()
 
 
+def start_session(gw, title=None):
+    res = gw.call_json("session.start",
+                       body={"method": "/api/session/start",
+                             "params": {"origin": "fresh", "lifecycle": "persistent"}})
+    # The server ignores a title on start, so name the chat afterwards.
+    sid = res.get("session_id") or res.get("id")
+    if title and sid:
+        # The chat already exists, so a failed rename must not hide its id.
+        try:
+            gw.call_json("session.rename", body={"session_id": sid, "title": title})
+            res["title"] = title
+        except (GatewayError, TimeoutError) as e:
+            res["title_error"] = str(e)
+            print(f"could not set the chat title: {e}", file=sys.stderr)
+    return res
+
+
 def cmd_session_start(args):
     gw = connect(load_config())
     try:
-        params = {"origin": "fresh", "lifecycle": "persistent"}
-        if args.title:
-            params["title"] = args.title
-        out(gw.call_json("session.start",
-                         body={"method": "/api/session/start", "params": params}))
+        out(start_session(gw, args.title))
     finally:
         gw.close()
 
@@ -860,7 +895,8 @@ def main():
     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)")
+                   help="save files the reply produced into DIR (needs --wait); waits until the "
+                        "chat is quiet for 15 s, at most --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)
@@ -881,7 +917,8 @@ def main():
     p.set_defaults(fn=cmd_feed)
     sub.add_parser("feed-status", help="feed refresh status").set_defaults(fn=cmd_feed_status)
     p = sub.add_parser("feed-react", help="react to a feed unit")
-    p.add_argument("unit"); p.add_argument("reaction", nargs="?", default="love")
+    p.add_argument("unit"); p.add_argument("reaction", nargs="?", default="love",
+                   choices=["like", "love", "dislike"], help="default: love")
     p.set_defaults(fn=cmd_feed_react)
     sub.add_parser("feed-prompt", help="show feed prompt").set_defaults(fn=cmd_feed_prompt)
     sub.add_parser("goals", help="list goals").set_defaults(fn=cmd_goals)
@@ -889,7 +926,10 @@ def main():
     sub.add_parser("ideas", help="list idea cards").set_defaults(fn=cmd_ideas)
     p = sub.add_parser("idea", help="show one idea"); p.add_argument("id"); p.set_defaults(fn=cmd_idea)
     p = sub.add_parser("idea-exec", help="execute an idea (agent acts on it)")
-    p.add_argument("id"); p.add_argument("--thread", default=None); p.set_defaults(fn=cmd_idea_exec)
+    p.add_argument("id")
+    p.add_argument("--thread", default=None,
+                   help="side chat to run it in (the server may ignore this and use the main chat)")
+    p.set_defaults(fn=cmd_idea_exec)
     sub.add_parser("unread", help="unread counts").set_defaults(fn=cmd_unread)
     p = sub.add_parser("seen", help="mark a thread seen"); p.add_argument("thread")
     p.set_defaults(fn=cmd_seen)
@@ -922,6 +962,9 @@ def main():
     try:
         try:
             args.fn(args)
+            # Flush here: with a block-buffered pipe, a closed reader only
+            # surfaces at flush time, which would otherwise be after this handler.
+            sys.stdout.flush()
         except AuthError as e:
             print(f"auth error: {e}", file=sys.stderr)
             sys.exit(2)
@@ -931,6 +974,14 @@ def main():
         except TimeoutError as e:
             print(f"timeout: {e}", file=sys.stderr)
             sys.exit(4)
+        except BrokenPipeError:
+            # The reader (`head`, `jq -e`) closed early. Point stdout at devnull
+            # so the interpreter's exit-time flush does not raise again.
+            os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno())
+            sys.exit(141)
+        except KeyboardInterrupt:
+            print(file=sys.stderr)
+            sys.exit(130)
     finally:
         finish_update_check(notice)