imessage-bridge 0.1.0__tar.gz

imessage_bridge-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.3
+Name: imessage-bridge
+Version: 0.1.0
+Summary: Connected CLI for imessage-mcp — stable public broker URL with account-managed API keys.
+Keywords: mcp,imessage,macos,claude,llm
+Author: moritzhwnr
+Author-email: moritzhwnr <moritz.hawener@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: Chat
+Requires-Dist: imessage-mcp>=0.1.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=14.0.0
+Requires-Dist: typer>=0.25.1
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/yourname/imessage-bridge
+Project-URL: Repository, https://github.com/yourname/imessage-bridge
+Project-URL: Issues, https://github.com/yourname/imessage-bridge/issues
+Description-Content-Type: text/markdown
+
+# imessage-bridge
+
+The "batteries-included" CLI for [`imessage-mcp`](https://pypi.org/project/imessage-mcp/): adds account management, a stable broker URL, and one-command tunneling.
+
+If you just want a local MCP server with no third-party service, install [`imessage-mcp`](https://pypi.org/project/imessage-mcp/) instead. This package wraps it.
+
+## What you get
+
+- **Account-managed API keys.** Sign up once, mint and revoke keys from the CLI.
+- **Stable broker URL.** `https://imessage-bridge.example.com/api/mcp` — works in any MCP client (Claude Desktop, Cursor, Poke). Survives cloudflared restarts because the CLI re-registers automatically.
+- **All of `imessage-mcp`.** `setup`, `token`, and `serve` all live in this binary too.
+
+## Install
+
+```bash
+brew install cloudflared
+uv tool install imessage-bridge
+```
+
+## Quickstart
+
+```bash
+imessage-bridge setup                # macOS Full Disk Access pane
+imessage-bridge signup               # create account, save API key locally
+imessage-bridge serve --public       # tunnel + register with broker
+                                     # prints the URL + token to paste into your MCP client
+```
+
+## Commands
+
+| | |
+|---|---|
+| `signup` | Create account, save API key |
+| `new-key` | Mint a new API key (asks for email + password) |
+| `logout` | Forget local API key |
+| `whoami` | Show current account |
+| `keys list` | List all API keys on your account |
+| `keys revoke <id>` | Revoke a key by ID |
+| `serve [--public]` | Run the MCP server, optionally tunneling + registering |
+| `setup` | Open macOS Full Disk Access pane |
+| `token [--rotate]` | Print/rotate the local bearer token |
+
+## License
+
+MIT

imessage_bridge-0.1.0/README.md

@@ -0,0 +1,45 @@
+# imessage-bridge
+
+The "batteries-included" CLI for [`imessage-mcp`](https://pypi.org/project/imessage-mcp/): adds account management, a stable broker URL, and one-command tunneling.
+
+If you just want a local MCP server with no third-party service, install [`imessage-mcp`](https://pypi.org/project/imessage-mcp/) instead. This package wraps it.
+
+## What you get
+
+- **Account-managed API keys.** Sign up once, mint and revoke keys from the CLI.
+- **Stable broker URL.** `https://imessage-bridge.example.com/api/mcp` — works in any MCP client (Claude Desktop, Cursor, Poke). Survives cloudflared restarts because the CLI re-registers automatically.
+- **All of `imessage-mcp`.** `setup`, `token`, and `serve` all live in this binary too.
+
+## Install
+
+```bash
+brew install cloudflared
+uv tool install imessage-bridge
+```
+
+## Quickstart
+
+```bash
+imessage-bridge setup                # macOS Full Disk Access pane
+imessage-bridge signup               # create account, save API key locally
+imessage-bridge serve --public       # tunnel + register with broker
+                                     # prints the URL + token to paste into your MCP client
+```
+
+## Commands
+
+| | |
+|---|---|
+| `signup` | Create account, save API key |
+| `new-key` | Mint a new API key (asks for email + password) |
+| `logout` | Forget local API key |
+| `whoami` | Show current account |
+| `keys list` | List all API keys on your account |
+| `keys revoke <id>` | Revoke a key by ID |
+| `serve [--public]` | Run the MCP server, optionally tunneling + registering |
+| `setup` | Open macOS Full Disk Access pane |
+| `token [--rotate]` | Print/rotate the local bearer token |
+
+## License
+
+MIT

imessage_bridge-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "imessage-bridge"
+version = "0.1.0"
+description = "Connected CLI for imessage-mcp — stable public broker URL with account-managed API keys."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "moritzhwnr", email = "moritz.hawener@gmail.com" },
+]
+requires-python = ">=3.13"
+dependencies = [
+    "imessage-mcp>=0.1.0",
+    "httpx>=0.28.1",
+    "questionary>=2.1.1",
+    "rich>=14.0.0",
+    "typer>=0.25.1",
+]
+keywords = ["mcp", "imessage", "macos", "claude", "llm"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: MacOS :: MacOS X",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Communications :: Chat",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourname/imessage-bridge"
+Repository = "https://github.com/yourname/imessage-bridge"
+Issues = "https://github.com/yourname/imessage-bridge/issues"
+
+[project.scripts]
+imessage-bridge = "imessage_bridge.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.11.2,<0.12.0"]
+build-backend = "uv_build"

imessage_bridge-0.1.0/src/imessage_bridge/__init__.py

@@ -0,0 +1 @@
+"""imessage-bridge — connected CLI on top of imessage-mcp."""

imessage_bridge-0.1.0/src/imessage_bridge/_account.py

@@ -0,0 +1,68 @@
+"""Local account state: API key + user ID on disk, password prompts."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import questionary
+import typer
+from rich.console import Console
+
+out = Console()
+err = Console(stderr=True)
+
+CONFIG_DIR = Path.home() / ".config" / "imessage-bridge"
+API_KEY_FILE = CONFIG_DIR / "api_key"
+USER_ID_FILE = CONFIG_DIR / "user_id"
+
+DEFAULT_BACKEND_URL = os.environ.get(
+    "IMESSAGE_BRIDGE_BACKEND_URL",
+    os.environ.get("IMESSAGE_MCP_BACKEND_URL", "http://localhost:3000"),
+)
+
+
+def save_account(api_key: str, user_id: str) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    API_KEY_FILE.write_text(api_key)
+    API_KEY_FILE.chmod(0o600)
+    USER_ID_FILE.write_text(user_id)
+
+
+def load_account() -> tuple[str, str] | None:
+    if not API_KEY_FILE.exists() or not USER_ID_FILE.exists():
+        return None
+    return API_KEY_FILE.read_text().strip(), USER_ID_FILE.read_text().strip()
+
+
+def require_account() -> tuple[str, str]:
+    account = load_account()
+    if account is None:
+        err.print(
+            "[red]Not logged in.[/red] "
+            "Run [cyan]imessage-bridge signup[/cyan] or "
+            "[cyan]imessage-bridge new-key[/cyan] first."
+        )
+        raise typer.Exit(code=1)
+    return account
+
+
+def prompt_credentials(confirm_password: bool) -> tuple[str, str]:
+    """Interactive email + password prompt. Returns (email, password)."""
+    email = questionary.text("Email:").ask()
+    if not email:
+        out.print("[yellow]Canceled.[/yellow]")
+        raise typer.Exit(code=0)
+
+    password = questionary.password("Password:").ask()
+    if not password:
+        out.print("[yellow]Canceled.[/yellow]")
+        raise typer.Exit(code=0)
+
+    if confirm_password:
+        confirm = questionary.password("Confirm password:").ask()
+        if confirm != password:
+            err.print("[red]Passwords don't match.[/red]")
+            raise typer.Exit(code=1)
+
+    return email, password

imessage_bridge-0.1.0/src/imessage_bridge/_broker.py

@@ -0,0 +1,113 @@
+"""HTTP calls to the broker.
+
+Two call shapes:
+  - `call_broker(...)` — auth flows. Raises typer.Exit on failure with a
+    clean message (the user is interactive; failing hard is right).
+  - `register_tunnel(...)` — runtime side-effect. Returns bool, prints a
+    yellow warning on failure. Broker downtime must not kill the local
+    server; the cloudflare URL still works directly.
+"""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+out = Console()
+err = Console(stderr=True)
+
+
+def call_broker(
+    backend_url: str, path: str, payload: dict, *, api_key: str | None = None
+) -> dict:
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    try:
+        resp = httpx.post(
+            f"{backend_url}{path}", json=payload, headers=headers, timeout=10.0
+        )
+    except httpx.ConnectError:
+        err.print(
+            f"[red]Cannot reach broker at {backend_url}[/red]\n"
+            f"Is it running? (Set IMESSAGE_BRIDGE_BACKEND_URL or "
+            f"start the broker locally.)"
+        )
+        raise typer.Exit(code=1)
+    except httpx.HTTPError as e:
+        err.print(f"[red]Network error:[/red] {type(e).__name__}: {e}")
+        raise typer.Exit(code=1)
+
+    if resp.status_code >= 400:
+        try:
+            msg = resp.json().get("error", resp.text)
+        except ValueError:
+            msg = resp.text or "<empty body>"
+        err.print(f"[red]{resp.status_code} from {path}:[/red] {msg}")
+        raise typer.Exit(code=1)
+
+    return resp.json() if resp.content else {}
+
+
+def register_tunnel(
+    backend_url: str, api_key: str, url: str, tunnel_token: str
+) -> bool:
+    """Returns True on success, False on any failure (logged + soft-failed)."""
+    try:
+        resp = httpx.post(
+            f"{backend_url}/api/tunnels/register",
+            json={"url": url, "tunnel_token": tunnel_token},
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10.0,
+        )
+    except httpx.HTTPError as e:
+        err.print(
+            f"[yellow]Broker registration failed ({type(e).__name__}). "
+            f"Tunnel still usable directly.[/yellow]"
+        )
+        return False
+    if resp.status_code >= 400:
+        try:
+            msg = resp.json().get("error", resp.text)
+        except ValueError:
+            msg = resp.text or "<empty body>"
+        err.print(
+            f"[yellow]Broker rejected registration ({resp.status_code}): {msg}[/yellow]"
+        )
+        return False
+    return True
+
+
+def print_broker_panel(backend_url: str, api_key: str) -> None:
+    """Green panel — the broker URL is the 'preferred' connection point.
+
+    The URL is identical for every user; the API key identifies who's
+    calling. This is the shape Poke/Claude Desktop/Cursor expect.
+    """
+    public_url = f"{backend_url.rstrip('/')}/api/mcp"
+    config_snippet = json.dumps(
+        {
+            "mcpServers": {
+                "imessage": {
+                    "url": public_url,
+                    "headers": {"Authorization": f"Bearer {api_key}"},
+                }
+            }
+        },
+        indent=2,
+    )
+    out.print(
+        Panel(
+            f"[bold]{public_url}[/bold]\n"
+            "[dim]Stable URL — survives cloudflared restarts as long as this "
+            "CLI re-registers.[/dim]\n\n"
+            "Add to your MCP client config:\n"
+            f"[green]{config_snippet}[/green]",
+            title="imessage-bridge (BROKER)",
+            border_style="green",
+        )
+    )

imessage_bridge-0.1.0/src/imessage_bridge/cli.py

@@ -0,0 +1,293 @@
+"""Typer CLI for imessage-bridge.
+
+Strategy: this binary subsumes imessage-mcp's commands so users only need
+one tool. We:
+  1. Import imessage-mcp's Typer app
+  2. Replace its `serve` with our broker-aware version
+  3. Add signup / new-key / whoami / logout / keys subcommands
+
+Users installing only `imessage-mcp` see the local-only commands. Users
+installing `imessage-bridge` get everything in one binary.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Annotated
+from urllib.parse import urlparse
+
+import httpx
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from imessage_mcp._imessage import CHAT_DB
+from imessage_mcp.cli import app as mcp_app
+from imessage_mcp.config import load_or_create_token
+from imessage_mcp.server import allow_tunnel_host, serve_mcp
+from imessage_mcp.tunnel import print_config_panel, spawn_cloudflared
+
+from imessage_bridge._account import (
+    API_KEY_FILE,
+    API_KEY_FILE as _API_KEY_FILE_UNUSED,
+    DEFAULT_BACKEND_URL,
+    USER_ID_FILE,
+    load_account,
+    prompt_credentials,
+    require_account,
+    save_account,
+)
+from imessage_bridge._broker import (
+    call_broker,
+    print_broker_panel,
+    register_tunnel,
+)
+
+out = Console()
+err = Console(stderr=True)
+
+DEFAULT_HOST = "127.0.0.1"
+DEFAULT_PORT = 8765
+
+# ---------- Build the bridge Typer app ----------
+#
+# We start with imessage-mcp's app (which already has `setup` and `token`)
+# and REPLACE its `serve` with our broker-aware variant. Typer stores
+# commands in `app.registered_commands`; rewriting that list is the
+# cleanest way to override.
+
+app = mcp_app
+app.info.help = (
+    "Connected CLI for imessage-mcp — stable broker URL, account-managed keys."
+)
+# Drop the standalone `serve` so we can re-register the broker-aware one.
+app.registered_commands = [
+    c for c in app.registered_commands if c.name != "serve"
+]
+
+
+@app.command()
+def serve(
+    host: Annotated[
+        str, typer.Option(help="Bind address. Keep 127.0.0.1 unless you know why.")
+    ] = DEFAULT_HOST,
+    port: Annotated[int, typer.Option(help="TCP port.")] = DEFAULT_PORT,
+    public: Annotated[
+        bool,
+        typer.Option(
+            "--public",
+            help="Tunnel via cloudflared and (if logged in) register with the broker.",
+        ),
+    ] = False,
+    rotate_token: Annotated[
+        bool, typer.Option("--rotate-token", help="Generate a fresh local bearer token first.")
+    ] = False,
+    backend_url: Annotated[
+        str,
+        typer.Option(
+            envvar="IMESSAGE_BRIDGE_BACKEND_URL",
+            help="Broker URL (override for staging/prod).",
+        ),
+    ] = DEFAULT_BACKEND_URL,
+) -> None:
+    """Run the MCP server; with --public also tunnel + register with the broker."""
+    if not CHAT_DB.exists():
+        err.print(f"[red]chat.db not found at {CHAT_DB}[/red]")
+        err.print("Run [cyan]imessage-bridge setup[/cyan] first.")
+        raise typer.Exit(code=1)
+
+    token = load_or_create_token(rotate=rotate_token)
+    local_url = f"http://{host}:{port}"
+    print_config_panel(local_url, token, public=False)
+
+    tunnel_proc: subprocess.Popen | None = None
+    if public:
+        account = load_account()  # captured by closure
+
+        def on_url(url: str) -> None:
+            allow_tunnel_host(urlparse(url).netloc, url)
+            if account is not None:
+                api_key, _user_id = account
+                if register_tunnel(backend_url, api_key, url, token):
+                    print_broker_panel(backend_url, api_key)
+                    return
+                # Registration failed — fall back to direct cloudflare URL.
+                print_config_panel(url, token, public=True)
+            else:
+                print_config_panel(url, token, public=True)
+                out.print(
+                    "[dim]Tip: run `imessage-bridge signup` to also share "
+                    "this via a stable broker URL.[/dim]"
+                )
+
+        tunnel_proc = spawn_cloudflared(local_url, on_url=on_url)
+        out.print("[dim]Waiting for cloudflared to establish the tunnel...[/dim]")
+
+    try:
+        serve_mcp(host=host, port=port, token=token)
+    finally:
+        if tunnel_proc is not None and tunnel_proc.poll() is None:
+            tunnel_proc.terminate()
+            try:
+                tunnel_proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                tunnel_proc.kill()
+
+
+# ---------- account commands ----------
+
+
+@app.command()
+def signup(
+    backend_url: Annotated[
+        str, typer.Option(envvar="IMESSAGE_BRIDGE_BACKEND_URL")
+    ] = DEFAULT_BACKEND_URL,
+) -> None:
+    """Create a new account on the broker and save your API key."""
+    if load_account() is not None:
+        err.print(
+            "[yellow]You're already logged in.[/yellow] "
+            "Run [cyan]imessage-bridge logout[/cyan] first."
+        )
+        raise typer.Exit(code=1)
+
+    out.print(Panel.fit("Create a new account", border_style="cyan"))
+    email, password = prompt_credentials(confirm_password=True)
+    data = call_broker(
+        backend_url, "/api/auth/signup", {"email": email, "password": password}
+    )
+    save_account(data["api_key"], data["user_id"])
+
+    out.print(f"\n[green]Account created.[/green]")
+    out.print(f"User ID: [cyan]{data['user_id']}[/cyan]")
+    out.print(f"API key saved to [dim]{API_KEY_FILE}[/dim]")
+    out.print(
+        "\nNext: [cyan]imessage-bridge serve --public[/cyan] to register your tunnel."
+    )
+
+
+@app.command("new-key")
+def new_key(
+    backend_url: Annotated[
+        str, typer.Option(envvar="IMESSAGE_BRIDGE_BACKEND_URL")
+    ] = DEFAULT_BACKEND_URL,
+) -> None:
+    """Mint a fresh API key for your account (asks for email + password)."""
+    out.print(Panel.fit("Mint a new API key", border_style="cyan"))
+    email, password = prompt_credentials(confirm_password=False)
+    data = call_broker(
+        backend_url, "/api/auth/login", {"email": email, "password": password}
+    )
+    save_account(data["api_key"], data["user_id"])
+    out.print(f"\n[green]New API key saved.[/green]")
+    out.print(f"User ID: [cyan]{data['user_id']}[/cyan]")
+
+
+@app.command()
+def logout() -> None:
+    """Forget the local API key + user ID. (The key stays valid server-side.)"""
+    removed = []
+    for p in (API_KEY_FILE, USER_ID_FILE):
+        if p.exists():
+            p.unlink()
+            removed.append(p.name)
+    if not removed:
+        out.print("[yellow]Nothing to log out from.[/yellow]")
+        return
+    out.print(f"[green]Logged out.[/green] Removed: {', '.join(removed)}")
+    out.print("[dim]The API key is still valid server-side until you revoke it.[/dim]")
+
+
+@app.command()
+def whoami() -> None:
+    """Show the currently logged-in user (if any)."""
+    account = load_account()
+    if account is None:
+        out.print(
+            "[yellow]Not logged in.[/yellow] "
+            "Run [cyan]imessage-bridge signup[/cyan] or [cyan]new-key[/cyan]."
+        )
+        raise typer.Exit(code=1)
+    api_key, user_id = account
+    out.print(f"User ID: [cyan]{user_id}[/cyan]")
+    out.print(f"API key: [dim]{api_key[:8]}…[/dim] (loaded from {API_KEY_FILE})")
+
+
+# ---------- API key management subcommand group ----------
+
+keys_app = typer.Typer(help="List and revoke your API keys.")
+app.add_typer(keys_app, name="keys")
+
+
+@keys_app.command("list")
+def keys_list(
+    backend_url: Annotated[
+        str, typer.Option(envvar="IMESSAGE_BRIDGE_BACKEND_URL")
+    ] = DEFAULT_BACKEND_URL,
+) -> None:
+    """List all API keys on your account. (Current key marked with ●.)"""
+    api_key, _ = require_account()
+    try:
+        resp = httpx.get(
+            f"{backend_url}/api/keys",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10.0,
+        )
+    except httpx.HTTPError as e:
+        err.print(f"[red]Network error:[/red] {e}")
+        raise typer.Exit(code=1)
+    if resp.status_code != 200:
+        err.print(f"[red]{resp.status_code}:[/red] {resp.text}")
+        raise typer.Exit(code=1)
+
+    table = Table(title="API keys")
+    table.add_column("", width=2)
+    table.add_column("ID", style="cyan")
+    table.add_column("Created", style="dim")
+    table.add_column("Last used", style="dim")
+    for k in resp.json():
+        marker = "[green]●[/green]" if k["current"] else " "
+        last = k["last_used_at"][:19].replace("T", " ") if k["last_used_at"] else "—"
+        created = k["created_at"][:19].replace("T", " ")
+        table.add_row(marker, k["id"], created, last)
+    out.print(table)
+    out.print("[dim]Revoke with:[/dim] [cyan]imessage-bridge keys revoke <ID>[/cyan]")
+
+
+@keys_app.command("revoke")
+def keys_revoke(
+    key_id: Annotated[str, typer.Argument(help="Key UUID from `keys list`.")],
+    backend_url: Annotated[
+        str, typer.Option(envvar="IMESSAGE_BRIDGE_BACKEND_URL")
+    ] = DEFAULT_BACKEND_URL,
+    yes: Annotated[
+        bool, typer.Option("--yes", "-y", help="Skip the confirmation prompt.")
+    ] = False,
+) -> None:
+    """Revoke an API key by ID."""
+    api_key, _ = require_account()
+    if not yes and not typer.confirm(f"Revoke key {key_id}?", default=False):
+        out.print("[yellow]Canceled.[/yellow]")
+        raise typer.Exit(code=0)
+    try:
+        resp = httpx.delete(
+            f"{backend_url}/api/keys/{key_id}",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10.0,
+        )
+    except httpx.HTTPError as e:
+        err.print(f"[red]Network error:[/red] {e}")
+        raise typer.Exit(code=1)
+    if resp.status_code == 204:
+        out.print(f"[green]Revoked[/green] {key_id}")
+        return
+    if resp.status_code == 404:
+        err.print(f"[red]No such key on your account.[/red]")
+        raise typer.Exit(code=1)
+    err.print(f"[red]{resp.status_code}:[/red] {resp.text}")
+    raise typer.Exit(code=1)
+
+
+def main() -> None:
+    app()