muse-cli 0.2.2__tar.gz → 0.3.1__tar.gz

{muse_cli-0.2.2 → muse_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: muse-cli
-Version: 0.2.2
+Version: 0.3.1
 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
@@ -75,7 +75,7 @@ to `~/.agents/skills/muse-cli`:
 curl -fsSL https://raw.githubusercontent.com/nikships/muse-cli/main/install.sh | bash
 ```
 
-Upgrade with `uv tool upgrade muse-cli`, remove with `uv tool uninstall muse-cli`.
+Upgrade with `muse-cli update`. In a terminal it also checks PyPI once a day and, when a newer release exists, prints that command on stderr. It does not upgrade itself. Set `MUSE_NO_UPDATE_CHECK=1` to silence the notice. The check stays quiet when output is piped or `CI` is set. Remove with `uv tool uninstall muse-cli`.
 
 Logging in is a separate one-time step. Chrome shares its cookies after you
 turn on remote debugging. Follow [Log in once](#log-in-once) before running

{muse_cli-0.2.2 → muse_cli-0.3.1}/README.md

@@ -38,7 +38,7 @@ to `~/.agents/skills/muse-cli`:
 curl -fsSL https://raw.githubusercontent.com/nikships/muse-cli/main/install.sh | bash
 ```
 
-Upgrade with `uv tool upgrade muse-cli`, remove with `uv tool uninstall muse-cli`.
+Upgrade with `muse-cli update`. In a terminal it also checks PyPI once a day and, when a newer release exists, prints that command on stderr. It does not upgrade itself. Set `MUSE_NO_UPDATE_CHECK=1` to silence the notice. The check stays quiet when output is piped or `CI` is set. Remove with `uv tool uninstall muse-cli`.
 
 Logging in is a separate one-time step. Chrome shares its cookies after you
 turn on remote debugging. Follow [Log in once](#log-in-once) before running

{muse_cli-0.2.2 → muse_cli-0.3.1}/skills/muse-cli/SKILL.md

@@ -174,3 +174,7 @@ only for methods with no wrapper.
   don't guess at crypto or framing.
 - Respect rate limits. Writes (send, react, execute, session ops) act as the
   user in their agent: announce them before running, never loop them.
+- A stderr line `A new release of muse-cli is available` is an upgrade
+  notice, not a failed command. Upgrade with `muse-cli update`. The check
+  runs at most once a day, only in a terminal, and never changes the install
+  by itself. `MUSE_NO_UPDATE_CHECK=1` silences it.

{muse_cli-0.2.2 → muse_cli-0.3.1}/src/muse_cli/__init__.py

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

{muse_cli-0.2.2 → muse_cli-0.3.1}/src/muse_cli/cli.py

@@ -17,6 +17,7 @@ import time
 
 from . import __version__
 from .gateway import Gateway, AuthError, GatewayError, load_cookies
+from .update import cmd_update, finish_update_check, start_update_check
 
 CONFIG_DIR = os.path.expanduser("~/.config/muse-cli")
 CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
@@ -81,7 +82,32 @@ def _parse_browser_doc(stdout):
     return None
 
 
-def _browser_run(argv):
+def _interpret_browser(returncode, stdout, stderr, require_json):
+    """Turn one agent-browser invocation into data, or raise RuntimeError.
+
+    `tab <id>` confirms success with a human line (`✓ Title` plus the URL)
+    and exit 0. That is not a failure. A real failure is `success: false`
+    or a non-zero exit.
+    """
+    doc = _parse_browser_doc(stdout) or _parse_browser_doc(stderr)
+    if isinstance(doc, dict) and doc.get("success") is False:
+        raise RuntimeError(str(doc.get("error") or "unknown error")[:400])
+    if isinstance(doc, dict):
+        data = doc.get("data")
+        if isinstance(data, dict):
+            return data
+        if isinstance(data, list):
+            return {"items": data}
+        if "cookies" in doc or "tabs" in doc:
+            return doc
+        return data if isinstance(data, dict) else (doc if doc.get("success") else {})
+    text = (stderr or stdout or "").strip()
+    if returncode == 0 and not require_json:
+        return {}
+    raise RuntimeError(text[:400] or f"exit {returncode}")
+
+
+def _browser_run(argv, require_json=True):
     """Run agent-browser and return the JSON envelope's data.
 
     On failure the tool prints {"success": false, "error": ...}. Some versions
@@ -89,13 +115,7 @@ def _browser_run(argv):
     """
     import subprocess
     r = subprocess.run(argv, capture_output=True, text=True)
-    doc = _parse_browser_doc(r.stdout) or _parse_browser_doc(r.stderr)
-    if isinstance(doc, dict) and doc.get("success") is False:
-        raise RuntimeError(str(doc.get("error") or "unknown error")[:400])
-    if r.returncode != 0 or doc is None:
-        msg = (r.stderr or r.stdout or "").strip()
-        raise RuntimeError(msg[:400] or f"exit {r.returncode}")
-    return doc.get("data", {}) if isinstance(doc, dict) else doc
+    return _interpret_browser(r.returncode, r.stdout, r.stderr, require_json)
 
 
 def _export_error_kind(err):
@@ -107,6 +127,9 @@ def _export_error_kind(err):
         return "debug"
     if err == "no muse.ai tab open in Chrome":
         return "tab"
+    # A page title from agent-browser means Chrome already answered.
+    if "https://muse.ai" in e or e.startswith("✓") or e.startswith("connected to chrome"):
+        return "connected"
     return "other"
 
 
@@ -172,6 +195,13 @@ def _print_export_failure(err):
         print("Open https://muse.ai/, log in, leave that tab open, and run", file=sys.stderr)
         print("`muse-cli auth export` again.", file=sys.stderr)
         return
+    if kind == "connected":
+        print("Chrome is connected and the muse.ai tab is open.", file=sys.stderr)
+        print("Remote debugging is already on. The cookie read did not come back.", file=sys.stderr)
+        print("Run `muse-cli auth export` again. If Chrome asks, click Allow.", file=sys.stderr)
+        print(file=sys.stderr)
+        _print_hand_copy()
+        return
     print(err, file=sys.stderr)
     print(file=sys.stderr)
     print("Check both of these, then run `muse-cli auth export` again:", file=sys.stderr)
@@ -200,10 +230,22 @@ def _browser_cookies():
                          and (t.get("id") or t.get("tabId"))]
             if not muse_tabs:
                 return None, "no muse.ai tab open in Chrome"
-            _browser_run(base + ["tab", muse_tabs[0].get("id") or muse_tabs[0]["tabId"]])
+            tab_id = (muse_tabs[0].get("id") or muse_tabs[0].get("tabId")
+                      or muse_tabs[0].get("targetId"))
+            # Switching tabs prints a human confirmation unless --json is set.
+            # Exit 0 is success either way; the cookies read is the next call.
+            _browser_run(base + ["tab", tab_id, "--json"], require_json=False)
             data = _browser_run(base + ["cookies", "get", "--json"])
-            jar = data.get("cookies", []) if isinstance(data, dict) else []
-            return [c for c in jar if "muse.ai" in c.get("domain", "")], None
+            raw = []
+            if isinstance(data, list):
+                raw = data
+            elif isinstance(data, dict):
+                for key in ("cookies", "items"):
+                    if isinstance(data.get(key), list):
+                        raw = data[key]
+                        break
+            jar = [c for c in raw if isinstance(c, dict) and "muse.ai" in (c.get("domain") or c.get("url") or "")]
+            return jar, None
         except RuntimeError as e:
             last_err = str(e)
             # Missing debug port and a stuck daemon will not change on retry.
@@ -655,23 +697,30 @@ def main():
             p.add_argument("title")
         p.set_defaults(fn=cmd_session_op(kind))
     sub.add_parser("wake", help="request a VM wake").set_defaults(fn=cmd_wake)
+    sub.add_parser("update", help="upgrade this install to the latest release").set_defaults(fn=cmd_update)
     p = sub.add_parser("raw", help="call any gateway method (escape hatch)")
     p.add_argument("method"); p.add_argument("--body", default=None)
     p.add_argument("--param", action="append", default=[], help="path param k=v (repeatable)")
     p.add_argument("--timeout", type=int, default=30); p.set_defaults(fn=cmd_raw)
 
     args = ap.parse_args()
+    # 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()
     try:
-        args.fn(args)
-    except AuthError as e:
-        print(f"auth error: {e}", file=sys.stderr)
-        sys.exit(2)
-    except GatewayError as e:
-        print(f"gateway error: {e}", file=sys.stderr)
-        sys.exit(3)
-    except TimeoutError as e:
-        print(f"timeout: {e}", file=sys.stderr)
-        sys.exit(4)
+        try:
+            args.fn(args)
+        except AuthError as e:
+            print(f"auth error: {e}", file=sys.stderr)
+            sys.exit(2)
+        except GatewayError as e:
+            print(f"gateway error: {e}", file=sys.stderr)
+            sys.exit(3)
+        except TimeoutError as e:
+            print(f"timeout: {e}", file=sys.stderr)
+            sys.exit(4)
+    finally:
+        finish_update_check(notice)
 
 
 if __name__ == "__main__":

muse_cli-0.3.1/src/muse_cli/update.py

@@ -0,0 +1,150 @@
+"""Tell an interactive user when a newer muse-cli is on PyPI.
+
+Same shape as `gh` and `uv`: look at most once a day, never on a pipe or in
+CI, never fail the command, and print the upgrade command instead of
+replacing the install. uv tools do not upgrade themselves.
+"""
+import json
+import os
+import shutil
+import sys
+import threading
+import time
+import urllib.request
+
+from . import __version__
+
+CHECK_INTERVAL = 24 * 60 * 60
+FAIL_BACKOFF = 60 * 60
+STATE_FILE = os.path.expanduser("~/.config/muse-cli/update.json")
+PYPI_URL = "https://pypi.org/pypi/muse-cli/json"
+
+
+def version_key(value):
+    """Stable x.y.z as a tuple. Pre-releases and junk compare as absent."""
+    text = str(value).strip().lstrip("v").split("+", 1)[0]
+    if not text or any(c.isalpha() for c in text):
+        return None
+    try:
+        return tuple(int(part) for part in text.split("."))
+    except ValueError:
+        return None
+
+
+def is_newer(latest, current):
+    new, old = version_key(latest), version_key(current)
+    return bool(new and old and new > old)
+
+
+def upgrade_argv():
+    """The upgrade command for this install. uv tool, pipx, or pip."""
+    prefix = os.path.realpath(sys.prefix)
+    sep = os.sep
+    if f"{sep}uv{sep}tools{sep}" in prefix:
+        return ["uv", "tool", "upgrade", "muse-cli"]
+    if f"{sep}pipx{sep}" in prefix:
+        return ["pipx", "upgrade", "muse-cli"]
+    return [sys.executable, "-m", "pip", "install", "-U", "muse-cli"]
+
+
+def upgrade_command():
+    return " ".join(upgrade_argv())
+
+
+def _should_check():
+    if os.environ.get("MUSE_NO_UPDATE_CHECK"):
+        return False
+    if os.environ.get("CI"):
+        return False
+    try:
+        return sys.stdout.isatty() and sys.stderr.isatty()
+    except (AttributeError, ValueError):
+        return False
+
+
+def _load_state():
+    try:
+        with open(STATE_FILE) as fh:
+            data = json.load(fh)
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _save_state(data):
+    try:
+        os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
+        tmp = STATE_FILE + ".tmp"
+        with open(tmp, "w") as fh:
+            json.dump(data, fh)
+        os.replace(tmp, STATE_FILE)
+    except OSError:
+        pass
+
+
+def _fetch_latest():
+    req = urllib.request.Request(
+        PYPI_URL,
+        headers={"Accept": "application/json", "User-Agent": f"muse-cli/{__version__}"},
+    )
+    with urllib.request.urlopen(req, timeout=2) as resp:
+        payload = json.loads(resp.read().decode())
+    return str(payload["info"]["version"])
+
+
+def start_update_check():
+    """Begin a check, or return a cached result. None when the notice is off."""
+    if not _should_check():
+        return None
+    state = _load_state()
+    latest = state.get("latest") or ""
+    checked = float(state.get("checked_at") or 0)
+    if latest and time.time() - checked < CHECK_INTERVAL:
+        return {"latest": latest}
+    holder = {"latest": None, "thread": None}
+
+    def work():
+        try:
+            found = _fetch_latest()
+            holder["latest"] = found
+            _save_state({"checked_at": time.time(), "latest": found})
+        except Exception:
+            # Offline or PyPI blip: try again in an hour, keep any known version.
+            holder["latest"] = latest or None
+            _save_state({
+                "checked_at": time.time() - CHECK_INTERVAL + FAIL_BACKOFF,
+                "latest": latest,
+            })
+
+    thread = threading.Thread(target=work, daemon=True)
+    holder["thread"] = thread
+    thread.start()
+    return holder
+
+
+def finish_update_check(holder):
+    """Print the notice on stderr once the check has had a moment to finish."""
+    if not holder:
+        return
+    thread = holder.get("thread")
+    if thread is not None:
+        thread.join(timeout=1.5)
+    latest = holder.get("latest")
+    if not is_newer(latest, __version__):
+        return
+    print(
+        f"\nA new release of muse-cli is available: {__version__} → {latest}\n"
+        f"To upgrade, run: {upgrade_command()}\n",
+        file=sys.stderr,
+    )
+
+
+def cmd_update(_args):
+    argv = upgrade_argv()
+    if argv[0] != sys.executable and shutil.which(argv[0]) is None:
+        print(f"{argv[0]} is not on PATH.", file=sys.stderr)
+        print(f"To upgrade, run: {upgrade_command()}", file=sys.stderr)
+        sys.exit(1)
+    print(f"running: {upgrade_command()}", file=sys.stderr)
+    import subprocess
+    raise SystemExit(subprocess.call(argv))