hypha-debugger 0.2.0__tar.gz → 0.2.2__tar.gz

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha-debugger
-Version: 0.2.0
+Version: 0.2.2
 Summary: Injectable debugger for Python processes and AI agents, powered by Hypha RPC
 Author: Amun AI AB
 License: MIT
@@ -20,6 +20,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: hypha-rpc>=0.20.0
 Requires-Dist: pydantic>=2.0
+Requires-Dist: certifi
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21; extra == "dev"

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/hypha_debugger/__init__.py

@@ -12,5 +12,5 @@ Usage (sync):
 
 from hypha_debugger.debugger import start_debugger, start_debugger_sync, DebugSession
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 __all__ = ["start_debugger", "start_debugger_sync", "DebugSession", "__version__"]

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/hypha_debugger/cli.py

@@ -22,6 +22,7 @@ after every ``hyd sh``. See any debugger's ``GET <url>/get_skill_md``.
 import json
 import os
 import shlex
+import ssl
 import sys
 import urllib.error
 import urllib.request
@@ -29,6 +30,24 @@ import urllib.request
 __all__ = ["main"]
 
 
+def _ssl_context() -> ssl.SSLContext:
+    """A TLS context that verifies certs using certifi's CA bundle when available.
+
+    Python's default context uses the system/OpenSSL trust store, which is often
+    missing or unconfigured (macOS framework Python, minimal containers, fresh
+    venvs) — causing CERTIFICATE_VERIFY_FAILED on HTTPS service URLs even though
+    `curl` works. certifi (a transitive dep of hypha-rpc) fixes that portably.
+    """
+    try:
+        import certifi
+        return ssl.create_default_context(cafile=certifi.where())
+    except Exception:
+        return ssl.create_default_context()
+
+
+_SSL_CTX = _ssl_context()
+
+
 class CliError(Exception):
     pass
 
@@ -114,6 +133,29 @@ def _normalize_url(url: str) -> str:
     return url.rstrip("/")
 
 
+# ---- profile type (terminal vs browser) ----------------------------------
+def _profile_type(profile: dict) -> str:
+    return profile.get("type", "terminal")
+
+
+def _infer_type(url: str) -> str:
+    """Guess the profile type from the service id in the URL."""
+    u = url.lower()
+    if "web-navigator" in u or "web-debugger" in u or "navigator" in u:
+        return "browser"
+    return "terminal"
+
+
+def _print_value(value) -> None:
+    """Print a service result: strings verbatim, everything else as JSON."""
+    if value is None:
+        return
+    if isinstance(value, str):
+        sys.stdout.write(value if value.endswith("\n") else value + "\n")
+    else:
+        print(json.dumps(value, indent=2, default=str))
+
+
 def _resolve_profile(explicit: str = "") -> tuple:
     """Return (name, profile_dict). Priority: -p flag > $HYD_PROFILE > sole profile."""
     profiles = _load_profiles()
@@ -141,7 +183,7 @@ def _call_remote(profile: dict, fn: str, params: dict, http_timeout: int = 75) -
     if profile.get("token"):
         req.add_header("Authorization", "Bearer " + profile["token"])
     try:
-        with urllib.request.urlopen(req, timeout=http_timeout) as resp:
+        with urllib.request.urlopen(req, timeout=http_timeout, context=_SSL_CTX) as resp:
             raw = resp.read().decode("utf-8", "replace")
     except urllib.error.HTTPError as e:
         body = e.read().decode("utf-8", "replace") if e.fp else ""
@@ -175,17 +217,7 @@ def _extract_opts(args: list) -> tuple:
     return opts, rest
 
 
-def cmd_sh(args: list, bare: bool = False) -> int:
-    if bare:
-        opts, command_parts = {"profile": "", "timeout": None, "cwd": ""}, args
-    else:
-        opts, command_parts = _extract_opts(args)
-    command = " ".join(command_parts).strip()
-    if not command:
-        raise CliError("nothing to run. Usage: hyd sh '<command>'")
-    _name, profile = _resolve_profile(opts["profile"])
-    cwd = opts["cwd"] or _env_cwd()
-    timeout = opts["timeout"] if opts["timeout"] is not None else 30
+def _run_shell(profile: dict, command: str, cwd: str, timeout: int) -> int:
     data = _call_remote(
         profile, "execute_bash",
         {"command": command, "cwd": cwd, "timeout": timeout},
@@ -200,12 +232,113 @@ def cmd_sh(args: list, bare: bool = False) -> int:
     return int(data.get("exit_code", 0) or 0)
 
 
+def _run_js(profile: dict, code: str, timeout: int) -> int:
+    data = _call_remote(profile, "execute_script", {"code": code}, http_timeout=(timeout or 60) + 15)
+    if isinstance(data, dict):
+        if data.get("error"):
+            sys.stderr.write(f"hyd: {data['error']}\n")
+            return 1
+        # execute_script returns {result, type, ...}; print just the result.
+        _print_value(data["result"] if "result" in data else data)
+    else:
+        _print_value(data)
+    return 0
+
+
+def cmd_run(args: list, bare: bool = False) -> int:
+    """Type-adaptive run: shell on a terminal profile, JavaScript on a browser one."""
+    if bare:
+        opts, parts = {"profile": "", "timeout": None, "cwd": ""}, args
+    else:
+        opts, parts = _extract_opts(args)
+    payload = " ".join(parts).strip()
+    if not payload:
+        raise CliError("nothing to run. Usage: hyd '<shell command or JS>'")
+    name, profile = _resolve_profile(opts["profile"])
+    timeout = opts["timeout"] if opts["timeout"] is not None else 30
+    if _profile_type(profile) == "browser":
+        return _run_js(profile, payload, timeout)
+    return _run_shell(profile, payload, opts["cwd"] or _env_cwd(), timeout)
+
+
+def cmd_sh(args: list) -> int:
+    opts, parts = _extract_opts(args)
+    command = " ".join(parts).strip()
+    if not command:
+        raise CliError("nothing to run. Usage: hyd sh '<command>'")
+    name, profile = _resolve_profile(opts["profile"])
+    if _profile_type(profile) == "browser":
+        raise CliError(f"profile '{name}' is a browser profile — use `hyd js '<code>'` (or bare `hyd '<code>'`).")
+    timeout = opts["timeout"] if opts["timeout"] is not None else 30
+    return _run_shell(profile, command, opts["cwd"] or _env_cwd(), timeout)
+
+
+def cmd_js(args: list) -> int:
+    opts, parts = _extract_opts(args)
+    code = " ".join(parts).strip()
+    if not code:
+        raise CliError("nothing to run. Usage: hyd js '<javascript>'")
+    name, profile = _resolve_profile(opts["profile"])
+    if _profile_type(profile) != "browser":
+        raise CliError(f"profile '{name}' is a terminal profile — use `hyd sh '<command>'`.")
+    timeout = opts["timeout"] if opts["timeout"] is not None else 30
+    return _run_js(profile, code, timeout)
+
+
+def cmd_call(args: list) -> int:
+    """Generic passthrough: call any service function. `hyd call <fn> [--json '{...}'] [k=v ...]`."""
+    opts, rest = _extract_opts(args)
+    if not rest:
+        raise CliError("usage: hyd call <function> [--json '{...}'] [key=value ...]")
+    fn, params = rest[0], {}
+    i = 1
+    while i < len(rest):
+        a = rest[i]
+        if a == "--json" and i + 1 < len(rest):
+            params.update(json.loads(rest[i + 1])); i += 2; continue
+        if "=" in a:
+            k, v = a.split("=", 1)
+            params[k] = v; i += 1; continue
+        i += 1
+    _name, profile = _resolve_profile(opts["profile"])
+    _print_value(_call_remote(profile, fn, params))
+    return 0
+
+
+def cmd_nav(args: list) -> int:
+    if not args:
+        raise CliError("usage: hyd nav <url>")
+    name, profile = _resolve_profile()
+    if _profile_type(profile) != "browser":
+        raise CliError(f"profile '{name}' is not a browser profile.")
+    _print_value(_call_remote(profile, "navigate", {"url": args[0]}))
+    return 0
+
+
+def cmd_shot(args: list) -> int:
+    import base64
+    name, profile = _resolve_profile()
+    if _profile_type(profile) != "browser":
+        raise CliError(f"profile '{name}' is not a browser profile.")
+    data = _call_remote(profile, "take_screenshot", {})
+    b64 = data.get("base64") or (data.get("data_url", "").split(",", 1)[-1] if data.get("data_url") else "")
+    if not b64:
+        raise CliError(f"no screenshot data: {data.get('error', data)}")
+    path = args[0] if args else "screenshot.png"
+    with open(path, "wb") as f:
+        f.write(base64.b64decode(b64))
+    print(path)
+    return 0
+
+
 def cmd_py(args: list) -> int:
     opts, code_parts = _extract_opts(args)
     code = " ".join(code_parts).strip()
     if not code:
         raise CliError("nothing to run. Usage: hyd py '<python code>'")
-    _name, profile = _resolve_profile(opts["profile"])
+    name, profile = _resolve_profile(opts["profile"])
+    if _profile_type(profile) == "browser":
+        raise CliError(f"profile '{name}' is a browser profile — use `hyd js '<code>'`.")
     data = _call_remote(profile, "execute_code", {"code": code})
     if isinstance(data, dict):
         if data.get("stdout"):
@@ -243,26 +376,30 @@ def cmd_profile_add(args: list) -> int:
     i = 0
     while i < len(args):
         a = args[i]
-        if a in ("--token", "--workspace") and i + 1 < len(args):
+        if a in ("--token", "--workspace", "--type") and i + 1 < len(args):
             opts[a.lstrip("-")] = args[i + 1]; i += 2; continue
         pos.append(a); i += 1
     if len(pos) < 2:
-        raise CliError("usage: hyd profile add <name> <service_url> [--token T] [--workspace W] [--use]")
+        raise CliError("usage: hyd profile add <name> <service_url> [--type terminal|browser] [--token T] [--use]")
     name, url = pos[0], _normalize_url(pos[1])
+    ptype = opts.get("type")
+    if ptype and ptype not in ("terminal", "browser"):
+        raise CliError("--type must be 'terminal' or 'browser'")
     profiles = _load_profiles()
     entry = profiles.get(name, {})
     entry["service_url"] = url
+    entry["type"] = ptype or entry.get("type") or _infer_type(url)
     if opts.get("token"):
         entry["token"] = opts["token"]
     if opts.get("workspace"):
         entry["workspace"] = opts["workspace"]
     profiles[name] = entry
     _save_profiles(profiles)
+    label = f"{url} [{entry['type']}]"
     if use:
-        _emit_state({"HYD_PROFILE": name}, human=f"profile '{name}' -> {url} (now active)")
+        _emit_state({"HYD_PROFILE": name}, human=f"profile '{name}' -> {label} (now active)")
     else:
-        # No current-state change → just confirm (eval-safe comment).
-        print(f"# profile '{name}' -> {url}   (activate: export HYD_PROFILE={name})")
+        print(f"# profile '{name}' -> {label}   (activate: export HYD_PROFILE={name})")
     return 0
 
 
@@ -275,7 +412,7 @@ def cmd_profile_list(_args: list) -> int:
     for name, p in profiles.items():
         mark = "*" if name == active else " "
         tok = " (token)" if p.get("token") else ""
-        print(f"{mark} {name}  {p.get('service_url', '')}{tok}")
+        print(f"{mark} {name}  [{_profile_type(p)}]  {p.get('service_url', '')}{tok}")
     return 0
 
 
@@ -331,11 +468,16 @@ def cmd_status(_args: list) -> int:
         name, profile = _resolve_profile()
     except CliError as e:
         print(e); return 1
-    print(f"profile: {name}   cwd: {_env_cwd() or '(remote default)'}   (HYD_PROFILE/HYD_CWD)")
+    ptype = _profile_type(profile)
+    print(f"profile: {name} [{ptype}]   cwd: {_env_cwd() or '(remote default)'}   (HYD_PROFILE/HYD_CWD)")
     print(f"url: {_normalize_url(profile['service_url'])}")
     try:
-        info = _call_remote(profile, "get_process_info", {})
-        print(f"connected: pid={info.get('pid')} host={info.get('hostname')} py={info.get('python_version')}")
+        if ptype == "browser":
+            info = _call_remote(profile, "get_page_info", {})
+            print(f"connected: url={info.get('url')} title={info.get('title')}")
+        else:
+            info = _call_remote(profile, "get_process_info", {})
+            print(f"connected: pid={info.get('pid')} host={info.get('hostname')} py={info.get('python_version')}")
     except CliError as e:
         print(f"UNREACHABLE: {e}"); return 1
     return 0
@@ -359,17 +501,20 @@ def cmd_shell_init(_args: list) -> int:
 
 def _print_help() -> int:
     print(
-        """hyd — Hypha remote debugger CLI (run remote shell commands with minimal overhead)
+        """hyd — Hypha remote CLI: drive a terminal (Python process) OR a browser with minimal overhead
 
-USAGE
-  hyd sh '<command>'            Run a shell command on the active profile (cwd via HYD_CWD)
-  hyd '<command>'              Same (bare form; anything not a subcommand runs as a command)
-  hyd py '<python>'            Run Python via the debugger's execute_code
-  hyd -p <profile> sh '...'    Run against a specific profile (overrides HYD_PROFILE)
+USAGE (adapts to the active profile's type)
+  hyd '<x>'                    Bare: runs <x> as SHELL on a terminal profile, JAVASCRIPT on a browser one
+  hyd sh '<command>'           Force a shell command (terminal profile; cwd via HYD_CWD)
+  hyd js '<javascript>'        Force JavaScript (browser profile) — returns the result
+  hyd py '<python>'            Run Python via execute_code (terminal profile)
+  hyd call <fn> [--json '{…}'] [k=v …]   Call ANY service function (either type)
+  hyd nav <url> | shot [file]  Browser: navigate / save a screenshot (PNG)
+  hyd -p <profile> …           Run against a specific profile (overrides HYD_PROFILE)
 
-PROFILES (machines — stored on disk)
-  hyd profile add <name> <service_url> [--token T] [--workspace W] [--use]
-  hyd profile list | show <name> | rm <name>
+PROFILES (machines — stored on disk; each has a type: terminal|browser)
+  hyd profile add <name> <service_url> [--type terminal|browser] [--token T] [--use]
+  hyd profile list | show <name> | rm <name>       (type inferred from the URL if omitted)
 
 CURRENT STATE (env vars, per-terminal — NOT on disk)
   export HYD_PROFILE=<name>    Select the active profile for this shell
@@ -397,10 +542,20 @@ def main(argv=None) -> int:
             from hypha_debugger import __version__
             print(f"hyd (hypha-debugger) {__version__}")
             return 0
-        if cmd in ("sh", "run", "exec"):
+        if cmd in ("run", "exec"):
+            return cmd_run(argv[1:])
+        if cmd == "sh":
             return cmd_sh(argv[1:])
+        if cmd == "js":
+            return cmd_js(argv[1:])
         if cmd == "py":
             return cmd_py(argv[1:])
+        if cmd == "call":
+            return cmd_call(argv[1:])
+        if cmd == "nav":
+            return cmd_nav(argv[1:])
+        if cmd == "shot":
+            return cmd_shot(argv[1:])
         if cmd in ("profile", "profiles"):
             return cmd_profile(argv[1:] if cmd == "profile" else ["list"] + argv[1:])
         if cmd == "use":
@@ -413,8 +568,9 @@ def main(argv=None) -> int:
             return cmd_status(argv[1:])
         if cmd == "shell-init":
             return cmd_shell_init(argv[1:])
-        # Bare fallback: the whole argv is a shell command.
-        return cmd_sh(argv, bare=True)
+        # Bare fallback: run the whole argv, dispatching by profile type
+        # (shell on a terminal profile, JavaScript on a browser one).
+        return cmd_run(argv, bare=True)
     except CliError as e:
         sys.stderr.write(f"hyd: {e}\n")
         return 2

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/hypha_debugger/services/source.py

@@ -90,18 +90,20 @@ def _get_skill_md_impl() -> str:
 
 ## Overview
 A remote debugger is attached to a running Python process. You have full access
-to execute code, read/write files, inspect variables, and install packages.
+to run shell + Python, read/write files, inspect variables, and install packages.
 
-**Recommended approach**: Use `execute_code` as your primary tool — it's a
-persistent Python REPL where variables, imports, and functions survive across
-calls. The other endpoints are convenience shortcuts.
+**START HERE → install the `hyd` CLI (next section).** Decision rule: if you'll run
+more than ~2 commands here (i.e. almost any real task), `hyd` is the intended
+interface — one `pip install`, then every command is a short `hyd sh '…'` /
+`hyd py '…'` with the connection + working directory remembered for you, far fewer
+tokens than re-sending an authenticated curl each time, and it behaves like a local
+shell. Only for a single throwaway call is raw curl (further down) simpler. The raw
+HTTP API is the low-level fallback and powers the CLI.
 
-## Fast path — the `hyd` CLI (recommended for agents)
+## Fast path — the `hyd` CLI (do this first)
 
-For repeated shell work, don't hand-write authenticated curl calls — install the
-`hyd` client CLI once and run remote commands with almost no per-call overhead.
-It stores this connection as a named **profile** (URL + token) on disk, so later
-calls carry no auth or JSON boilerplate. Bootstrap yourself:
+Bootstrap yourself in three lines (THIS_SERVICE_URL = the URL you fetched this doc
+from, without the trailing `/get_skill_md`):
 
 ```bash
 pip install hypha-debugger            # ships the `hyd` command
@@ -111,8 +113,13 @@ export HYD_PROFILE=main               # select it (env var — per-terminal, not
 hyd sh 'uname -a && pwd'              # run a remote shell command
 hyd 'ls -la'                         # bare form: anything not a subcommand runs as a command
 hyd py 'import sys; sys.version'      # run Python via execute_code
+hyd status                           # confirm it's connected
 ```
 
+If the `hyd` command isn't on your PATH after install (e.g. a `--user` install),
+either add the install bin dir to PATH or just use `python -m hypha_debugger.cli`
+in place of `hyd` — identical arguments (`python -m hypha_debugger.cli sh 'pwd'`).
+
 Key ideas:
 - **The remote is stateless.** The "current directory" and "current profile" live
   in the environment variables `HYD_CWD` and `HYD_PROFILE` (per shell), so different
@@ -122,6 +129,13 @@ Key ideas:
   `hyd sh`.
 - **Multiple machines**: add more profiles (`hyd profile add other "<url>" --token …`)
   and switch with `export HYD_PROFILE=other` or a one-off `hyd -p other sh '…'`.
+- **Terminal *or* browser**: each profile has a `type` (inferred from the URL). A
+  terminal profile (this Python debugger) runs shell/Python; a `browser` profile (a
+  Hypha Navigator web service) runs JavaScript. The SAME bare `hyd '<x>'` adapts —
+  shell on a terminal profile, JS on a browser one — or force it with `hyd sh` /
+  `hyd js`. `hyd call <fn> [--json '{…}']` calls any function; `hyd nav <url>` /
+  `hyd shot [file]` are browser shortcuts. Example:
+  `hyd profile add web "<navigator-url>" --type browser --use && hyd 'document.title'`.
 - `hyd sh` streams stdout/stderr and exits with the remote command's exit code, so
   it behaves like a local shell. Run `hyd` (no args) for full help.
 

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/hypha_debugger.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha-debugger
-Version: 0.2.0
+Version: 0.2.2
 Summary: Injectable debugger for Python processes and AI agents, powered by Hypha RPC
 Author: Amun AI AB
 License: MIT
@@ -20,6 +20,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: hypha-rpc>=0.20.0
 Requires-Dist: pydantic>=2.0
+Requires-Dist: certifi
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21; extra == "dev"

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/hypha_debugger.egg-info/requires.txt

@@ -1,5 +1,6 @@
 hypha-rpc>=0.20.0
 pydantic>=2.0
+certifi
 
 [dev]
 pytest>=7.0

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypha-debugger"
-version = "0.2.0"
+version = "0.2.2"
 description = "Injectable debugger for Python processes and AI agents, powered by Hypha RPC"
 readme = "README.md"
 license = {text = "MIT"}
@@ -25,6 +25,7 @@ classifiers = [
 dependencies = [
     "hypha-rpc>=0.20.0",
     "pydantic>=2.0",
+    "certifi",
 ]
 
 [project.urls]

{hypha_debugger-0.2.0 → hypha_debugger-0.2.2}/tests/test_cli.py

@@ -116,6 +116,59 @@ def test_bare_fallback_runs_as_command(cfg, monkeypatch):
     assert seen["command"] == "ls -la"
 
 
+def test_type_inference_browser_and_terminal(cfg):
+    cli.main(["profile", "add", "web", "https://h.io/services/web-navigator-abc"])
+    cli.main(["profile", "add", "box", "https://h.io/services/py-debugger-xyz"])
+    profs = cli._load_profiles()
+    assert profs["web"]["type"] == "browser"
+    assert profs["box"]["type"] == "terminal"
+
+
+def test_type_explicit_override(cfg):
+    cli.main(["profile", "add", "x", "https://h.io/services/anything", "--type", "browser"])
+    assert cli._load_profiles()["x"]["type"] == "browser"
+
+
+def test_bare_dispatches_by_type(cfg, monkeypatch):
+    cli.main(["profile", "add", "web", "https://h.io/services/web-navigator-abc"])
+    monkeypatch.setenv("HYD_PROFILE", "web")
+    seen = {}
+    monkeypatch.setattr(cli, "_call_remote", lambda profile, fn, params, http_timeout=75: seen.update(fn=fn, params=params) or {"result": "My Page", "type": "string"})
+    rc = cli.main(["document.title"])  # bare, browser profile -> execute_script
+    assert rc == 0 and seen["fn"] == "execute_script" and seen["params"]["code"] == "document.title"
+
+
+def test_js_result_printed(cfg, monkeypatch, capsys):
+    cli.main(["profile", "add", "web", "https://h.io/services/web-navigator-abc"])
+    monkeypatch.setenv("HYD_PROFILE", "web")
+    monkeypatch.setattr(cli, "_call_remote", lambda *a, **k: {"result": {"a": 1}, "type": "object"})
+    cli.main(["js", "({a:1})"])
+    assert '"a": 1' in capsys.readouterr().out
+
+
+def test_sh_rejects_browser_profile(cfg, monkeypatch, capsys):
+    cli.main(["profile", "add", "web", "https://h.io/services/web-navigator-abc"])
+    monkeypatch.setenv("HYD_PROFILE", "web")
+    rc = cli.main(["sh", "ls"])
+    assert rc == 2 and "browser profile" in capsys.readouterr().err
+
+
+def test_js_rejects_terminal_profile(cfg, monkeypatch, capsys):
+    cli.main(["profile", "add", "box", "https://h.io/services/py-debugger-xyz"])
+    monkeypatch.setenv("HYD_PROFILE", "box")
+    rc = cli.main(["js", "1+1"])
+    assert rc == 2 and "terminal profile" in capsys.readouterr().err
+
+
+def test_call_generic_passthrough(cfg, monkeypatch):
+    cli.main(["profile", "add", "web", "https://h.io/services/web-navigator-abc"])
+    monkeypatch.setenv("HYD_PROFILE", "web")
+    seen = {}
+    monkeypatch.setattr(cli, "_call_remote", lambda profile, fn, params, http_timeout=75: seen.update(fn=fn, params=params) or {"ok": True})
+    cli.main(["call", "navigate", "--json", '{"url":"https://x.com"}'])
+    assert seen["fn"] == "navigate" and seen["params"]["url"] == "https://x.com"
+
+
 def test_p_flag_selects_profile(cfg, monkeypatch):
     cli.main(["profile", "add", "a", "https://a.io/s/1"])
     cli.main(["profile", "add", "b", "https://b.io/s/2"])