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

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

@@ -70,3 +70,13 @@ 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
+
+# install-smoke pre-release wheel (transient)
+install-smoke/_wheel/

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: yoru-cli
-Version: 0.1.2
+Version: 0.2.0
 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
@@ -34,20 +34,23 @@ The Claude Code hook installer for Yoru. One command installs a `PostToolUse` ho
 ## Install
 
 ```bash
-pip install yoru-cli
-yoru init
+pipx install yoru-cli                       # or: uv tool install yoru-cli
+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.
+Use `pipx`/`uv` — a bare `pip install yoru-cli` fails on Homebrew/Debian Python with
+`error: externally-managed-environment` (PEP 668). No pipx? A venv works too:
+`python3 -m venv .venv && .venv/bin/pip install yoru-cli`.
+
+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 +72,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.2.0}/README.md

@@ -8,20 +8,23 @@ The Claude Code hook installer for Yoru. One command installs a `PostToolUse` ho
 ## Install
 
 ```bash
-pip install yoru-cli
-yoru init
+pipx install yoru-cli                       # or: uv tool install yoru-cli
+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.
+Use `pipx`/`uv` — a bare `pip install yoru-cli` fails on Homebrew/Debian Python with
+`error: externally-managed-environment` (PEP 668). No pipx? A venv works too:
+`python3 -m venv .venv && .venv/bin/pip install yoru-cli`.
+
+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 +46,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.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yoru-cli"
-version = "0.1.2"
+version = "0.2.0"
 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.2.0/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.2.0/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.2.0}/src/yoru_cli/doctor_cmd.py

@@ -6,13 +6,14 @@ Read-only check of the install:
   3. hook-token valid (GET /hook-tokens)   → else exit 3 on 401
   4. ~/.claude/hooks/yoru.sh is 0755    → else exit 4
 
-Prints ✓ lines to stdout on success (exit 0). Failures go to stderr with a
-short human-readable reason. No fixes attempted.
+Prints a ✓ line to stdout as each stage passes, so a failure leaves a visible
+trail of what already worked (✓ config / ✓ backend / token revoked → the break
+is obvious). Failures go to stderr with a short human-readable reason, then a
+non-zero exit. No fixes attempted.
 """
 from __future__ import annotations
 
 import argparse
-import os
 import stat
 import sys
 from pathlib import Path
@@ -42,6 +43,9 @@ def run(args: argparse.Namespace) -> int:  # noqa: ARG001 — argparse hands arg
     if not server or not token:
         print("yoru init not run", file=sys.stderr)
         return 1
+    # Each stage prints its check the moment it passes, so a later failure
+    # leaves a visible trail of what DID work.
+    print(f"✓ config at ~/.config/yoru/config.json (token {_token_suffix(token)})")
 
     # 2. backend /health/ready
     try:
@@ -52,6 +56,7 @@ def run(args: argparse.Namespace) -> int:  # noqa: ARG001 — argparse hands arg
     if r.status_code != 200:
         print(f"backend unreachable at {server}", file=sys.stderr)
         return 2
+    print(f"✓ backend {server} reachable")
 
     # 3. hook-token validity
     try:
@@ -72,6 +77,8 @@ def run(args: argparse.Namespace) -> int:  # noqa: ARG001 — argparse hands arg
             file=sys.stderr,
         )
         return 3
+    user = cfg.get("user") or "authenticated"
+    print(f"✓ hook-token valid (user: {user})")
 
     # 4. hook file + perms
     hook = _hook_path()
@@ -82,11 +89,5 @@ def run(args: argparse.Namespace) -> int:  # noqa: ARG001 — argparse hands arg
     if mode != 0o755:
         print("hook file missing or not 0755", file=sys.stderr)
         return 4
-
-    # all green
-    user = cfg.get("user") or "authenticated"
-    print(f"\u2713 config at ~/.config/yoru/config.json (token {_token_suffix(token)})")
-    print(f"\u2713 backend {server} reachable")
-    print(f"\u2713 hook-token valid (user: {user})")
     print("\u2713 hook installed at ~/.claude/hooks/yoru.sh")
     return 0

{yoru_cli-0.1.2 → yoru_cli-0.2.0}/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.2.0}/src/yoru_cli/init_cmd.py

@@ -16,6 +16,7 @@ import httpx
 from . import config
 from .api import ReceiptClient
 from .hook_template import HOOK_SCRIPT
+from .skill_template import SKILL_MD, SKILL_NAME
 
 
 def _default_label() -> str:
@@ -106,7 +107,7 @@ def _pair_device(server: str, label: str, *, no_browser: bool) -> str | None:
     interval = int(start.get("interval", 2))
 
     print()
-    print(f"  Pair this device with your Yoru account:")
+    print("  Pair this device with your Yoru account:")
     print(f"    1. Open  {verify_uri}")
     print(f"    2. Enter {user_code}")
     print()
@@ -143,6 +144,35 @@ def _pair_device(server: str, label: str, *, no_browser: bool) -> str | None:
     return None
 
 
+def _install_skill() -> Path:
+    """(Re)write the PUBLIC end-user yoru Claude Code skill so a fresh Claude
+    session can drive setup + usage. Lands at ~/.claude/skills/yoru/SKILL.md,
+    where Claude Code resolves user-level skills. Idempotent."""
+    skill_dir = Path.home() / ".claude" / "skills" / SKILL_NAME
+    os.makedirs(skill_dir, exist_ok=True)
+    skill_path = skill_dir / "SKILL.md"
+    skill_path.write_text(SKILL_MD, encoding="utf-8")
+    return skill_path
+
+
+def refresh_hook_assets() -> tuple[Path, Path, Path]:
+    """(Re)write the Claude Code hook script + the public yoru skill, and
+    (re)register the hook in settings.json. Idempotent — used by `init` (first
+    install) and `update` (refresh to the new version + repair the wiring).
+    Returns (hook_path, settings_path, skill_path). Does NOT touch config."""
+    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)
+
+    skill_path = _install_skill()
+    return hook_path, settings_path, skill_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,17 +197,11 @@ 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")
     print("\u2713 settings \u2192 ~/.claude/settings.json (hook registered)")
+    print("\u2713 skill    \u2192 ~/.claude/skills/yoru/SKILL.md (Claude can drive setup + usage)")
     print("Next: run Claude Code normally; first event streams to /sessions/events.")
     return 0