@clicbase/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Clicbase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# Serveur MCP Clicbase (tout-en-un)
+
+Donne à Claude (ou tout client MCP) de quoi **provisionner ET administrer** une base
+Clicbase, avec une **clé API** `cbk_…` générée depuis le tableau de bord.
+
+> ⚠️ Cette phrase annonçait « uniquement avec un compte Clicbase (email + mot de
+> passe) » jusqu'au 2026-09-17, alors que le code n'accepte plus que la clé
+> depuis le 2026-09-13. La section « Pourquoi une clé et pas un mot de passe »,
+> plus bas, disait déjà le contraire : personne ne lit la page entière avant de
+> se lancer, et une première ligne fausse envoie chercher au mauvais endroit.
+
+Outils :
+
+- `create_database` — crée/récupère une base pour un site (renvoie connexion Postgres + URL REST + clés anon/service).
+- `get_credentials` — récupère les identifiants d'un projet existant.
+- `run_sql` — exécute du SQL (tables, RLS, policies…) sur un projet.
+- `list_tables` — liste les tables d'un projet.
+- `enable_realtime` — active le temps réel sur une table.
+- `set_oauth_provider` — configure Google OAuth.
+- `set_email_smtp` — configure un SMTP (sinon SMTP interne Clicbase par défaut).
+
+## Lecture seule
+
+```bash
+claude mcp add clicbase \
+  -e CLICBASE_API_KEY=cbk_... \
+  -e CLICBASE_READ_ONLY=1 \
+  -- node /chemin/absolu/vers/mcp/clicbase-mcp.mjs
+```
+
+En lecture seule, les outils qui écrivent ne sont **pas refusés : ils sont
+absents**. Un outil présent qui répond « interdit » laisse l'assistant croire
+qu'un chemin existe, donc essayer, reformuler, insister. Un outil qui n'est pas
+dans la liste n'est jamais demandé.
+
+Ce qui reste : `list_tables`, `describe_table`, `get_oauth_provider`.
+Ce qui part : `run_sql`, `create_database`, `enable_realtime`, `enable_rls`,
+`create_policy`, `set_oauth_provider`, `set_email_smtp`, et **`get_credentials`**.
+
+> `get_credentials` ne modifie rien, et il part quand même. Il rend la clé
+> `service` du projet, laquelle ouvre le SQL complet et contourne la RLS. Le
+> garder reviendrait à retirer `run_sql` d'une main et à livrer de quoi le
+> refaire de l'autre.
+
+Un outil ajouté plus tard sans être classé dans `portee.mjs` est traité comme
+une **écriture** : il disparaît du mode restreint au lieu d'y être admis. Un
+oubli coûte alors une fonction manquante, que l'on remarque ; l'inverse aurait
+coûté une écriture ouverte dans un mode qui promet de ne pas écrire.
+
+## Quand l'utiliser
+
+`run_sql` exécute du SQL arbitraire avec les droits du propriétaire de la base,
+et la clé service **contourne la RLS** : un `SELECT` rend toutes les données
+personnelles du projet en clair, et elles entrent dans le contexte du modèle.
+Six risques n'ont aucune parade côté serveur, dont l'impossibilité de
+distinguer un `DROP TABLE` prévu d'un `DROP TABLE` accidentel.
+
+En clair :
+
+| | mode complet | lecture seule |
+| --- | --- | --- |
+| Ta propre plateforme, sous tes yeux | oui | — |
+| Un agent autonome | non | oui |
+| La base d'un client | non | oui |
+
+## Installation
+
+```bash
+claude mcp add clicbase \
+  -e CLICBASE_API_KEY=cbk_... \
+  -e CLICBASE_READ_ONLY=1 \
+  -- npx -y @clicbase/mcp
+```
+
+> ⚠️ `CLICBASE_READ_ONLY=1` est volontairement dans la commande d'installation.
+> C'est le mode à conseiller par défaut : il retire `run_sql`, la création de
+> projet et la clé `service`. Retire cette ligne seulement quand tu sais
+> pourquoi, et lis la section « Quand l'utiliser » avant.
+
+### Depuis le dépôt
+
+
+```bash
+cd mcp
+npm install
+```
+
+## Configuration dans Claude Code
+
+Le plus simple (depuis le dossier du site à connecter) :
+
+```bash
+claude mcp add clicbase -e CLICBASE_API_KEY=cbk_... -- node /chemin/absolu/vers/mcp/clicbase-mcp.mjs
+```
+
+Ou à la main dans la config MCP (`~/.claude.json` / `claude_desktop_config.json`) :
+
+```json
+{
+  "mcpServers": {
+    "clicbase": {
+      "command": "node",
+      "args": ["/chemin/absolu/vers/mcp/clicbase-mcp.mjs"],
+      "env": {
+        "CLICBASE_API_KEY": "cbk_..."
+      }
+    }
+  }
+}
+```
+
+## Utilisation : « Claude fait tout »
+
+Dans la session Claude du site (ex. exoskool.com), une seule consigne suffit :
+
+> « Connecte ce site à Clicbase via le MCP clicbase. Crée une base `exoskool`
+> (domaine `exoskool.com`), crée le schéma dont le site a besoin (tables + RLS),
+> puis branche le front sur l'API REST (clé anon) et écris les variables dans `.env`. »
+
+Claude appellera `create_database`, puis `run_sql` pour le schéma/RLS, récupèrera
+les clés via `get_credentials`, et câblera le site. Aucune clé à copier-coller à la main.
+
+
+## Pourquoi une clé et pas un mot de passe
+
+Ce serveur envoyait `ROROUIRA_EMAIL` + `ROROUIRA_PASSWORD`. Changé le
+2026-09-13.
+
+Un mot de passe est une **identité** : il ouvre le compte entier, doit vivre
+en clair dans la configuration, et ne laisse aucune trace distinguable. Pour le
+révoquer, il faut le changer partout où il a été collé, sans jamais savoir si
+on a tout trouvé.
+
+Une clé `cbk_…` est une **permission** :
+
+| | mot de passe | clé API |
+| --- | --- | --- |
+| Portée | tout le compte | `vps`, `docker` ou granulaire |
+| Expiration | aucune | `expiresAt`, automatique |
+| Révocation | changer le mot de passe partout | un clic |
+| Stockage serveur | — | seulement un `sha256` |
+| Journal | indistinguable de toi | chaque appel, avec son `keyId` |
+
+La clé se génère depuis le tableau de bord, menu **VPS** ou **Docker** ›
+**Clés API**. Elle n'est affichée qu'une fois : le serveur n'en garde que
+l'empreinte.

package/clicbase-db-mcp.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// Serveur MCP d'administration d'UNE base Clicbase (scopé à un projet).
+// Emballe l'endpoint /sql (clé service) en outils MCP.
+// Env requis : CLICBASE_DB_URL (ex. https://clicbase.com/db/mon-projet)
+//              CLICBASE_SERVICE_KEY (clé service du projet — côté outil uniquement)
+//
+// ⚠️ LES ANCIENS NOMS RESTENT ACCEPTÉS, EN SECOND. `ROROUIRA_DB_URL` et
+// `ROROUIRA_SERVICE_KEY` continuent de fonctionner : une configuration déjà
+// posée chez quelqu'un ne doit pas cesser de marcher parce que nous avons
+// renommé la maison. Ils disparaîtront quand plus personne ne les utilisera.
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { filtre, lectureSeule } from "./portee.mjs";
+
+const BASE = process.env.CLICBASE_DB_URL ?? process.env.ROROUIRA_DB_URL;
+const KEY = process.env.CLICBASE_SERVICE_KEY ?? process.env.ROROUIRA_SERVICE_KEY;
+if (!BASE || !KEY) {
+  console.error(
+    "CLICBASE_DB_URL et CLICBASE_SERVICE_KEY requis. " +
+      "Exemple : CLICBASE_DB_URL=https://clicbase.com/db/mon-projet",
+  );
+  process.exit(1);
+}
+
+const ident = (s) => '"' + String(s).replace(/"/g, '""') + '"';
+const lit = (s) => "'" + String(s).replace(/'/g, "''") + "'";
+
+async function sql(query) {
+  const res = await fetch(`${BASE}/sql`, {
+    method: "POST",
+    headers: { "content-type": "application/json", Authorization: `Bearer ${KEY}` },
+    body: JSON.stringify({ query }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+  return data;
+}
+// Appel générique d'un endpoint du projet (autre que /sql), avec la clé service.
+async function api(path, method = "GET", body) {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: { "content-type": "application/json", Authorization: `Bearer ${KEY}` },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+  return data;
+}
+
+const out = (d) => ({ content: [{ type: "text", text: JSON.stringify(d, null, 2) }] });
+const fail = (e) => ({ isError: true, content: [{ type: "text", text: String(e?.message ?? e) }] });
+
+const server = new McpServer({ name: "clicbase-db", version: "1.0.0" });
+
+// ⚠️ EN LECTURE SEULE, LES OUTILS QUI ECRIVENT NE SONT PAS ENREGISTRES. Voir
+// portee.mjs : un outil absent n'est jamais demande, un outil present qui
+// refuse invite a insister. `outils.tool(...)` remplace l'appel direct.
+const SEULEMENT_LECTURE = lectureSeule();
+const outils = filtre(server, SEULEMENT_LECTURE);
+
+outils.tool(
+  "run_sql",
+  "Exécute du SQL (DDL/DML/RLS) sur la base. Après un changement de schéma, termine par: NOTIFY pgrst, 'reload schema';",
+  { query: z.string() },
+  async ({ query }) => {
+    try {
+      return out(await sql(query));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+outils.tool("list_tables", "Liste les tables du schéma public.", {}, async () => {
+  try {
+    return out(
+      await sql(
+        "select table_name from information_schema.tables where table_schema='public' order by table_name",
+      ),
+    );
+  } catch (e) {
+    return fail(e);
+  }
+});
+
+outils.tool(
+  "describe_table",
+  "Décrit les colonnes d'une table (nom, type, nullable, défaut).",
+  { table: z.string() },
+  async ({ table }) => {
+    try {
+      return out(
+        await sql(
+          `select column_name, data_type, is_nullable, column_default from information_schema.columns where table_schema='public' and table_name=${lit(table)} order by ordinal_position`,
+        ),
+      );
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+outils.tool(
+  "enable_rls",
+  "Active la Row-Level Security sur une table.",
+  { table: z.string() },
+  async ({ table }) => {
+    try {
+      return out(
+        await sql(
+          `alter table ${ident(table)} enable row level security; notify pgrst, 'reload schema';`,
+        ),
+      );
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+outils.tool(
+  "create_policy",
+  "Crée (ou remplace) une policy RLS. using/check sont des expressions SQL (ex: \"auth.uid() is not null\", \"user_id = auth.uid()\").",
+  {
+    table: z.string(),
+    name: z.string(),
+    command: z.enum(["select", "insert", "update", "delete", "all"]),
+    using: z.string().optional(),
+    check: z.string().optional(),
+  },
+  async ({ table, name, command, using, check }) => {
+    try {
+      let s = `drop policy if exists ${ident(name)} on ${ident(table)}; create policy ${ident(name)} on ${ident(table)} for ${command}`;
+      if (using) s += ` using (${using})`;
+      if (check) s += ` with check (${check})`;
+      s += `; notify pgrst, 'reload schema';`;
+      return out(await sql(s));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+outils.tool(
+  "get_oauth_provider",
+  "Donne le statut d'un provider OAuth (ex. google) : activé ou non.",
+  { provider: z.enum(["google"]) },
+  async ({ provider }) => {
+    try {
+      return out(await api(`/auth/providers/${provider}`));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+outils.tool(
+  "set_oauth_provider",
+  "Configure un provider OAuth (ex. google) avec son client_id et son client_secret (chiffré côté serveur). L'URI de redirection à déclarer chez le fournisseur est: <ROROUIRA_DB_URL>/auth/callback/<provider>.",
+  {
+    provider: z.enum(["google"]),
+    client_id: z.string(),
+    client_secret: z.string(),
+  },
+  async ({ provider, client_id, client_secret }) => {
+    try {
+      return out(
+        await api(`/auth/providers/${provider}`, "POST", {
+          client_id,
+          client_secret,
+        }),
+      );
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+// ⚠️ LE MODE RESTREINT S'ANNONCE, SUR LA SORTIE D'ERREUR. Un serveur qui
+// retire des outils en silence se decouvre en pleine session : l'assistant
+// cherche une fonction qui devrait exister, ne la trouve pas, et conclut que le
+// serveur est casse. Deux lignes evitent cette demi-heure. La sortie STANDARD
+// est reservee au protocole MCP : y ecrire casserait la conversation.
+if (SEULEMENT_LECTURE) {
+  console.error(
+    `[clicbase-mcp] LECTURE SEULE. Outils retires : ${outils.retires.join(", ") || "aucun"}.`,
+  );
+  console.error(
+    "[clicbase-mcp] Pour tout ouvrir : retirer CLICBASE_READ_ONLY de la configuration.",
+  );
+}
+
+await server.connect(new StdioServerTransport());

package/clicbase-mcp.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// MCP Clicbase "tout-en-un" : Claude provisionne ET administre une base.
+//
+// ⚠️ AUTHENTIFICATION PAR CLE API, PLUS PAR MOT DE PASSE. Ce fichier envoyait
+// ROROUIRA_EMAIL + ROROUIRA_PASSWORD, ce qui donnait a un programme l'acces au
+// COMPTE ENTIER : pas de portee, pas d'expiration, pas de plafond, aucune
+// trace distinguable dans le journal, et une revocation qui oblige a changer
+// le mot de passe partout ou il a ete colle.
+//
+// Une cle `cbk_…` est une PERMISSION, pas une identite : portee, expiration,
+// revocation d'un clic, et chaque appel journalise avec son keyId. Le secret
+// n'est jamais stocke cote serveur, seulement son sha256.
+//
+// C'etait aussi le seul endroit du depot qui contredisait la regle « Teiki ne
+// se connecte jamais par mot de passe ». Corrige le 2026-09-13.
+//
+//   export CLICBASE_API_KEY=cbk_...   (genere depuis le tableau de bord)
+// L'API de provisioning est idempotente -> on l'utilise aussi pour résoudre
+// dynamiquement l'URL + la clé service d'un projet (par nom).
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { filtre, lectureSeule } from "./portee.mjs";
+
+const API = process.env.CLICBASE_API ?? process.env.ROROUIRA_API ?? "https://clicbase.com/api/v1/databases";
+
+/** La cle, lue une fois. Absente, on le dit tout de suite plutot que de
+ *  laisser chaque appel echouer en 401 sans expliquer ce qui manque. */
+const CLE = process.env.CLICBASE_API_KEY;
+if (!CLE) {
+  console.error(
+    "CLICBASE_API_KEY manquante. Genere une cle depuis le tableau de bord " +
+      "(menu VPS ou Docker > Cles API), puis : export CLICBASE_API_KEY=cbk_...",
+  );
+  process.exit(1);
+}
+const out = (d) => ({ content: [{ type: "text", text: typeof d === "string" ? d : JSON.stringify(d, null, 2) }] });
+const fail = (e) => ({ isError: true, content: [{ type: "text", text: String(e?.message ?? e) }] });
+
+// Provisionne (ou récupère, idempotent) un projet et renvoie ses infos.
+const cache = new Map();
+async function resolve(name, domain) {
+  if (cache.has(name)) return cache.get(name);
+  const res = await fetch(API, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      // ⚠️ UNE CLE, PAS UN MOT DE PASSE. Voir l'en-tete du fichier.
+      authorization: `Bearer ${CLE}`,
+    },
+    body: JSON.stringify({ name, domain }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(`Clicbase ${res.status}: ${JSON.stringify(data)}`);
+  const info = {
+    url: data.restApi?.url,
+    anonKey: data.restApi?.anonKey,
+    serviceKey: data.restApi?.serviceKey,
+    connectionString: data.connectionString,
+    raw: data,
+  };
+  cache.set(name, info);
+  return info;
+}
+
+// Appel d'un endpoint du projet avec la clé service.
+async function call(name, path, method = "POST", body) {
+  const p = await resolve(name);
+  if (!p.url || !p.serviceKey) throw new Error("Projet non résolu (clés manquantes).");
+  const res = await fetch(`${p.url}${path}`, {
+    method,
+    headers: { "content-type": "application/json", Authorization: `Bearer ${p.serviceKey}` },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+  return data;
+}
+
+const server = new McpServer({ name: "clicbase", version: "2.0.0" });
+
+// ⚠️ EN LECTURE SEULE, LES OUTILS QUI ECRIVENT NE SONT PAS ENREGISTRES. Voir
+// portee.mjs : un outil absent n'est jamais demande, un outil present qui
+// refuse invite a insister. `outils.tool(...)` remplace l'appel direct.
+const SEULEMENT_LECTURE = lectureSeule();
+const outils = filtre(server, SEULEMENT_LECTURE);
+
+outils.tool(
+  "create_database",
+  "Crée (ou récupère, idempotent) une base Clicbase pour un site. Renvoie la chaîne de connexion PostgreSQL, l'URL de l'API REST et les clés anon/service.",
+  { name: z.string().describe("Nom du projet, ex. exoskool"), domain: z.string().optional().describe("Domaine, ex. exoskool.com") },
+  async ({ name, domain }) => {
+    try { cache.delete(name); return out((await resolve(name, domain)).raw); } catch (e) { return fail(e); }
+  },
+);
+
+outils.tool(
+  "get_credentials",
+  "Renvoie les identifiants d'un projet existant (connexion Postgres + URL REST + clés anon/service) pour brancher le site.",
+  { name: z.string() },
+  async ({ name }) => { try { return out((await resolve(name)).raw); } catch (e) { return fail(e); } },
+);
+
+outils.tool(
+  "run_sql",
+  "Exécute du SQL (DDL/DML/RLS) sur la base d'un projet. Pour créer des tables, policies RLS, etc. Termine par: NOTIFY pgrst, 'reload schema'; après un changement de schéma.",
+  { name: z.string().describe("Nom du projet"), query: z.string() },
+  async ({ name, query }) => { try { return out(await call(name, "/sql", "POST", { query })); } catch (e) { return fail(e); } },
+);
+
+outils.tool(
+  "list_tables",
+  "Liste les tables du schéma public d'un projet.",
+  { name: z.string() },
+  async ({ name }) => {
+    try { return out(await call(name, "/sql", "POST", { query: "select table_name from information_schema.tables where table_schema='public' order by table_name" })); } catch (e) { return fail(e); }
+  },
+);
+
+outils.tool(
+  "enable_realtime",
+  "Active le temps réel (WebSocket) sur une table d'un projet.",
+  { name: z.string(), table: z.string() },
+  async ({ name, table }) => { try { return out(await call(name, "/realtime/enable", "POST", { table })); } catch (e) { return fail(e); } },
+);
+
+outils.tool(
+  "set_oauth_provider",
+  "Configure un provider OAuth (ex. google) d'un projet. URI de redirection à déclarer chez le fournisseur : <url REST du projet>/auth/callback/<provider>.",
+  { name: z.string(), provider: z.enum(["google"]), client_id: z.string(), client_secret: z.string() },
+  async ({ name, provider, client_id, client_secret }) => {
+    try { return out(await call(name, `/auth/providers/${provider}`, "POST", { client_id, client_secret })); } catch (e) { return fail(e); }
+  },
+);
+
+outils.tool(
+  "set_email_smtp",
+  "Configure le SMTP d'un projet (sinon le SMTP interne Clicbase est utilisé par défaut).",
+  { name: z.string(), host: z.string(), port: z.number().optional(), secure: z.boolean().optional(), username: z.string().optional(), password: z.string().optional(), sender_email: z.string(), sender_name: z.string().optional() },
+  async ({ name, ...cfg }) => { try { return out(await call(name, "/email/config", "POST", cfg)); } catch (e) { return fail(e); } },
+);
+
+// ⚠️ LE MODE RESTREINT S'ANNONCE, SUR LA SORTIE D'ERREUR. Un serveur qui
+// retire des outils en silence se decouvre en pleine session : l'assistant
+// cherche une fonction qui devrait exister, ne la trouve pas, et conclut que le
+// serveur est casse. Deux lignes evitent cette demi-heure. La sortie STANDARD
+// est reservee au protocole MCP : y ecrire casserait la conversation.
+if (SEULEMENT_LECTURE) {
+  console.error(
+    `[clicbase-mcp] LECTURE SEULE. Outils retires : ${outils.retires.join(", ") || "aucun"}.`,
+  );
+  console.error(
+    "[clicbase-mcp] Pour tout ouvrir : retirer CLICBASE_READ_ONLY de la configuration.",
+  );
+}
+
+await server.connect(new StdioServerTransport());

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@clicbase/mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "clicbase-mcp": "clicbase-mcp.mjs",
+    "clicbase-db-mcp": "clicbase-db-mcp.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "description": "Serveur MCP pour Clicbase : provisionner et administrer une base PostgreSQL managee depuis un assistant.",
+  "license": "MIT",
+  "homepage": "https://clicbase.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clicbase/mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/clicbase/mcp/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "clicbase",
+    "postgres",
+    "baas"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "clicbase-mcp.mjs",
+    "clicbase-db-mcp.mjs",
+    "portee.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/portee.mjs

@@ -0,0 +1,108 @@
+// LA PORTÉE DES SERVEURS MCP : ce qu'une IA reçoit, et ce qu'elle ne voit pas.
+//
+// Demande de Teiki le 2026-09-17, après examen de ce que fait Supabase : leur
+// serveur se configure par `read_only=true`, `project_ref` et `features`, et
+// leur première ligne d'installation est un avertissement de sécurité.
+//
+// ⚠️ EN LECTURE SEULE, LES OUTILS QUI ÉCRIVENT NE SONT PAS REFUSÉS : ILS SONT
+// ABSENTS. C'est la seule parade qui tienne. Un outil présent mais qui répond
+// « interdit » laisse l'assistant croire qu'il existe un chemin, donc essayer,
+// reformuler, insister. Un outil qui n'est pas dans la liste n'est jamais
+// demandé : on ne réclame pas ce qu'on ne voit pas.
+//
+// ⚠️ ON NE FILTRE PAS L'INTENTION, ON RETIRE L'OUTIL. `DROP TABLE` est du DDL
+// valide, et le DDL est la raison d'être de `run_sql` : aucune liste de mots
+// interdits ne distingue « supprime l'ancienne table comme prévu » de
+// « supprime la mauvaise ». La seule frontière qui tient passe par la présence
+// de l'outil, pas par l'analyse de ce qu'on lui demande.
+
+/**
+ * Ce que chaque outil fait, du point de vue du risque.
+ *
+ *  · `lecture` : ne modifie rien et ne rend aucun secret.
+ *  · `ecriture` : modifie la base, la configuration ou crée une ressource.
+ *  · `secret` : ne modifie rien, mais REND UNE CLÉ qui, elle, permet tout.
+ *
+ * ⚠️ `secret` EXISTE POUR `get_credentials`, ET CE N'EST PAS UN EXCÈS DE ZÈLE.
+ * Il ne modifie rien, donc il a l'air d'une lecture. Mais il rend la clé
+ * `service` du projet, laquelle ouvre le SQL complet et contourne la RLS.
+ * Le laisser en mode lecture seule reviendrait à retirer `run_sql` d'une main
+ * et à livrer de quoi le refaire de l'autre.
+ */
+export const OUTILS = {
+  // --- serveur « tout-en-un » ---
+  create_database: "ecriture",
+  get_credentials: "secret",
+  run_sql: "ecriture",
+  list_tables: "lecture",
+  enable_realtime: "ecriture",
+  set_oauth_provider: "ecriture",
+  set_email_smtp: "ecriture",
+  // --- serveur « base d'un projet » ---
+  describe_table: "lecture",
+  enable_rls: "ecriture",
+  create_policy: "ecriture",
+  get_oauth_provider: "lecture",
+};
+
+/** Ce qu'on garde en lecture seule. */
+const PERMIS_EN_LECTURE = new Set(["lecture"]);
+
+/**
+ * Le serveur tourne-t-il en lecture seule ?
+ *
+ * ⚠️ TOUTE VALEUR AUTRE QUE « 0 », « false » OU VIDE ACTIVE LE MODE. La
+ * variable est là pour fermer : quelqu'un qui écrit `CLICBASE_READ_ONLY=oui`
+ * veut manifestement fermer, et un jeu de valeurs trop strict lui ouvrirait
+ * tout en silence. On ferme au moindre doute, jamais l'inverse.
+ *
+ * ⚠️ LE PARAMÈTRE EST ANNOTÉ LARGEMENT, ET PAS LAISSÉ À L'INFÉRENCE. Sans cette
+ * ligne, TypeScript déduit le type de la valeur par défaut, donc `ProcessEnv`,
+ * qui EXIGE `NODE_ENV` : un test ne pourrait plus passer un environnement
+ * fabriqué, et la bascule deviendrait invérifiable.
+ *
+ * @param {Record<string, string | undefined>} [env]
+ * @returns {boolean}
+ */
+export function lectureSeule(env = process.env) {
+  const v = (env.CLICBASE_READ_ONLY ?? "").trim().toLowerCase();
+  if (v === "" || v === "0" || v === "false" || v === "non") return false;
+  return true;
+}
+
+/**
+ * Cet outil doit-il être proposé ?
+ *
+ * ⚠️ UN OUTIL INCONNU EST TRAITÉ COMME UNE ÉCRITURE. C'est le point le plus
+ * important de ce fichier. Le jour où quelqu'un ajoute un outil sans le classer
+ * ici, il sera RETIRÉ du mode lecture seule au lieu d'y être admis par défaut.
+ * Un oubli coûte alors une fonction manquante, que l'on remarque ; l'autre
+ * défaut aurait coûté une écriture ouverte dans un mode qui promet de ne pas
+ * écrire, et celui-là ne se remarque pas.
+ */
+export function outilPermis(nom, enLectureSeule) {
+  if (!enLectureSeule) return true;
+  const genre = OUTILS[nom] ?? "ecriture";
+  return PERMIS_EN_LECTURE.has(genre);
+}
+
+/**
+ * Enveloppe `server.tool` pour n'enregistrer que ce qui est permis.
+ *
+ * Renvoie aussi la liste de ce qui a été retiré, pour que le serveur puisse le
+ * DIRE au démarrage : un mode restreint silencieux se découvre en pleine
+ * session, quand un outil attendu manque sans explication.
+ */
+export function filtre(server, enLectureSeule) {
+  const retires = [];
+  return {
+    tool(nom, ...reste) {
+      if (!outilPermis(nom, enLectureSeule)) {
+        retires.push(nom);
+        return;
+      }
+      server.tool(nom, ...reste);
+    },
+    retires,
+  };
+}