yoru-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{yoru_cli-0.1.2 → yoru_cli-0.1.3}/.gitignore

@@ -70,3 +70,10 @@ backend/receipt.db
 # Runtime caches populated by pricing warmup etc.
 backend/data/*.json
 .saasforge
+
+# Local-auth JWT signing secret (auto-generated, machine-local — NEVER commit)
+backend/data/.auth_jwt_secret
+
+# Embedding cache (trovex / fastembed)
+.fastembed_cache/
+.vercel

{yoru_cli-0.1.2 → yoru_cli-0.1.3}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: yoru-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Yoru — audit-grade session receipts for autonomous AI coding agents.
 Project-URL: Homepage, https://yoru.sh
 Project-URL: Documentation, https://yoru.sh/docs
-Project-URL: Repository, https://github.com/yoru-sh/cli
-Project-URL: Issues, https://github.com/yoru-sh/cli/issues
+Project-URL: Repository, https://github.com/TsukumoHQ/cli-yoru
+Project-URL: Issues, https://github.com/TsukumoHQ/cli-yoru/issues
 Author-email: Yoru authors <hello@yoru.sh>
 License: MIT
 License-File: LICENSE
@@ -35,19 +35,18 @@ The Claude Code hook installer for Yoru. One command installs a `PostToolUse` ho
 
 ```bash
 pip install yoru-cli
-yoru init
+yoru init --server https://yoru.acme.com
 ```
 
-`yoru init` opens a pairing URL in your browser, writes `~/.claude/hooks/yoru.sh`, and registers the hook in `~/.claude/settings.json`. By default it points at Yoru Cloud ([yoru.sh](https://yoru.sh)) — free forever for one developer.
+Yoru is **self-hosted** — point the CLI at your own backend with `--server`. `yoru init` opens a pairing URL in your browser, writes `~/.claude/hooks/yoru.sh`, and registers the hook in `~/.claude/settings.json`. Don't have a server yet? [Stand one up](https://github.com/TsukumoHQ/yoru) — `docker-compose up`.
 
 Requires Python 3.10+. One runtime dep: `httpx`.
 
 ## Usage
 
 ```bash
-yoru init                               # pair against https://api.yoru.sh
-yoru init --server https://yoru.acme    # pair against your self-hosted server
-yoru init --token yoru_xxx --force      # non-interactive (CI / scripted rotation)
+yoru init --server https://yoru.acme.com       # pair against your server (--server required)
+yoru init --server https://yoru.acme.com --token yoru_xxx --force   # non-interactive (CI / scripted rotation)
 
 yoru tail < events.jsonl                # post a batch of events (debug)
 
@@ -69,8 +68,8 @@ It uses `curl --max-time 2 || true` so a Yoru outage never stalls your terminal
 
 ## Self-host the server
 
-The CLI is MIT. The server (backend + dashboard) is AGPL-3.0 and lives at **[github.com/yoru-sh/yoru](https://github.com/yoru-sh/yoru)**. `docker-compose up`, then `yoru init --server https://your-host` — done.
+The CLI is MIT. The server (backend + dashboard) is AGPL-3.0 and lives at **[github.com/TsukumoHQ/yoru](https://github.com/TsukumoHQ/yoru)**. `docker-compose up`, then `yoru init --server https://your-host` — done. There is no hosted Yoru; you run it.
 
 ## License
 
-[MIT](./LICENSE) · Copyright (c) 2026 Yoru authors. Issues and PRs welcome at [github.com/yoru-sh/cli](https://github.com/yoru-sh/cli).
+[MIT](./LICENSE) · Copyright (c) 2026 Yoru authors. Issues and PRs welcome at [github.com/TsukumoHQ/cli-yoru](https://github.com/TsukumoHQ/cli-yoru).

{yoru_cli-0.1.2 → yoru_cli-0.1.3}/README.md

@@ -9,19 +9,18 @@ The Claude Code hook installer for Yoru. One command installs a `PostToolUse` ho
 
 ```bash
 pip install yoru-cli
-yoru init
+yoru init --server https://yoru.acme.com
 ```
 
-`yoru init` opens a pairing URL in your browser, writes `~/.claude/hooks/yoru.sh`, and registers the hook in `~/.claude/settings.json`. By default it points at Yoru Cloud ([yoru.sh](https://yoru.sh)) — free forever for one developer.
+Yoru is **self-hosted** — point the CLI at your own backend with `--server`. `yoru init` opens a pairing URL in your browser, writes `~/.claude/hooks/yoru.sh`, and registers the hook in `~/.claude/settings.json`. Don't have a server yet? [Stand one up](https://github.com/TsukumoHQ/yoru) — `docker-compose up`.
 
 Requires Python 3.10+. One runtime dep: `httpx`.
 
 ## Usage
 
 ```bash
-yoru init                               # pair against https://api.yoru.sh
-yoru init --server https://yoru.acme    # pair against your self-hosted server
-yoru init --token yoru_xxx --force      # non-interactive (CI / scripted rotation)
+yoru init --server https://yoru.acme.com       # pair against your server (--server required)
+yoru init --server https://yoru.acme.com --token yoru_xxx --force   # non-interactive (CI / scripted rotation)
 
 yoru tail < events.jsonl                # post a batch of events (debug)
 
@@ -43,8 +42,8 @@ It uses `curl --max-time 2 || true` so a Yoru outage never stalls your terminal
 
 ## Self-host the server
 
-The CLI is MIT. The server (backend + dashboard) is AGPL-3.0 and lives at **[github.com/yoru-sh/yoru](https://github.com/yoru-sh/yoru)**. `docker-compose up`, then `yoru init --server https://your-host` — done.
+The CLI is MIT. The server (backend + dashboard) is AGPL-3.0 and lives at **[github.com/TsukumoHQ/yoru](https://github.com/TsukumoHQ/yoru)**. `docker-compose up`, then `yoru init --server https://your-host` — done. There is no hosted Yoru; you run it.
 
 ## License
 
-[MIT](./LICENSE) · Copyright (c) 2026 Yoru authors. Issues and PRs welcome at [github.com/yoru-sh/cli](https://github.com/yoru-sh/cli).
+[MIT](./LICENSE) · Copyright (c) 2026 Yoru authors. Issues and PRs welcome at [github.com/TsukumoHQ/cli-yoru](https://github.com/TsukumoHQ/cli-yoru).

{yoru_cli-0.1.2 → yoru_cli-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yoru-cli"
-version = "0.1.2"
+version = "0.1.3"
 description = "Yoru — audit-grade session receipts for autonomous AI coding agents."
 license = { text = "MIT" }
 license-files = ["LICENSE"]
@@ -23,8 +23,8 @@ dependencies = ["httpx>=0.27"]
 [project.urls]
 Homepage = "https://yoru.sh"
 Documentation = "https://yoru.sh/docs"
-Repository = "https://github.com/yoru-sh/cli"
-Issues = "https://github.com/yoru-sh/cli/issues"
+Repository = "https://github.com/TsukumoHQ/cli-yoru"
+Issues = "https://github.com/TsukumoHQ/cli-yoru/issues"
 
 [project.scripts]
 yoru = "yoru_cli.cli:main"

yoru_cli-0.1.3/src/yoru_cli/api.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+class ReceiptClient:
+    def __init__(self, base_url: str, token: str | None = None) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+
+    def start_device_code(self, label: str | None = None) -> dict[str, Any]:
+        """Begin the device-pairing handshake — no auth needed."""
+        r = httpx.post(
+            f"{self.base_url}/api/v1/auth/device-code",
+            json={"label": label} if label else {},
+            timeout=5.0,
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def poll_device_code(self, device_code: str) -> dict[str, Any]:
+        """Poll for approval — returns {status, token?}."""
+        r = httpx.post(
+            f"{self.base_url}/api/v1/auth/device-code/poll",
+            json={"device_code": device_code},
+            timeout=10.0,
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def post_events(self, events: list[dict[str, Any]]) -> httpx.Response:
+        headers = {"Authorization": f"Bearer {self.token}"} if self.token else {}
+        return httpx.post(
+            f"{self.base_url}/api/v1/sessions/events",
+            json={"events": events},
+            headers=headers,
+            timeout=5.0,
+        )
+
+    def share_session(self, session_id: str) -> dict[str, Any]:
+        """Flip a session public (#79). Requires bearer token — 401 otherwise.
+
+        Backend is idempotent: re-POST on an already-public session returns
+        the same `public_url`. 404 on cross-user (token's user doesn't own
+        this session) — callers should treat that as "not your session".
+        """
+        if not self.token:
+            raise RuntimeError("share_session requires authentication (run `yoru init`)")
+        r = httpx.post(
+            f"{self.base_url}/api/v1/sessions/{session_id}/share",
+            json={"source": "cli"},
+            headers={"Authorization": f"Bearer {self.token}"},
+            timeout=10.0,
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def revoke_share(self, session_id: str) -> dict[str, Any]:
+        """Flip a session back to private (#79). Idempotent."""
+        if not self.token:
+            raise RuntimeError("revoke_share requires authentication (run `yoru init`)")
+        r = httpx.post(
+            f"{self.base_url}/api/v1/sessions/{session_id}/share/revoke",
+            headers={"Authorization": f"Bearer {self.token}"},
+            timeout=10.0,
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def get_share_consent(self) -> dict[str, Any]:
+        """Returns {consented: bool, at: str|None} for the authenticated user."""
+        if not self.token:
+            raise RuntimeError("get_share_consent requires authentication")
+        r = httpx.get(
+            f"{self.base_url}/api/v1/account/share-consent",
+            headers={"Authorization": f"Bearer {self.token}"},
+            timeout=5.0,
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def post_share_consent(self) -> dict[str, Any]:
+        """Stamp share consent for the authenticated user (idempotent)."""
+        if not self.token:
+            raise RuntimeError("post_share_consent requires authentication")
+        r = httpx.post(
+            f"{self.base_url}/api/v1/account/share-consent",
+            headers={"Authorization": f"Bearer {self.token}"},
+            timeout=5.0,
+        )
+        r.raise_for_status()
+        return r.json()

yoru_cli-0.1.3/src/yoru_cli/cli.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import argparse
+
+from . import __version__
+from . import config, doctor_cmd, init_cmd, share_cmd, tail_cmd, update_cmd
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="yoru",
+        description="Yoru — audit-grade session receipts for autonomous AI coding agents.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"yoru {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="cmd", required=True, metavar="{init,tail,doctor,share,update}"
+    )
+
+    p_init = subparsers.add_parser(
+        "init",
+        help="Install the Claude Code hook and write ~/.config/yoru/config.json.",
+    )
+    p_init.add_argument(
+        "--server",
+        required=True,
+        help="Backend URL of your Yoru server, e.g. https://yoru.acme.com. "
+             "Yoru is self-hosted — there is no default server.",
+    )
+    p_init.add_argument(
+        "--token",
+        default=None,
+        help="Pre-minted hook token (rcpt_...) — for headless/CI/server setups. "
+             "Also read from $YORU_TOKEN. Without this, yoru init launches "
+             "interactive device pairing.",
+    )
+    p_init.add_argument(
+        "--label",
+        default=None,
+        help="Human-readable machine label shown in the dashboard "
+             "(default: <hostname> · <os>).",
+    )
+    p_init.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Don't try to auto-open the pairing URL in a browser.",
+    )
+    p_init.add_argument("--force", action="store_true", help="Overwrite an existing install.")
+
+    p_tail = subparsers.add_parser(
+        "tail",
+        help="Read JSON events from stdin and POST them as a batch (dev/debug).",
+    )
+    p_tail.add_argument(
+        "--server",
+        default=None,
+        help="Backend URL (default: the server saved in config by `yoru init`).",
+    )
+    p_tail.add_argument("--session-id", default=None, help="Session id to stamp on events missing one.")
+
+    subparsers.add_parser(
+        "doctor",
+        help="Diagnose the install: config, backend, token, hook.",
+    )
+
+    p_share = subparsers.add_parser(
+        "share",
+        help="Flip a session public and copy its yoru.sh/s/<id> URL to the clipboard.",
+    )
+    p_share.add_argument(
+        "session_id",
+        help="Session id to share (or revoke). Find it in the dashboard URL or the session header.",
+    )
+    p_share.add_argument(
+        "--revoke",
+        action="store_true",
+        help="Flip the session back to private instead of sharing it.",
+    )
+
+    p_update = subparsers.add_parser(
+        "update",
+        help="Self-update the CLI to the latest release (pip), and refresh the hook.",
+    )
+    p_update.add_argument(
+        "--force",
+        action="store_true",
+        help="Bypass the dev-build and no-downgrade guards (explicit reinstall/downgrade).",
+    )
+    p_update.add_argument(
+        "--check",
+        action="store_true",
+        help="Report whether an update is available and exit — install nothing.",
+    )
+    p_update.add_argument(
+        "--server",
+        nargs="?",
+        const="",
+        default=None,
+        metavar="URL",
+        help="Check the running SERVER's version (notify-only) instead of self-updating "
+        "the CLI. Bare --server uses your configured server; --server URL targets that "
+        "instance. Never pulls or restarts the server.",
+    )
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.cmd == "tail" and args.server is None:
+        cfg = config.load() or {}
+        args.server = cfg.get("server")
+        if not args.server:
+            parser.error(
+                "no server configured — run `yoru init --server <url>` first, "
+                "or pass --server explicitly."
+            )
+
+    if args.cmd == "init":
+        return init_cmd.run(args)
+    if args.cmd == "tail":
+        return tail_cmd.run(args)
+    if args.cmd == "doctor":
+        return doctor_cmd.run(args)
+    if args.cmd == "share":
+        return share_cmd.run(args)
+    if args.cmd == "update":
+        return update_cmd.run(args)
+
+    parser.error(f"unknown command: {args.cmd!r}")
+    return 2

{yoru_cli-0.1.2 → yoru_cli-0.1.3}/src/yoru_cli/hook_template.py

@@ -81,24 +81,23 @@ if git_branch: e["git_branch"] = git_branch
 hen=e.get("hook_event_name")
 if hen=="SessionStart":
     e["kind"]="session_start"
-elif hen=="UserPromptSubmit":
-    e["kind"]="message"
-    e["tool"]="user"
-    p=e.get("prompt")
-    if isinstance(p,str) and p: e["content"]=p[:2000]
-elif hen=="Notification":
-    e["kind"]="message"
-    e["tool"]="notification"
-    m=e.get("message")
-    if isinstance(m,str) and m: e["content"]=m[:2000]
-elif hen=="SubagentStop":
-    e["kind"]="message"
-    e["tool"]="subagent"
-    e["content"]="subagent stopped"
 elif hen=="Stop":
     e["kind"]="session_end"
-# PostToolUse / PreToolUse: leave kind unset → backend _infer_kind() from tool
+    # Discreet share CTA after session_end (surfaced via hook stderr).
+    # (avoid apostrophes here - this block is inside a bash $(python3 -c '...'))
+    sid_stop = original.get("session_id") or original.get("sessionId") or ""
+    if isinstance(sid_stop, str) and sid_stop:
+        try:
+            sys.stderr.write(f"\\n[yoru] session ended - make it public: yoru share {sid_stop}\\n")
+        except Exception:
+            pass
+else:
+    # Tool calls, prompts, notifications now come from the durable transcript
+    # tailer (yoru_cli.transcript_tailer): single source, no duplicates, and
+    # they survive backend downtime. The hook only ships session lifecycle.
+    sys.exit(0)
 print(json.dumps({"events":[e]}))')
+[ -z "${BODY}" ] && exit 0
 curl -sS --max-time 2 -X POST "${SERVER}/api/v1/sessions/events" \\
   -H "Authorization: Bearer ${TOKEN}" \\
   -H "Content-Type: application/json" \\

{yoru_cli-0.1.2 → yoru_cli-0.1.3}/src/yoru_cli/init_cmd.py

@@ -143,6 +143,22 @@ def _pair_device(server: str, label: str, *, no_browser: bool) -> str | None:
     return None
 
 
+def refresh_hook_assets() -> tuple[Path, Path]:
+    """(Re)write the Claude Code hook script and (re)register it in
+    settings.json. Idempotent — used by `init` (first install) and `update`
+    (refresh the hook to the new version + repair the settings wiring). Returns
+    (hook_path, settings_path). Does NOT touch config (server/token)."""
+    hook_dir = Path.home() / ".claude" / "hooks"
+    hook_path = hook_dir / "yoru.sh"
+    os.makedirs(hook_dir, exist_ok=True)
+    hook_path.write_text(HOOK_SCRIPT, encoding="utf-8")
+    os.chmod(hook_path, 0o755)
+
+    settings_path = Path.home() / ".claude" / "settings.json"
+    _merge_settings_json(settings_path, hook_path)
+    return hook_path, settings_path
+
+
 def run(args: argparse.Namespace) -> int:
     if config.exists() and not getattr(args, "force", False):
         print("Already installed (use --force to overwrite)", file=sys.stderr)
@@ -167,14 +183,7 @@ def run(args: argparse.Namespace) -> int:
         "created_at": datetime.now(timezone.utc).isoformat(),
     })
 
-    hook_dir = Path.home() / ".claude" / "hooks"
-    hook_path = hook_dir / "yoru.sh"
-    os.makedirs(hook_dir, exist_ok=True)
-    hook_path.write_text(HOOK_SCRIPT, encoding="utf-8")
-    os.chmod(hook_path, 0o755)
-
-    settings_path = Path.home() / ".claude" / "settings.json"
-    _merge_settings_json(settings_path, hook_path)
+    refresh_hook_assets()
 
     print("\u2713 config   \u2192 ~/.config/yoru/config.json")
     print("\u2713 hook     \u2192 ~/.claude/hooks/yoru.sh")

yoru_cli-0.1.3/src/yoru_cli/share_cmd.py

@@ -0,0 +1,188 @@
+"""`yoru share` — public-share toggle for an agent session. Issue #80.
+
+Two flows:
+
+  yoru share <session-id>            # flip public, copy URL
+  yoru share --revoke <session-id>   # flip back to private
+
+Consent: the first-ever share on an account prompts for explicit
+acknowledgment ("prompts and file paths will be visible"). The decision
+is persisted server-side (users.share_consent_given_at) so it follows
+the account across machines — a second machine running `yoru share`
+won't re-ask. Previously stored in ~/.config/yoru/share-confirmed; the
+local file is obsolete and is now ignored if it exists.
+
+Clipboard: we try `pbcopy` on Darwin and `xclip -selection clipboard`
+elsewhere; on failure we just print the URL loudly enough to copy from
+terminal. No pyperclip dep on purpose — the std-lib `subprocess` path
+works everywhere we ship.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import subprocess
+import sys
+
+import httpx
+
+from . import config
+from .api import ReceiptClient
+
+
+def _prompt_consent() -> bool:
+    """Interactive one-time acknowledgment. Non-interactive callers (CI,
+    piped stdin) can set YORU_SHARE_CONSENT=yes to skip."""
+    if os.environ.get("YORU_SHARE_CONSENT", "").strip().lower() in ("1", "yes", "true"):
+        return True
+    if not sys.stdin.isatty():
+        print(
+            "error: `yoru share` needs an interactive TTY the first time so "
+            "you can confirm the public-disclosure terms. Re-run from a "
+            "terminal, or set YORU_SHARE_CONSENT=yes if you're scripting.",
+            file=sys.stderr,
+        )
+        return False
+
+    print()
+    print("  Make this session publicly shareable?")
+    print()
+    print("  Visible publicly: prompts, tool calls, file paths, red flags, grade.")
+    print("  Always redacted: content of any event flagged secret_* (AWS / Stripe /")
+    print("                   JWT / SSH / Anthropic key / Postgres URL / etc.).")
+    print()
+    print("  You'll only be asked once per account. Revoke any specific share at any")
+    print("  time with `yoru share --revoke <id>`.")
+    print()
+    try:
+        ans = input("  Share? [y/N]: ").strip().lower()
+    except EOFError:
+        return False
+    return ans in ("y", "yes")
+
+
+def _copy_to_clipboard(text: str) -> bool:
+    """Best-effort clipboard copy. Returns True if a copy command succeeded."""
+    if platform.system() == "Darwin":
+        cmd = ["pbcopy"]
+    elif platform.system() == "Linux":
+        # xclip is the most common; wl-copy (Wayland) would be a worthy add.
+        cmd = ["xclip", "-selection", "clipboard"]
+    else:
+        return False
+    try:
+        subprocess.run(cmd, input=text.encode("utf-8"), check=True, timeout=2)
+        return True
+    except (FileNotFoundError, subprocess.CalledProcessError, subprocess.TimeoutExpired):
+        return False
+
+
+def _format_tweet(url: str) -> str:
+    """Pre-filled tweet text the user can paste after copying the URL.
+
+    Intentionally short — the *link* carries most of the payload; the
+    tweet needs just enough framing that a dev scrolling past knows what
+    they're looking at.
+    """
+    return (
+        f"look what my Claude Code session just did — {url}\n\n"
+        "(yoru.sh — audit-grade trails for AI coding agents)"
+    )
+
+
+def run(args: argparse.Namespace) -> int:
+    cfg = config.load()
+    if cfg is None:
+        print("error: not configured — run `yoru init` first.", file=sys.stderr)
+        return 1
+    server = (cfg.get("server") or "").rstrip("/")
+    token = cfg.get("token") or ""
+    if not server or not token:
+        print("error: config missing server or token — re-run `yoru init`.", file=sys.stderr)
+        return 1
+
+    session_id = (getattr(args, "session_id", None) or "").strip()
+    if not session_id:
+        print(
+            "error: missing <session-id>. Usage: yoru share <session-id> "
+            "[--revoke]",
+            file=sys.stderr,
+        )
+        return 2
+    revoke = bool(getattr(args, "revoke", False))
+
+    client = ReceiptClient(server, token=token)
+
+    # Revoke path — no consent check, no clipboard. Fast and quiet.
+    if revoke:
+        try:
+            resp = client.revoke_share(session_id)
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                print(
+                    f"error: session {session_id} not found (or not owned by this account).",
+                    file=sys.stderr,
+                )
+                return 3
+            print(f"error: revoke failed: {e}", file=sys.stderr)
+            return 4
+        except httpx.HTTPError as e:
+            print(f"error: revoke failed: {e}", file=sys.stderr)
+            return 4
+        print(f"✓ session {session_id} is private again.")
+        return 0
+
+    # Share path — consent is server-side now (one stamp per account).
+    try:
+        consent = client.get_share_consent()
+    except httpx.HTTPError as e:
+        print(f"error: couldn't check share consent: {e}", file=sys.stderr)
+        return 4
+
+    if not consent.get("consented"):
+        ok = _prompt_consent()
+        if not ok:
+            print("  aborted — session stays private.")
+            return 0
+        try:
+            client.post_share_consent()
+        except httpx.HTTPError as e:
+            print(
+                f"error: couldn't save consent (not stamping server-side): {e}",
+                file=sys.stderr,
+            )
+            return 4
+
+    try:
+        resp = client.share_session(session_id)
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 404:
+            print(
+                f"error: session {session_id} not found (or not owned by this account).",
+                file=sys.stderr,
+            )
+            return 3
+        print(f"error: share failed: {e}", file=sys.stderr)
+        return 4
+    except httpx.HTTPError as e:
+        print(f"error: share failed: {e}", file=sys.stderr)
+        return 4
+
+    url = resp.get("public_url") or ""
+    if not url:
+        print("error: backend returned no public_url — is the session actually public?", file=sys.stderr)
+        return 4
+
+    copied = _copy_to_clipboard(url)
+
+    print()
+    print(f"  ✓ public  {url}")
+    if copied:
+        print("    (copied to clipboard)")
+    print()
+    print("    suggested tweet:")
+    print(f"    {_format_tweet(url)}")
+    print()
+    print(f"    revoke: yoru share --revoke {session_id}")
+    return 0