rayonne-mcp 0.2.0__tar.gz

rayonne_mcp-0.2.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+dist/
+__pycache__/
+*.egg-info/
+uv.lock

rayonne_mcp-0.2.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.5
+Name: rayonne-mcp
+Version: 0.2.0
+Summary: Rayonne MCP server — pilote le workspace Rayonne (audit marketing, analyse produit, contenus, vidéos, métriques AARRR) depuis tout agent compatible MCP.
+Author-email: Sponge Theory <contact@sponge-theory.ai>
+License: SPONGE THEORY PROPRIETARY LICENSE
+Keywords: claude,marketing,mcp,rayonne,sponge-theory
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: mcp[cli]<2,>=1.2.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Rayonne MCP
+
+Serveur MCP (stdio) exposant le workspace Rayonne — contenus, soumissions,
+métriques AARRR — à tout agent compatible MCP (Claude Code, Claude Desktop…),
+via l'**API publique v1 en lecture** (`docs/API.md` du repo).
+
+## Prérequis
+
+Une clé API workspace (`rk_…`) : Rayonne → **Réglages → Clés API**
+(plan **Business**, entitlement `api_access`).
+
+## Claude Code
+
+```sh
+claude mcp add rayonne \
+  --env RAYONNE_API_KEY=rk_xxxxxxxx \
+  --env RAYONNE_API_URL=https://rayonne.ai \
+  -- uv run --project /chemin/vers/rayonne/mcp rayonne-mcp
+```
+
+## Claude Desktop (`claude_desktop_config.json`)
+
+```json
+{
+  "mcpServers": {
+    "rayonne": {
+      "command": "uv",
+      "args": ["run", "--project", "/chemin/vers/rayonne/mcp", "rayonne-mcp"],
+      "env": {
+        "RAYONNE_API_KEY": "rk_xxxxxxxx",
+        "RAYONNE_API_URL": "https://rayonne.ai"
+      }
+    }
+  }
+}
+```
+
+Le serveur démarre **sans** clé (non fatal) : chaque outil renvoie alors un
+message d'installation clair au lieu d'un crash.
+
+## Outils
+
+| Outil | Rend |
+|---|---|
+| `rayonne_overview` | nom, URL produit, autopilote, compteurs contenus/soumissions par statut |
+| `rayonne_list_content` | derniers contenus (+ `predicted_engagement` 0-100) |
+| `rayonne_list_submissions` | statut de publication par plateforme (+ `external_url`) |
+| `rayonne_metrics_aarrr` | snapshot AARRR (stages, geo, by_channel, timeseries, deltas) |
+
+## Tests
+
+```sh
+cd mcp && uv run --extra dev pytest -q
+```
+
+## Publication marketplace
+
+À faire via le flux commun Sponge Theory (même patron qu'`audigeo-mcp` :
+stdio + PyPI, vendored dans `ezeeFlop/claude-plugins`) — voir l'agent
+`mcp-plugin-publisher`.

rayonne_mcp-0.2.0/README.md

@@ -0,0 +1,60 @@
+# Rayonne MCP
+
+Serveur MCP (stdio) exposant le workspace Rayonne — contenus, soumissions,
+métriques AARRR — à tout agent compatible MCP (Claude Code, Claude Desktop…),
+via l'**API publique v1 en lecture** (`docs/API.md` du repo).
+
+## Prérequis
+
+Une clé API workspace (`rk_…`) : Rayonne → **Réglages → Clés API**
+(plan **Business**, entitlement `api_access`).
+
+## Claude Code
+
+```sh
+claude mcp add rayonne \
+  --env RAYONNE_API_KEY=rk_xxxxxxxx \
+  --env RAYONNE_API_URL=https://rayonne.ai \
+  -- uv run --project /chemin/vers/rayonne/mcp rayonne-mcp
+```
+
+## Claude Desktop (`claude_desktop_config.json`)
+
+```json
+{
+  "mcpServers": {
+    "rayonne": {
+      "command": "uv",
+      "args": ["run", "--project", "/chemin/vers/rayonne/mcp", "rayonne-mcp"],
+      "env": {
+        "RAYONNE_API_KEY": "rk_xxxxxxxx",
+        "RAYONNE_API_URL": "https://rayonne.ai"
+      }
+    }
+  }
+}
+```
+
+Le serveur démarre **sans** clé (non fatal) : chaque outil renvoie alors un
+message d'installation clair au lieu d'un crash.
+
+## Outils
+
+| Outil | Rend |
+|---|---|
+| `rayonne_overview` | nom, URL produit, autopilote, compteurs contenus/soumissions par statut |
+| `rayonne_list_content` | derniers contenus (+ `predicted_engagement` 0-100) |
+| `rayonne_list_submissions` | statut de publication par plateforme (+ `external_url`) |
+| `rayonne_metrics_aarrr` | snapshot AARRR (stages, geo, by_channel, timeseries, deltas) |
+
+## Tests
+
+```sh
+cd mcp && uv run --extra dev pytest -q
+```
+
+## Publication marketplace
+
+À faire via le flux commun Sponge Theory (même patron qu'`audigeo-mcp` :
+stdio + PyPI, vendored dans `ezeeFlop/claude-plugins`) — voir l'agent
+`mcp-plugin-publisher`.

rayonne_mcp-0.2.0/build/build_mcpb.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# Build the Claude Desktop MCPB bundle from mcp/mcpb/.
+# Output: mcp/dist/rayonne-<VERSION>.mcpb (zip file with renamed extension)
+#
+# Usage: ./build_mcpb.sh
+
+set -euo pipefail
+
+MCP_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$MCP_DIR"
+
+VERSION=$(grep -E "^version" pyproject.toml | head -1 | sed -E 's/.*"([^"]+)".*/\1/')
+if [ -z "$VERSION" ]; then
+    echo "ERROR: cannot parse version from pyproject.toml" >&2
+    exit 1
+fi
+
+mkdir -p dist
+OUT="${MCP_DIR}/dist/rayonne-${VERSION}.mcpb"
+
+if [ ! -d "mcpb" ]; then
+    echo "ERROR: mcpb/ template missing" >&2
+    exit 1
+fi
+
+STAGE=$(mktemp -d)
+trap 'rm -rf "$STAGE"' EXIT
+
+cp -R mcpb/* "$STAGE/"
+
+# Embed the server source so the bundle is self-contained
+mkdir -p "$STAGE/server"
+cp -R src "$STAGE/server/src"
+cp pyproject.toml "$STAGE/server/pyproject.toml"
+cp README.md "$STAGE/server/README.md"
+
+# Bundle the wheel so bootstrap.py can provision dependencies on the user's
+# machine at first run (pip resolves the correct per-platform binaries —
+# vendoring compiled deps like pydantic-core into one cross-platform bundle is
+# not possible). Build the wheel first if it isn't in dist/ yet.
+mkdir -p "$STAGE/server/wheels"
+WHEEL=$(ls -t dist/rayonne_mcp-*.whl 2>/dev/null | head -1 || true)
+if [ -z "${WHEEL:-}" ]; then
+    echo "No wheel in dist/ — building it first…"
+    "$(dirname "$0")/build_wheel.sh" >/dev/null
+    WHEEL=$(ls -t dist/rayonne_mcp-*.whl 2>/dev/null | head -1 || true)
+fi
+if [ -z "${WHEEL:-}" ]; then
+    echo "ERROR: could not build/find the rayonne_mcp wheel" >&2
+    exit 1
+fi
+cp "$WHEEL" "$STAGE/server/wheels/"
+echo "Bundled wheel: $(basename "$WHEEL")"
+
+# Inject version into manifest.json
+MANIFEST="$STAGE/manifest.json"
+if [ -f "$MANIFEST" ]; then
+    /usr/bin/sed -i.bak -E "s/\"version\": *\"[^\"]+\"/\"version\": \"${VERSION}\"/" "$MANIFEST"
+    rm -f "${MANIFEST}.bak"
+fi
+
+# Strip macOS metadata
+find "$STAGE" -name '.DS_Store' -delete 2>/dev/null || true
+find "$STAGE" -name '__pycache__' -type d -exec rm -rf {} + 2>/dev/null || true
+
+# .mcpb is just a zip
+rm -f "$OUT"
+(cd "$STAGE" && zip -qr "$OUT" .)
+
+echo "Built: $OUT ($(du -h "$OUT" | awk '{print $1}'))"

rayonne_mcp-0.2.0/build/build_plugin.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Build the Claude Code plugin tar.gz from mcp/claude_code_plugin/.
+# Output: mcp/dist/rayonne-claude-code-<VERSION>.tar.gz
+#
+# Usage: ./build_plugin.sh
+
+set -euo pipefail
+
+MCP_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$MCP_DIR"
+
+# The plugin is versioned independently of the PyPI server package (the plugin
+# just references `uvx rayonne-mcp`). Read the version from plugin.json.
+VERSION=$(grep -E '"version"' claude_code_plugin/.claude-plugin/plugin.json | head -1 | sed -E 's/.*"version": *"([^"]+)".*/\1/')
+if [ -z "$VERSION" ]; then
+    echo "ERROR: cannot parse version from plugin.json" >&2
+    exit 1
+fi
+
+mkdir -p dist
+OUT="dist/rayonne-claude-code-${VERSION}.tar.gz"
+
+if [ ! -d "claude_code_plugin" ]; then
+    echo "ERROR: claude_code_plugin/ template missing" >&2
+    exit 1
+fi
+
+# Stage to a temp dir so the tarball has a clean top-level directory
+STAGE=$(mktemp -d)
+trap 'rm -rf "$STAGE"' EXIT
+cp -R claude_code_plugin "${STAGE}/rayonne"
+
+# No server source is bundled: the plugin's .mcp.json launches the MCP server
+# via `uvx rayonne-mcp`, which fetches the published package from PyPI and
+# caches an isolated environment on first run. This keeps the plugin tiny and
+# lets it be distributed from a PUBLIC marketplace without shipping the
+# proprietary server source. (The self-contained path lives in the .mcpb
+# bundle for Claude Desktop, built by build_mcpb.sh.)
+
+# Strip macOS metadata and caches
+find "$STAGE" -name '.DS_Store' -delete 2>/dev/null || true
+find "$STAGE" -name '__pycache__' -type d -exec rm -rf {} + 2>/dev/null || true
+
+tar -czf "$OUT" -C "$STAGE" rayonne
+echo "Built: $OUT ($(du -h "$OUT" | awk '{print $1}'))"

rayonne_mcp-0.2.0/build/build_wheel.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Build the rayonne-mcp Python wheel.
+# Output: mcp/dist/rayonne_mcp-<VERSION>-py3-none-any.whl + .tar.gz
+#
+# Usage: ./build_wheel.sh
+
+set -euo pipefail
+
+MCP_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$MCP_DIR"
+
+# Don't rm dist/ — other build scripts have already populated it
+rm -f dist/rayonne_mcp-*.whl dist/rayonne_mcp-*.tar.gz 2>/dev/null || true
+
+# Prefer uv (already used in the project), fall back to python -m build
+if command -v uv >/dev/null 2>&1; then
+    uv build --wheel --sdist --out-dir dist 2>&1 | tail -5
+else
+    "${PYTHON:-python}" -m build --wheel --sdist --outdir dist . 2>&1 | tail -5
+fi
+
+echo ""
+echo "Built artifacts:"
+ls -lh dist/rayonne_mcp-*.whl dist/rayonne_mcp-*.tar.gz 2>/dev/null

rayonne_mcp-0.2.0/build/publish_pypi.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# Publish the rayonne-mcp package to PyPI.
+#
+# Builds a fresh wheel + sdist for the current version and uploads them.
+# Already-published versions are skipped (idempotent) via --check-url, so a
+# re-run after a failed upload is safe.
+#
+# Token resolution order (first hit wins):
+#   1. $UV_PUBLISH_TOKEN         (CI / one-off overrides)
+#   2. ~/.pypirc [pypi] password (the global PyPI token, chmod 600)
+#
+# Usage: ./build/publish_pypi.sh
+set -euo pipefail
+
+MCP_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$MCP_DIR"
+
+VERSION=$(grep -E "^version" pyproject.toml | head -1 | sed -E 's/.*"([^"]+)".*/\1/')
+echo "Publishing rayonne-mcp ${VERSION} to PyPI…"
+
+# --- Resolve token ---------------------------------------------------------
+TOKEN="${UV_PUBLISH_TOKEN:-}"
+if [ -z "$TOKEN" ] && [ -f "${HOME}/.pypirc" ]; then
+    TOKEN="$(awk '/^\[pypi\]/{f=1} f&&/password/{sub(/^[^=]*=[[:space:]]*/,"");print;exit}' "${HOME}/.pypirc")"
+fi
+if [ -z "$TOKEN" ]; then
+    echo "ERROR: no PyPI token found. Set UV_PUBLISH_TOKEN, or create ${TOKEN_FILE}." >&2
+    exit 1
+fi
+
+# --- Build fresh artifacts -------------------------------------------------
+"$(dirname "$0")/build_wheel.sh" >/dev/null
+WHEEL=$(ls -t dist/rayonne_mcp-"${VERSION}"-*.whl 2>/dev/null | head -1)
+SDIST=$(ls -t dist/rayonne_mcp-"${VERSION}".tar.gz 2>/dev/null | head -1)
+if [ -z "${WHEEL:-}" ] || [ -z "${SDIST:-}" ]; then
+    echo "ERROR: could not find built artifacts for ${VERSION} in dist/." >&2
+    exit 1
+fi
+
+# --- Upload (idempotent: skips versions already on the index) --------------
+uv publish \
+    --token "$TOKEN" \
+    --check-url https://pypi.org/simple/rayonne-mcp/ \
+    "$WHEEL" "$SDIST"
+
+echo ""
+echo "Done. Verify: https://pypi.org/project/rayonne-mcp/${VERSION}/"

rayonne_mcp-0.2.0/claude_code_plugin/.claude-plugin/plugin.json

@@ -0,0 +1,34 @@
+{
+  "name": "rayonne",
+  "version": "0.2.0",
+  "description": "Rayonne — l'autopilote marketing des SaaS : audit marketing de ta page produit, analyse, contenus, vidéos, métriques AARRR, depuis Claude Code.",
+  "author": {
+    "name": "Sponge Theory",
+    "email": "contact@sponge-theory.ai",
+    "url": "https://rayonne.ai"
+  },
+  "homepage": "https://rayonne.ai",
+  "license": "Sponge Theory Proprietary",
+  "keywords": ["marketing", "saas", "rayonne", "audit", "sponge-theory"],
+  "userConfig": {
+    "api_key": {
+      "type": "string",
+      "title": "Clé API Rayonne",
+      "description": "Générée dans Rayonne → Réglages → Clés API (format rk_…, plan Business requis).",
+      "sensitive": true,
+      "required": true
+    },
+    "api_url": {
+      "type": "string",
+      "title": "URL de l'API",
+      "description": "Laisser par défaut sauf instance auto-hébergée.",
+      "default": "https://rayonne.ai/api/public/v1"
+    },
+    "read_only": {
+      "type": "boolean",
+      "title": "Mode lecture seule",
+      "description": "Désactive les outils qui déclenchent un travail (analyse, audit, génération vidéo — la vidéo est facturée). À activer pour explorer sans rien consommer.",
+      "default": false
+    }
+  }
+}

rayonne_mcp-0.2.0/claude_code_plugin/.mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "rayonne": {
+      "command": "uvx",
+      "args": ["rayonne-mcp@0.2.0"],
+      "env": {
+        "RAYONNE_API_KEY": "${user_config.api_key}",
+        "RAYONNE_API_URL": "${user_config.api_url}",
+        "RAYONNE_READ_ONLY": "${user_config.read_only}"
+      }
+    }
+  }
+}

rayonne_mcp-0.2.0/claude_code_plugin/README.md

@@ -0,0 +1,30 @@
+# Rayonne — plugin Claude Code
+
+Pilote ton workspace [Rayonne](https://rayonne.ai) depuis Claude Code :
+audit marketing de ta page produit, analyse produit, génération de contenus
+et de vidéos, métriques AARRR.
+
+## Installation
+
+```
+/plugin marketplace add ezeeFlop/claude-plugins
+/plugin install rayonne
+```
+
+Claude Code demande alors ta **clé API** (Rayonne → Réglages → Clés API,
+format `rk_…`, plan Business).
+
+## Commandes
+
+- `/rayonne-audit` — audite le message de ta page produit et dit ce qui
+  plafonne tout ce que Rayonne génère pour toi.
+- `/rayonne-status` — état du workspace en quelques lignes.
+
+## Outils
+
+Lecture : `rayonne_overview`, `rayonne_list_content`,
+`rayonne_list_submissions`, `rayonne_metrics_aarrr`, `rayonne_list_audits`.
+
+Écriture : `rayonne_analyze_product`, `rayonne_marketing_audit`,
+`rayonne_create_video`. Chacun consomme du quota ; la génération vidéo est
+facturée. Coche **Mode lecture seule** à l'installation pour les désactiver.

rayonne_mcp-0.2.0/claude_code_plugin/commands/rayonne-audit.md

@@ -0,0 +1,19 @@
+---
+description: Audite le message de ta page produit et dit ce qui plafonne tes contenus.
+---
+
+Lance un audit marketing de la page produit du workspace Rayonne, puis
+présente le résultat.
+
+1. Appelle `rayonne_marketing_audit` (laisse `refresh` à true : il faut noter
+   la page **telle qu'elle est**, pas la dernière analyse).
+2. L'audit tourne en fond. Attends une minute environ, puis relis-le avec
+   `rayonne_list_audits`, en reprenant le plus récent.
+3. Présente dans cet ordre, sans jargon :
+   - le **verdict** en premier, tel quel — c'est la phrase qui doit suffire ;
+   - la note globale et les axes, en signalant celui qui est le plus bas ;
+   - les recommandations, avec leurs phrases de remplacement prêtes à coller.
+4. Si un audit précédent existe, compare les notes et dis franchement si la
+   dernière modification de la page a payé ou non.
+
+Ne reformule jamais le verdict et ne traduis pas les citations de la page.

rayonne_mcp-0.2.0/claude_code_plugin/commands/rayonne-status.md

@@ -0,0 +1,13 @@
+---
+description: État du workspace Rayonne — contenus, soumissions, métriques.
+---
+
+Donne un état des lieux court du workspace Rayonne.
+
+1. `rayonne_overview` pour le workspace et ses compteurs.
+2. `rayonne_list_content` (10 derniers) et `rayonne_list_submissions`.
+3. `rayonne_metrics_aarrr` pour les chiffres d'acquisition.
+
+Résume en quelques lignes : ce qui a été généré, ce qui est publié, ce qui
+attend une revue, et le chiffre AARRR qui bouge le plus. Signale tout
+contenu bloqué en revue depuis plus d'une semaine.

rayonne_mcp-0.2.0/mcpb/README.md

@@ -0,0 +1,17 @@
+# Rayonne — bundle Claude Desktop
+
+Installe ce fichier `.mcpb` dans Claude Desktop (Réglages → Extensions →
+installer depuis un fichier), puis colle ta **clé API Rayonne**
+(Réglages → Clés API dans Rayonne, format `rk_…`, plan Business).
+
+Aucun prérequis autre qu'un Python 3.10+ : le bundle provisionne son propre
+environnement au premier lancement.
+
+## À quoi ça sert
+
+Demande par exemple : « audite le message de ma page produit ». Rayonne note
+sept axes et te dit lequel plafonne tout le reste — avec les phrases de
+remplacement à coller.
+
+Coche **Mode lecture seule** si tu veux explorer sans rien déclencher : la
+génération vidéo consomme du quota et est facturée.

rayonne_mcp-0.2.0/mcpb/manifest.json

@@ -0,0 +1,54 @@
+{
+  "manifest_version": "0.2",
+  "name": "rayonne",
+  "display_name": "Rayonne",
+  "version": "0.2.0",
+  "description": "Audit marketing de ta page produit, analyse, contenus, vidéos et métriques AARRR — directement dans Claude Desktop.",
+  "long_description": "Rayonne est l'autopilote marketing des SaaS. Ce bundle expose ton workspace à Claude Desktop : l'AUDIT MARKETING note le message de ta page produit sur sept axes (hiérarchie du message, clarté, audience, différenciation, douleur, preuve, offre) et dit lequel plafonne tout ce que la plateforme génère pour toi, avec des phrases de remplacement prêtes à coller. S'y ajoutent l'analyse produit, la génération de vidéos, l'état des contenus et des soumissions, et le tableau AARRR. Plan Business requis (entitlement accès API).",
+  "author": {
+    "name": "Sponge Theory",
+    "email": "contact@sponge-theory.ai",
+    "url": "https://rayonne.ai"
+  },
+  "homepage": "https://rayonne.ai",
+  "documentation": "https://rayonne.ai/docs/mcp",
+  "support": "https://rayonne.ai",
+  "server": {
+    "type": "python",
+    "entry_point": "server/bootstrap.py",
+    "mcp_config": {
+      "command": "python",
+      "args": ["${__dirname}/server/bootstrap.py"],
+      "cwd": "${__dirname}/server",
+      "env": {
+        "PYTHONPATH": "${__dirname}/server/src",
+        "RAYONNE_API_KEY": "${user_config.api_key}",
+        "RAYONNE_API_URL": "${user_config.api_url}",
+        "RAYONNE_READ_ONLY": "${user_config.read_only}"
+      }
+    }
+  },
+  "user_config": {
+    "api_key": {
+      "type": "string",
+      "title": "Clé API Rayonne",
+      "description": "Générée dans Rayonne → Réglages → Clés API (format rk_…, plan Business requis).",
+      "sensitive": true,
+      "required": true
+    },
+    "api_url": {
+      "type": "string",
+      "title": "URL de l'API",
+      "description": "Laisser par défaut sauf instance auto-hébergée.",
+      "default": "https://rayonne.ai/api/public/v1",
+      "required": false
+    },
+    "read_only": {
+      "type": "boolean",
+      "title": "Mode lecture seule",
+      "description": "Désactive les outils qui déclenchent un travail (analyse, audit, génération vidéo — la vidéo est facturée). Recommandé pour explorer sans rien consommer.",
+      "default": false,
+      "required": false
+    }
+  }
+}

rayonne_mcp-0.2.0/mcpb/server/bootstrap.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""Bootstrap launcher for the Rayonne Claude Desktop (.mcpb) bundle.
+
+Claude Desktop starts this file with a system Python (manifest
+``server.type = "python"``). A single ``.mcpb`` must run on macOS, Windows and
+Linux, but the MCP SDK depends on compiled wheels (notably ``pydantic-core``)
+whose binaries differ per OS/architecture — they cannot be vendored portably
+into one bundle. So rather than ship binaries, we provision them on the user's
+own machine on first launch:
+
+  1. Fast path — if ``rayonne_mcp`` and its dependencies already import in the
+     current interpreter (developer machines, or an already-provisioned
+     Python), run the server in-process.
+  2. Otherwise, create a private per-user virtual environment and ``pip
+     install`` the wheel bundled next to this script under ``wheels/`` (pip
+     resolves the correct per-platform binaries), then exec the installed
+     ``rayonne-mcp`` console script. The venv is keyed by the wheel filename,
+     so a bundle upgrade provisions a fresh environment automatically.
+
+This makes a single cross-platform bundle work with no prerequisite beyond a
+Python 3.10+ interpreter — exactly what the bundle README promises. All
+diagnostics go to stderr; stdout is reserved for the MCP stdio protocol.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent  # .../server
+SRC = HERE / "src"
+WHEELS = HERE / "wheels"
+
+
+def _log(msg: str) -> None:
+    print(f"[rayonne-mcp bootstrap] {msg}", file=sys.stderr, flush=True)
+
+
+def _run_in_process() -> bool:
+    """Run the server with the current interpreter if deps are importable.
+
+    Returns False (without side effects beyond a sys.path insert) when the
+    dependencies are not present, so the caller can fall back to provisioning.
+    """
+    if SRC.is_dir():
+        sys.path.insert(0, str(SRC))
+    try:
+        import mcp  # noqa: F401
+
+        from rayonne_mcp.server import run
+    except Exception:
+        return False
+    _log("dependencies already present — running in-process")
+    run()
+    return True
+
+
+def _bundled_wheel() -> Path | None:
+    if not WHEELS.is_dir():
+        return None
+    wheels = sorted(WHEELS.glob("rayonne_mcp-*.whl"))
+    return wheels[-1] if wheels else None
+
+
+def _data_root() -> Path:
+    if os.name == "nt":
+        return Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support"
+    # Linux / other POSIX — honour XDG
+    return Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+
+
+def _venv_dir(wheel: Path) -> Path:
+    # Key by wheel filename so a new bundle version provisions a fresh venv.
+    return _data_root() / "rayonne-mcp" / f"venv-{wheel.stem}"
+
+
+def _venv_python(vdir: Path) -> Path:
+    if os.name == "nt":
+        return vdir / "Scripts" / "python.exe"
+    return vdir / "bin" / "python"
+
+
+def _venv_console(vdir: Path) -> Path:
+    if os.name == "nt":
+        return vdir / "Scripts" / "rayonne-mcp.exe"
+    return vdir / "bin" / "rayonne-mcp"
+
+
+def _provision(wheel: Path) -> Path:
+    import subprocess
+    import venv
+
+    vdir = _venv_dir(wheel)
+    marker = vdir / ".provisioned"
+    py = _venv_python(vdir)
+
+    # Fast-path: only skip provisioning when the sentinel records the *exact*
+    # wheel filename — a partial install (crash mid-pip) or a different wheel
+    # will have a missing or mismatched sentinel and triggers re-provisioning.
+    sentinel_ok = marker.exists() and marker.read_text().strip() == wheel.name
+    if not sentinel_ok:
+        _log(f"provisioning environment in {vdir} (wheel={wheel.name})…")
+        if not py.exists():
+            venv.EnvBuilder(with_pip=True).create(vdir)
+        # Remove a stale sentinel before installing so a crash mid-pip leaves
+        # no sentinel (not a stale one that would fool the next launch).
+        if marker.exists():
+            marker.unlink()
+        subprocess.check_call(
+            [
+                str(py),
+                "-m",
+                "pip",
+                "install",
+                "--quiet",
+                "--disable-pip-version-check",
+                str(wheel),
+            ]
+        )
+        marker.write_text(wheel.name)
+        _log("environment ready")
+    return vdir
+
+
+def main() -> None:
+    if _run_in_process():
+        return
+
+    wheel = _bundled_wheel()
+    if wheel is None:
+        _log(
+            "FATAL: dependencies are not installed and no bundled wheel was "
+            "found. Reinstall the bundle, or run 'uv tool install rayonne-mcp'."
+        )
+        sys.exit(1)
+
+    vdir = _provision(wheel)
+    console = _venv_console(vdir)
+    if console.exists():
+        exe, argv = str(console), [str(console)]
+    else:  # fall back to the module entry point
+        py = str(_venv_python(vdir))
+        exe, argv = py, [py, "-m", "rayonne_mcp"]
+    _log(f"launching {argv[0]}")
+    os.execv(exe, argv)
+
+
+if __name__ == "__main__":
+    main()

rayonne_mcp-0.2.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "rayonne-mcp"
+version = "0.2.0"
+description = "Rayonne MCP server — pilote le workspace Rayonne (audit marketing, analyse produit, contenus, vidéos, métriques AARRR) depuis tout agent compatible MCP."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "SPONGE THEORY PROPRIETARY LICENSE" }
+authors = [{ name = "Sponge Theory", email = "contact@sponge-theory.ai" }]
+keywords = ["mcp", "marketing", "rayonne", "claude", "sponge-theory"]
+
+dependencies = [
+    # <2 : la 2.0 a déplacé FastMCP hors de mcp.server.fastmcp ; la série 1.x
+    # est celle qu'audigeo-mcp fait tourner en production.
+    "mcp[cli]>=1.2.0,<2",
+    "httpx>=0.27,<1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+    "respx>=0.21",
+]
+
+[project.scripts]
+rayonne-mcp = "rayonne_mcp.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rayonne_mcp"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

rayonne_mcp-0.2.0/src/rayonne_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Rayonne MCP server — public read API v1 over stdio MCP."""
+
+__version__ = "0.1.0"

rayonne_mcp-0.2.0/src/rayonne_mcp/client.py

@@ -0,0 +1,122 @@
+"""HTTP client for the Rayonne public API v1 (lecture ET écriture).
+
+Pure httpx, no MCP imports — testable seule (respx), réutilisable par un
+futur connecteur Zapier. Contrat serveur : ``docs/API.md`` du repo Rayonne.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+DEFAULT_API_URL = "https://rayonne.ai/api/public/v1"
+
+
+class RayonneConfigError(RuntimeError):
+    """Raised on the first call when no API key is configured."""
+
+
+class RayonneClient:
+    """Thin async client. ``async with RayonneClient() as c: ...``"""
+
+    def __init__(
+        self, *, api_url: str | None = None, api_key: str | None = None
+    ) -> None:
+        raw_url = api_url or os.environ.get("RAYONNE_API_URL") or DEFAULT_API_URL
+        self.api_url = raw_url.rstrip("/")
+        # Tolère l'URL racine du déploiement : on complète le chemin public.
+        if not self.api_url.endswith("/api/public/v1"):
+            self.api_url = f"{self.api_url}/api/public/v1"
+        self.api_key = api_key or os.environ.get("RAYONNE_API_KEY") or ""
+        self._http: httpx.AsyncClient | None = None
+
+    async def __aenter__(self) -> "RayonneClient":
+        self._http = httpx.AsyncClient(timeout=30)
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        if self._http is not None:
+            await self._http.aclose()
+            self._http = None
+
+    def _headers(self) -> dict[str, str]:
+        if not self.api_key:
+            raise RayonneConfigError(
+                "No Rayonne API key configured. Create one in Rayonne → "
+                "Réglages → Clés API (rk_…, Business plan required) and set "
+                "RAYONNE_API_KEY."
+            )
+        return {"Authorization": f"Bearer {self.api_key}"}
+
+    async def _get(self, path: str, params: dict[str, Any] | None = None) -> Any:
+        assert self._http is not None, "use `async with RayonneClient()`"
+        resp = await self._http.get(
+            f"{self.api_url}{path}", params=params, headers=self._headers()
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    async def overview(self) -> dict[str, Any]:
+        return await self._get("/overview")  # type: ignore[no-any-return]
+
+    async def list_content(
+        self, *, status: str | None = None, limit: int = 50
+    ) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {"limit": limit}
+        if status:
+            params["status"] = status
+        return await self._get("/content", params)  # type: ignore[no-any-return]
+
+    async def list_submissions(
+        self, *, status: str | None = None, limit: int = 50
+    ) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {"limit": limit}
+        if status:
+            params["status"] = status
+        return await self._get("/submissions", params)  # type: ignore[no-any-return]
+
+    async def metrics_aarrr(self, *, span_days: int = 14) -> dict[str, Any]:
+        return await self._get(  # type: ignore[no-any-return]
+            "/metrics/aarrr", {"span_days": span_days}
+        )
+
+    # ── Écriture ────────────────────────────────────────────────────────
+    #
+    # Le serveur applique les mêmes gardes que l'interface (entitlement,
+    # quota facturé, garde SSRF) et déduit TOUJOURS le workspace de la clé.
+    # Côté client il n'y a donc rien à valider : on transmet, et une erreur
+    # métier revient telle quelle au modèle, qui saura la lire.
+
+    async def _post(self, path: str, body: dict[str, Any]) -> Any:
+        assert self._http is not None, "use `async with RayonneClient()`"
+        resp = await self._http.post(
+            f"{self.api_url}{path}", json=body, headers=self._headers()
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    async def create_brief(self, *, product_url: str) -> dict[str, Any]:
+        return await self._post(  # type: ignore[no-any-return]
+            "/briefs", {"product_url": product_url}
+        )
+
+    async def create_video(
+        self, *, locale: str = "fr", video_format: str = "9x16"
+    ) -> dict[str, Any]:
+        return await self._post(  # type: ignore[no-any-return]
+            "/video", {"locale": locale, "format": video_format}
+        )
+
+    async def run_marketing_audit(
+        self, *, locale: str | None = None, refresh: bool = True
+    ) -> dict[str, Any]:
+        return await self._post(  # type: ignore[no-any-return]
+            "/marketing-audit", {"locale": locale, "refresh": refresh}
+        )
+
+    async def list_marketing_audits(self, *, limit: int = 10) -> list[dict[str, Any]]:
+        return await self._get(  # type: ignore[no-any-return]
+            "/marketing-audit", {"limit": limit}
+        )

rayonne_mcp-0.2.0/src/rayonne_mcp/server.py

@@ -0,0 +1,183 @@
+"""FastMCP wiring — lecture ET écriture sur l'API publique Rayonne v1.
+
+Démarrage TOUJOURS non fatal (même patron que le MCP audigeo) : le serveur
+monte sans clé, chaque outil rend alors un message d'installation clair —
+jamais un crash au boot de Claude.
+
+**Écriture** : les outils qui déclenchent un travail (analyse de produit,
+audit marketing, génération vidéo) consomment du quota et, pour la vidéo,
+de la facturation. Ils sont donc désactivables d'un seul réglage,
+``RAYONNE_READ_ONLY=true``, que l'utilisateur pose à l'installation quand il
+veut explorer sans rien déclencher. Le serveur ne réimplémente aucune garde :
+l'API publique applique déjà l'entitlement, le quota et la garde SSRF, et
+déduit le workspace de la clé. Ce drapeau est un cran de sûreté côté client,
+pas une politique de sécurité.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from rayonne_mcp.client import RayonneClient, RayonneConfigError
+
+logger = logging.getLogger(__name__)
+
+INSTRUCTIONS = """\
+Rayonne MCP — pilot the marketing-autopilot workspace.
+
+READ: `rayonne_overview` (workspace + counts), `rayonne_list_content`
+(latest generated pieces, with predicted_engagement 0-100),
+`rayonne_list_submissions` (per-platform publication status, external_url
+when live), `rayonne_metrics_aarrr` (the AARRR dashboard snapshot),
+`rayonne_list_audits` (past marketing audits of the product page).
+
+WRITE (each consumes quota; video generation is billed):
+`rayonne_analyze_product` (crawl the product page into a fresh brief),
+`rayonne_marketing_audit` (grade the product page's MESSAGE — what it
+promises, to whom, against which alternative, at what price — and say which
+axis caps everything generated downstream), `rayonne_create_video`.
+
+START HERE when a user asks why their generated content is off-message:
+`rayonne_marketing_audit`. A page that leads with its architecture instead
+of the job it does caps every asset built from it — the audit names that
+and returns ready-to-paste rewrites.
+
+Auth: set RAYONNE_API_KEY (an `rk_` key from Rayonne → Réglages → Clés API;
+Business plan) and optionally RAYONNE_API_URL. Set RAYONNE_READ_ONLY=true to
+disable every write tool.
+"""
+
+mcp = FastMCP("rayonne", instructions=INSTRUCTIONS)
+
+
+async def _call(fn: str, /, **kwargs: Any) -> Any:
+    try:
+        async with RayonneClient() as client:
+            return await getattr(client, fn)(**kwargs)
+    except RayonneConfigError as exc:
+        return {"error": "not_configured", "message": str(exc)}
+    except Exception as exc:  # noqa: BLE001 — le message vaut mieux qu'un crash MCP
+        return {"error": "request_failed", "message": str(exc)[:300]}
+
+
+@mcp.tool()
+async def rayonne_overview() -> Any:
+    """Workspace summary: name, product URL, autopilot state, and content /
+    submission counts by status. Call this first."""
+    return await _call("overview")
+
+
+@mcp.tool()
+async def rayonne_list_content(status: str | None = None, limit: int = 50) -> Any:
+    """Latest content pieces (max 100). `status` filters on
+    pending/generating/review/approved/rejected/scheduled/published/failed/
+    cancelled. Each row carries predicted_engagement (0-100) when scored."""
+    return await _call("list_content", status=status, limit=limit)
+
+
+@mcp.tool()
+async def rayonne_list_submissions(status: str | None = None, limit: int = 50) -> Any:
+    """Latest submissions (max 100): platform slug, mode (api/browser_local/
+    semi_auto), status, and external_url once published."""
+    return await _call("list_submissions", status=status, limit=limit)
+
+
+def _read_only() -> bool:
+    return os.environ.get("RAYONNE_READ_ONLY", "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+async def _write(fn: str, /, **kwargs: Any) -> Any:
+    """Comme ``_call``, avec le cran de sûreté lecture seule.
+
+    Le refus est une RÉPONSE, pas une exception : le modèle doit pouvoir la
+    lire et l'expliquer à l'utilisateur plutôt que de voir l'outil planter.
+    """
+    if _read_only():
+        return {
+            "error": "read_only",
+            "message": (
+                "Ce serveur Rayonne est en lecture seule (RAYONNE_READ_ONLY). "
+                "Retire ce réglage dans la configuration du plugin pour "
+                "autoriser les actions qui consomment du quota."
+            ),
+        }
+    return await _call(fn, **kwargs)
+
+
+@mcp.tool()
+async def rayonne_metrics_aarrr(span_days: int = 14) -> Any:
+    """The AARRR snapshot (stages, geo, by_channel, timeseries, deltas) over
+    a sliding window of 1-90 days."""
+    return await _call("metrics_aarrr", span_days=span_days)
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO)
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()
+
+
+@mcp.tool()
+async def rayonne_list_audits(limit: int = 10) -> Any:
+    """Les audits marketing passés de la page produit (verdict, note, axes).
+
+    L'historique montre si une réécriture de page a payé : chaque audit
+    porte sa date et sa note.
+    """
+    return await _call("list_marketing_audits", limit=limit)
+
+
+@mcp.tool()
+async def rayonne_marketing_audit(
+    locale: str | None = None, refresh: bool = True
+) -> Any:
+    """Audite le MESSAGE de la page produit et rend un verdict actionnable.
+
+    Note sept axes — hiérarchie du message, clarté, audience nommée,
+    différenciation, douleur vécue, preuve, offre — et nomme celui qui
+    plafonne tout le reste. Une page qui mène avec son architecture au lieu
+    du métier qu'elle rend bride tout ce que la plateforme génère ensuite :
+    c'est ce que l'audit dit, avec des phrases de remplacement prêtes à
+    coller.
+
+    Distinct d'un audit GEO (visibilité DANS les IA) : ici c'est le message.
+
+    ``refresh`` relit la page avant de noter — laisse-le à True après une
+    modification de la page, sinon tu noterais l'analyse précédente.
+    ``locale`` suit le sélecteur de langue du produit (fr/en).
+
+    202 : l'audit tourne en fond, relis-le avec `rayonne_list_audits`.
+    """
+    return await _write("run_marketing_audit", locale=locale, refresh=refresh)
+
+
+@mcp.tool()
+async def rayonne_analyze_product(product_url: str) -> Any:
+    """Analyse la page produit et en tire un brief frais (crawl + extraction).
+
+    C'est la matière première de tout ce que la plateforme génère. 202 :
+    l'analyse tourne en fond.
+    """
+    return await _write("create_brief", product_url=product_url)
+
+
+@mcp.tool()
+async def rayonne_create_video(locale: str = "fr", video_format: str = "9x16") -> Any:
+    """Génère une vidéo courte à partir du brief courant.
+
+    ATTENTION : consomme du quota vidéo et est FACTURÉE. Formats : 9x16
+    (vertical), 16x9 (paysage), 1x1 (carré). 202 : le rendu tourne en fond.
+    """
+    return await _write("create_video", locale=locale, video_format=video_format)

rayonne_mcp-0.2.0/tests/test_client.py

@@ -0,0 +1,106 @@
+"""RayonneClient contre le contrat public v1 (respx, aucun réseau)."""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+import respx
+from httpx import Response
+
+from rayonne_mcp.client import RayonneClient, RayonneConfigError
+
+BASE = "https://rayonne.test/api/public/v1"
+
+
+@respx.mock
+async def test_overview_hits_the_public_path_with_bearer() -> None:
+    route = respx.get(f"{BASE}/overview").mock(
+        return_value=Response(200, json={"name": "WS", "autopilot": True})
+    )
+    async with RayonneClient(api_url="https://rayonne.test", api_key="rk_x") as c:
+        out = await c.overview()
+    assert out["name"] == "WS"
+    req = route.calls.last.request
+    assert req.headers["authorization"] == "Bearer rk_x"
+
+
+@respx.mock
+async def test_list_content_passes_status_and_limit() -> None:
+    route = respx.get(f"{BASE}/content").mock(return_value=Response(200, json=[]))
+    async with RayonneClient(api_url=BASE, api_key="rk_x") as c:
+        await c.list_content(status="approved", limit=10)
+    url = str(route.calls.last.request.url)
+    assert "status=approved" in url and "limit=10" in url
+
+
+async def test_missing_key_raises_config_error(monkeypatch) -> None:
+    monkeypatch.delenv("RAYONNE_API_KEY", raising=False)
+    async with RayonneClient(api_url=BASE, api_key="") as c:
+        with pytest.raises(RayonneConfigError):
+            await c.overview()
+
+
+@respx.mock
+async def test_metrics_span_days() -> None:
+    route = respx.get(f"{BASE}/metrics/aarrr").mock(
+        return_value=Response(200, json={"stages": {}})
+    )
+    async with RayonneClient(api_url=BASE, api_key="rk_x") as c:
+        await c.metrics_aarrr(span_days=30)
+    assert "span_days=30" in str(route.calls.last.request.url)
+
+
+# ── Écriture (2026-09-01) ────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_running_an_audit_posts_to_the_public_api(respx_mock):
+    route = respx_mock.post("https://x.io/api/public/v1/marketing-audit").mock(
+        return_value=httpx.Response(202, json={"job_id": "j", "resource_id": None})
+    )
+    async with RayonneClient(api_url="https://x.io", api_key="rk_x") as c:
+        out = await c.run_marketing_audit(locale="en", refresh=True)
+    assert out["job_id"] == "j"
+    body = json.loads(route.calls[0].request.content)
+    assert body == {"locale": "en", "refresh": True}
+
+
+@pytest.mark.asyncio
+async def test_a_write_without_a_key_raises_the_config_error():
+    """Même message d'installation que pour la lecture : jamais un crash
+    opaque au premier appel."""
+    async with RayonneClient(api_url="https://x.io", api_key="") as c:
+        with pytest.raises(RayonneConfigError):
+            await c.create_brief(product_url="https://y.io")
+
+
+def test_read_only_disables_every_write_tool(monkeypatch):
+    """Le cran de sûreté est une RÉPONSE lisible, pas une exception : le
+    modèle doit pouvoir l'expliquer à l'utilisateur."""
+    import asyncio
+
+    from rayonne_mcp import server
+
+    monkeypatch.setenv("RAYONNE_READ_ONLY", "true")
+    out = asyncio.run(server._write("create_video"))
+    assert out["error"] == "read_only"
+
+
+def test_read_only_off_lets_writes_through(monkeypatch):
+    import asyncio
+
+    from rayonne_mcp import server
+
+    monkeypatch.delenv("RAYONNE_READ_ONLY", raising=False)
+    called: list = []
+
+    async def fake_call(fn, /, **kw):
+        called.append(fn)
+        return {"ok": True}
+
+    monkeypatch.setattr(server, "_call", fake_call)
+    out = asyncio.run(server._write("create_video", locale="fr"))
+    assert out == {"ok": True}
+    assert called == ["create_video"]