Compare et synchronise les environnements Supabase, y compris le schéma, les RLS, l'auth, le storage et les edge functions.
Aussi connu sous akalsoftware/supaforge, @akal/supaforge
- Étoiles
- 1
- Outils
- 6
- Téléchargements, 30 jours
- 2 761
- Dernière version
- 0.0.46
- Dernier commit
- 15 nov. 2026
- Licence
- MIT
Qu'est-ce que SupaForge MCP ?
Compare et synchronise les environnements Supabase, y compris le schéma, les RLS, l'auth, le storage et les edge functions. Il expose 6 outils, comme list_environments, diff, sync.
Résumé généré à partir du README du projet
À propos du MCP server SupaForge
SupaForge permet aux développeurs de synchroniser les environnements Supabase en comparant les schémas, les politiques RLS, les configurations auth et les edge functions. Il vous permet d'identifier les écarts entre les projets, comme entre une base de données de développement et une instance de production, et de mettre la cible en conformité avec la source. L'outil gère un large éventail de composants de projet, notamment les buckets de storage, les cron jobs, les webhooks, les publications realtime et les descriptions de secrets vault.
Les utilisateurs peuvent l'exécuter localement via npm, Homebrew ou Docker, ou l'intégrer dans des pipelines CI en utilisant GitHub Actions. Il est conçu pour la sécurité, exigeant des flags explicites comme --apply pour effectuer des écritures et --allow-destructive pour les opérations qui suppriment des données. Pour les environnements critiques, le flag --prove permet de répéter les migrations sur une copie jetable pour garantir qu'elles reproduisent la source sans perte de lignes. Cela en fait un choix fiable pour gérer Supabase Cloud, des stacks auto-hébergées ou des cibles PostgreSQL classiques via un agent IA ou un client MCP.
Ce que vous pouvez faire avec
- 1Identifier les écarts d'environnementComparez une base de données de développement avec une base de données de production pour voir exactement ce qui a changé.
- 2Appliquer des changements de schéma en toute sécuritéSynchronisez votre base de données cible avec un projet source en utilisant des transactions ordonnées par dépendances.
- 3Répéter les migrations avant le déploiementTestez vos scripts de migration sur une copie temporaire de votre base de données pour éviter toute perte de données.
- 4Cloner des bases de données distantes localementCréez une copie locale d'une base de données distante, y compris ses données, à des fins de test.
Extrait du README du projet. Chaque cas d'utilisation est vérifié par rapport à une citation du document.
Comment installer SupaForge MCP
Formats vérifiés le 10 nov. 2026Ajouter à CursorAjouter à GooseInstaller SupaForge MCP dans Claude Code
$ claude mcp add supaforge -- npx -y @akal/supaforge mcpInstaller SupaForge MCP dans Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"supaforge": {
"command": "npx",
"args": [
"-y",
"@akal/supaforge",
"mcp"
]
}
}
}Installer SupaForge MCP dans VS Code
.vscode/mcp.json
{
"servers": {
"supaforge": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@akal/supaforge",
"mcp"
]
}
}
}Installer SupaForge MCP dans VS Code CLI
$ code --add-mcp '{"name":"supaforge","type":"stdio","command":"npx","args":["-y","@akal/supaforge","mcp"]}'Installer SupaForge MCP dans Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"supaforge": {
"command": "npx",
"args": [
"-y",
"@akal/supaforge",
"mcp"
]
}
}
}Installer SupaForge MCP dans Codex
$ codex mcp add supaforge -- npx -y @akal/supaforge mcpInstaller SupaForge MCP dans Codex config.toml
~/.codex/config.toml
[mcp_servers.supaforge] command = "npx" args = ["-y", "@akal/supaforge", "mcp"]
Installer SupaForge MCP dans Gemini CLI
$ gemini mcp add -s user supaforge npx -- -y @akal/supaforge mcpInstaller SupaForge MCP dans Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"supaforge": {
"command": "npx",
"args": [
"-y",
"@akal/supaforge",
"mcp"
]
}
}
}Démarré par HostedMCP le 16 nov. 2026
Nous avons lancé cette commande pour @akal/supaforge 0.0.46 dans un conteneur isolé, sans réseau ni clé. Il a répondu et listé 6 outils.
Outils MCP SupaForge 6
Lu sur le serveur avec tools/listlist_environmentsLecture seuleList the environments in supaforge.config.json, and which are the default source and target. Says whether each has the Supabase project details the API-based checks need; never returns credentials.
diffLecture seuleCompare two Supabase environments and report every difference: schema, RLS, roles and grants, auth, storage, Edge Functions, cron and more. Returns the findings with their SQL, a drift score, and the plan: the statements sync would run, in order, and what it would hold back and why. Writes nothing. Show the plan to the user before calling sync.
syncActionMake the target environment match the source by running the plan diff shows. WRITES TO THE TARGET DATABASE: call diff first, show the user the plan, and call this only once they agree, with the same arguments. SQL fixes run in one transaction and roll back together if any fails. prove=true first rehearses the plan on a throwaway copy of the target and refuses to write if the result would not match the source.
take_snapshotActionCapture a point-in-time snapshot of a Supabase environment. Snapshots are stored under .supaforge/snapshots/ and can be used to restore state.
create_migrationActionWrite the schema difference between source and target as a migration file, as `supaforge migrate create` does: the SQL that brings the target to the source, the grants on what it creates (so it works where new tables are not granted by default), and a DOWN to revert it. Written to the configured migrations directory (supabase/migrations by default). Changes no database.
get_check_resultLecture seuleRetrieve the result for one check from the most recent diff or sync call. Returns issues, status, and duration for the named check.
| list_environments | List the environments in supaforge.config.json, and which are the default source and target. Says whether each has the Supabase project details the API-based checks need; never returns credentials. | Lecture seule |
| diff | Compare two Supabase environments and report every difference: schema, RLS, roles and grants, auth, storage, Edge Functions, cron and more. Returns the findings with their SQL, a drift score, and the plan: the statements sync would run, in order, and what it would hold back and why. Writes nothing. Show the plan to the user before calling sync. | Lecture seule |
| sync | Make the target environment match the source by running the plan diff shows. WRITES TO THE TARGET DATABASE: call diff first, show the user the plan, and call this only once they agree, with the same arguments. SQL fixes run in one transaction and roll back together if any fails. prove=true first rehearses the plan on a throwaway copy of the target and refuses to write if the result would not match the source. | Action |
| take_snapshot | Capture a point-in-time snapshot of a Supabase environment. Snapshots are stored under .supaforge/snapshots/ and can be used to restore state. | Action |
| create_migration | Write the schema difference between source and target as a migration file, as `supaforge migrate create` does: the SQL that brings the target to the source, the grants on what it creates (so it works where new tables are not granted by default), and a DOWN to revert it. Written to the configured migrations directory (supabase/migrations by default). Changes no database. | Action |
| get_check_result | Retrieve the result for one check from the most recent diff or sync call. Returns issues, status, and duration for the named check. | Lecture seule |
Vérifications automatisées
Exécuté le 12 nov. 2026Rapport complet →A passé nos vérifications automatisées. Il ne s'agit pas d'un audit de sécurité : lisez le code et donnez au serveur l'accès le plus restreint dont il a besoin. Fonctionnement des vérifications
- Dépôt source lié et accessibleRéussi
- Licence open source (OSI)Réussi
- Commit ou version publiée au cours de l'année écouléeRéussi
- Nom du package non proche d'un package populaireRéussi
- L'endpoint distant utilise HTTPSNon vérifié
- Les outils destructifs sont étiquetésNon vérifié
- Aucune instruction cachée destinée au modèleRéussi
- Aucun avis critique dans le package ou ses dépendancesRéussi
README
Voir sur GitHubsupaforge
Diff and sync your Supabase environments.
SupaForge compares two Supabase projects (dev and prod, say) across everything that makes up a project, not just the schema. It reports every difference and makes the target match the source. Fixes run in dependency order, in one transaction, and can be proved on a throwaway copy before anything changes. With a single project, it snapshots, restores and clones it.
- The whole project. It covers schema, RLS, storage, auth, Edge Functions, cron, webhooks, Realtime, queues, partition sets, Vault, extensions, grants, reference data and migration history.
- Safe by default. Every write needs
--apply, and anything that loses data or opens up access also needs--allow-destructive. A failed apply leaves the target exactly as it was. - Production-aware. Each fix says what it does to a live database: the lock it holds and on which table, whether it may rewrite the table or scan every row, whether it can't run in a transaction.
- Provable.
--proverehearses the migration and refuses to apply one that wouldn't reproduce the source or would lose rows. - Anywhere. It works with Supabase Cloud, self-hosted stacks, plain PostgreSQL targets, CI pipelines and AI agents (MCP).
Built by Akal.
Quick start
npm install -g @akal/supaforge
supaforge init # create supaforge.config.json
supaforge diff # what has drifted?
supaforge diff --detail # with the SQL
supaforge diff --apply # fix the target
Everything that writes previews first. Add --apply to make it happen.
Install
| npm | npm install -g @akal/supaforge, or run it with npx @akal/supaforge |
| Homebrew | brew install akalsoftware/tap/supaforge |
| Docker | docker run --rm -v "$PWD:/work" ghcr.io/akalsoftware/supaforge diff |
| GitHub Actions | akalsoftware/supaforge-action — see CI |
| VS Code and its forks | The SupaForge extension: commands, and the MCP server for the editor's agent. Each release carries it as a .vsix |
| Cursor, VS Code, Claude | One-click installs of the MCP server — see MCP |
It needs Node.js 22 or newer. DBDiff, its diff engine, comes with it as a
native binary for your platform, so there is nothing else to install. The
Docker image needs nothing at all, and carries the PostgreSQL client tools
--prove uses; pass connection strings with -e, and mount the project at
/work.
What it compares
| Check | What it reads | Fixed with |
|---|---|---|
| Schema | @dbdiff/cli: every schema you own |
SQL |
| Reference data | Rows of the tables in checks.data.tables |
SQL |
| RLS policies | pg_policies, compared by meaning, not text |
SQL |
| RLS coverage | Tables in the target with RLS off (target only) | SQL, opt-in |
| Edge Functions | Management API, Studio, or a functions directory | Deploy command |
| Storage | Buckets and their policies (objects are never copied) | API and SQL |
| Auth config | Management API, or GoTrue on self-hosted | API (hosted) |
| Cron jobs | cron.job |
SQL |
| Queues | Supabase Queues (pgmq.meta), created and dropped through pgmq |
SQL |
| Partition sets | pg_partman registrations (part_config), made with create_parent |
SQL |
| Webhooks | Triggers calling supabase_functions.http_request |
SQL |
| Realtime | Publications, and policies on realtime.messages |
SQL |
| Vault | Secret names and descriptions (values can't be read) | Command to run |
| Extensions | pg_extension |
SQL |
| Migration history | Local migration files against supabase_migrations (target only) |
SQL, opt-in |
| Roles and grants | Custom roles, and grants on tables, views, sequences and functions, including anon, authenticated, service_role |
SQL |
The schema check covers tables, columns, keys, indexes, partitions, views,
materialized views, functions, aggregates, triggers, event triggers, rules,
sequences, enums, composite and range types, domains, casts, extended
statistics, text search configurations and dictionaries, foreign servers,
user mappings and foreign tables, policies, default privileges, replica
identity, statistics targets, extensions and comments. A renamed column,
table or sequence is renamed, keeping its rows, rather than dropped and
created again. It runs in every schema except Supabase's own (auth,
storage, and so on) and those in ignoreSchemas. Objects owned by an
extension belong to it and aren't compared. Objects of a kind it doesn't
compare, such as operator classes, are named under the check so you can look
at them by hand; they aren't counted as drift.
A check that can't run, for example without API credentials, says so and why. It's never reported as a clean pass.
Commands
supaforge init Create a config interactively
supaforge diff Report drift (alias: hukam)
supaforge sync Alias for diff --apply
supaforge snapshot --apply Capture an environment's structure and configuration
supaforge restore --apply Rebuild a database from a snapshot or migrations
supaforge clone --apply Copy a remote database to a local one
supaforge migrate create Write a migration file from the current drift
supaforge migrate list Local migrations, applied and pending
supaforge migrate run --apply Run pending migrations
supaforge migrate baseline --apply Mark migrations applied without running them
supaforge report Recent runs, from a local log
supaforge mcp MCP server for AI agents
supaforge help <command> Every flag, e.g. help diff
Useful diff flags:
| Flag | Does |
|---|---|
--check=rls / --skip=storage |
One check, or all but some (--skip repeats) |
--tables=orders,items / --exclude-tables='*_log' |
Scope the schema and data checks |
--only=<id,...> |
Apply only these findings (ids come from --json, globs allowed) |
--dry-run |
Print the fixes in the order they'd run, run nothing |
--prove |
Rehearse the fixes on a throwaway copy first |
--source-dir <dir> |
Compare a directory of schema files (such as supabase/schemas) with the target instead of a source database |
--allow-destructive |
Also apply drops and deletes |
--apply-posture |
Also apply the target-only checks' fixes |
--no-transaction |
Apply fix by fix, keeping what works |
--no-snapshot |
Read each query on its own. By default each database is read as of one instant, so a change made while the scan runs is seen by all of it or none; as with pg_dump, what it reads stays locked until the scan ends |
--json / --ci |
Machine-readable output; CI annotations and exit codes |
Applying fixes safely
- Preview first.
diff,snapshot,restore,cloneandmigrate runwrite nothing without--apply. - Destructive fixes need a second flag. Dropping a schema, table or
column, deleting or truncating rows, and removing an RLS policy are reported
but skipped until you add
--allow-destructive.migrate runuses the same gate. - Dependency order. Fixes run in dependency order: functions before the triggers that call them, columns before their indexes, drops last. A changed object that has to be dropped and recreated is a single fix.
- One transaction. If a fix fails, the whole set rolls back and the target is unchanged. A fix the target can't hold, because it needs an extension or a Supabase schema the target lacks, is skipped with the reason, and the rest still applies.
--prove. The fixes are replayed on a copy of the target's structure, made on the target's own server, the way the apply will run them, with a sample of each table's rows. Nothing is applied unless the result matches the source and the rows survive, and nothing is applied if the proof can't run. It also names the tables the fixes rewrite. Changes a copy can't hold, such as cron jobs (pg_cron lives in one database per server), are listed as not proved.
supaforge diff --dry-run # the plan, in order
supaforge diff --apply --prove # rehearse, then apply
supaforge diff --apply --only='schema-create-*'
Posture checks
RLS coverage and migration history look at the target alone, so they report
the same findings whichever pair you diff. They're scored separately
(Posture score), don't set the exit code unless you pass
--fail-on-posture, and their fixes apply only with --apply-posture, or
when you name the check, as in --check=rls-coverage --apply. Applying them
blindly would move the target away from the source.
Snapshot, restore and clone
supaforge snapshot --env=prod --apply # capture
supaforge snapshot --env=prod --migration --apply # and write what changed since the last one
supaforge restore --env=local --from-snapshot=latest --apply
supaforge clone --env=prod --apply # local copy, data included
A snapshot records a project's structure and configuration: schema, RLS
policies, cron, webhooks, extensions, storage, auth, Edge Functions,
reference data, Realtime, Vault names and grants. It is not a
backup. It holds no rows beyond checks.data.tables, and no stored files.
Its schema is written as SQL by pg_dump, which has to be at least as new as
the server; without one the snapshot can still be diffed but not restored, and
snapshot exits 1 unless --allow-schema-json-only says that is enough.
restore --from-snapshot puts back:
| Restored | Notes |
|---|---|
| Extensions, schema, RLS policies, cron jobs, webhooks, Realtime publications, grants | As SQL, in dependency order. Roles a policy or grant names are created first |
| Storage policies and buckets | Bucket rows are created when the target has a storage schema; files never are |
| Reference data | The rows of checks.data.tables, parents before children, sequences moved past the restored ids |
It can't put back auth config, Edge Functions (deploy them with
supabase functions deploy), or Vault secret values. Each of these is named in
the output.
- Targets. Restore runs as one transaction and expects an empty database.
--forceclears the snapshot's own schemas first (never Supabase's) and puts back the triggers and policies outside them that depended on what it cleared. A restore or apply that looks likely to need more locks than the target allows in one transaction says so before it starts;--no-transactioncommits as it goes instead. - Plain PostgreSQL. Restoring into plain PostgreSQL works. What can't
exist there is skipped and named: a foreign key to
auth.users, a webhook, an extension the server doesn't ship, and everything that needs it. - Exit code. A restore that left anything out exits 1. So does one that refused to run.
- JSON.
--jsonprints only JSON, for a preview too.
clone copies a remote database into a local server with pg_dump and
pg_restore (--schema-only to leave the rows behind). Extensions the local
server has are installed first. Objects it couldn't restore are listed by
cause. Afterwards the config's target points at the clone, so a bare
diff --apply writes there rather than to the remote.
Migrations
supaforge migrate create --name=add_orders # from the drift between source and target
supaforge migrate run --env=prod # preview
supaforge migrate run --env=prod --apply
- Files and history. Files live in
supabase/migrations(setchecks.migrations.dirto change it). Applied versions are recorded insupabase_migrations.schema_migrations, the Supabase CLI's table. - Destructive statements.
migrate createlists any it wrote, andmigrate runneeds--allow-destructiveto run them. - History table permissions. On a self-hosted stack the history table can
belong to an admin role. SupaForge then says which
GRANTis needed instead of failing with a bare permission error. - Projects without a tracked history.
checks.migrations.modedecides how the migration-history check reports them:auto(one note when nothing is tracked),warnorignore.
Configuration
{
"environments": {
"dev": { "dbUrl": "$DEV_DATABASE_URL", "projectRef": "abc123", "accessToken": "$SUPABASE_ACCESS_TOKEN" },
"prod": { "dbUrl": "$PROD_DATABASE_URL", "projectRef": "xyz789", "accessToken": "$SUPABASE_ACCESS_TOKEN" }
},
"source": "dev",
"target": "prod",
"checks": {
"data": { "tables": ["plans", "feature_flags"] },
"exclude": ["edge-functions"]
}
}
| Field | Meaning |
|---|---|
dbUrl |
PostgreSQL connection string. $VAR and ${VAR} are read from the environment |
projectRef, accessToken |
Enable the Management API checks (auth, Edge Functions) |
apiUrl |
A self-hosted API gateway, used instead of projectRef |
studioUrl, functionsPath |
Where self-hosted Edge Functions are read from |
source, target |
What to compare: the source is the truth, the target gets fixed |
ignoreSchemas |
Schemas of your own to leave out |
checks.data.tables |
Tables whose rows are compared and snapshotted |
checks.exclude |
Checks never to run (merged with --skip) |
checks.tables, checks.excludeTables |
Default scope for the schema and data checks |
checks.migrations.dir, checks.migrations.mode |
Where migrations live and how the history check reports |
- Per environment.
checks.excludeandchecks.schema.timeoutcan also be set on an environment, and apply when it's the target. .envfiles..envfiles are loaded the Next.js way:.env.{NODE_ENV}.local,.env.local,.env.{NODE_ENV},.env. Values already in the environment win.- Single database. A config with a single environment and no
source/targetis fine. Usesnapshot,cloneandrestore.
| Environment variable | Default | Purpose |
|---|---|---|
SUPAFORGE_DBDIFF_TIMEOUT |
600 |
Seconds before the schema or data diff gives up |
SUPAFORGE_DBDIFF_MEMORY |
1G |
Memory limit for @dbdiff/cli (2G, -1 for none) |
SUPAFORGE_CONNECT_TIMEOUT |
15 |
Seconds to wait for a connection |
SUPAFORGE_CHECK_CONCURRENCY |
4 |
Checks run at once. Lower it behind a tight pooler |
SUPAFORGE_PROVE_ROWS |
1000 |
Rows of each table --prove copies to check they survive; 0 checks structure only |
SUPAFORGE_PG_BIN |
— | A directory of PostgreSQL client tools (pg_dump, psql), used ahead of PATH — for a server newer than the tools on PATH |
Self-hosted Supabase
Set apiUrl to the gateway and accessToken to the service-role key. All
checks run.
- Edge Functions. Self-hosted has no management endpoint for Edge
Functions, so set
studioUrl(Studio's port, not the gateway's) orfunctionsPath(the mounted functions directory). The two can be mixed across environments. Studio's functions API is unauthenticated, so don't expose it publicly. - Auth config. On self-hosted, auth config is read from GoTrue's settings endpoint, which carries fewer keys and can't be written. Change the deployment's environment instead.
Diffing a clone
A local clone is plain PostgreSQL. Storage, auth, Edge Functions, Vault, Realtime and Supabase's roles have nothing to compare there, so skip those checks:
{ "checks": { "exclude": ["storage", "auth", "edge-functions", "vault", "realtime", "roles"] } }
When the source is a clone and the target isn't, diff warns that --apply
would push the clone's shape, absences included, onto the target.
CI and exit codes
The GitHub Action runs
diff --ci and adds a summary of the drift to the job page:
- uses: akalsoftware/supaforge-action@v1
env:
DEV_DATABASE_URL: ${{ secrets.DEV_DATABASE_URL }}
PROD_DATABASE_URL: ${{ secrets.PROD_DATABASE_URL }}
Anywhere else, run the CLI:
npx @akal/supaforge diff --ci
| Code | Meaning |
|---|---|
0 |
Did what was asked, including when there was nothing to do |
1 |
Found drift, declined to act, or something failed or was left out |
2 |
Couldn't run: a usage error, or under --ci a check that couldn't finish |
--ci fails on critical drift by default. Set the threshold with
--fail-on=warning or --fail-on=any.
MCP (AI agents)
SupaForge runs as an MCP server, so an AI agent in your editor can scan for drift and fix it, asking you before anything is written.
-
Claude Desktop: download the extension for your platform (
supaforge-<version>-<platform>.mcpb) from the latest release and open it. It asks for your project directory. -
Claude Code: install the plugin, which adds the MCP server and a skill for applying fixes safely:
/plugin marketplace add akalsoftware/claude-plugins /plugin install supaforge@akalsoftwareor add just the server:
claude mcp add supaforge -- npx -y @akal/supaforge mcp -
Any other client:
{ "mcpServers": { "supaforge": { "command": "npx", "args": ["-y", "@akal/supaforge", "mcp", "--project", "/path/to/project"] } } }
It is listed in the MCP Registry
as io.github.akalsoftware/supaforge.
The server exposes these tools:
| Tool | What it does | Annotation |
|---|---|---|
list_environments |
The environments in the config, without their credentials | Read-only |
diff |
Every difference, with the plan sync would run |
Read-only |
get_check_result |
One check's result from the last diff or sync |
Read-only |
sync |
Runs the plan on the target; prove: true rehearses it on a copy first |
Destructive |
create_migration |
Writes the drift as a migration file, as migrate create does |
Writes files |
take_snapshot |
Snapshots an environment to local files | Writes files |
diff and sync take the same arguments, so the plan an agent shows you is
the plan that runs. Fixes that drop tables or columns are held back unless
allowDestructive is set.
It reads supaforge.config.json in the directory given by --project (or the
one it starts in), and refuses a configPath from a client unless started
with --allow-config-path.
Hooks
import { HookBus, scan, createDefaultRegistry, loadConfig } from '@akal/supaforge'
const bus = new HookBus()
bus.on('supaforge.check.after', ({ check, result }) => {
if (result.status === 'drifted') console.log(`Drift in ${check}`)
})
await scan(createDefaultRegistry(), { config: await loadConfig() }, bus)
Development
cd packages/cli
npm install
npm test # unit tests
npm run lint # type-check
./bin/dev.js diff # run from source
| Suite | Command | Needs |
|---|---|---|
| Integration | npm run test:integration |
Docker or Podman |
| Database e2e | npm run test:e2e |
Docker or Podman |
| Scenarios | npx vitest run -c vitest.scenarios.config.ts |
Docker or Podman, pg_dump |
| Supabase e2e | npm run test:e2e:supabase |
Supabase CLI |
| Release candidates | scripts/test-release-candidates.sh --dbdiff ../DBDiff --pg-conformance ../pg-conformance |
Podman or Docker |
The release-candidates script builds DBDiff's binary and the npm packages from local checkouts the way a release does, installs SupaForge against them as a user would, and runs every suite above against that install. It tests changes that span the three projects together, before any of them is released.
The scenario suite migrates every case in the
@akal/pg-conformance corpus in both
directions. It checks the result against the corpus's own state oracle and
against --prove.
License
MIT
Questions sur SupaForge MCP
Comment ajouter SupaForge MCP à Claude Code ?
Exécutez claude mcp add supaforge -- npx -y @akal/supaforge mcp dans votre terminal. Ajoutez --scope user pour le rendre disponible dans tous les projets.
Comment ajouter SupaForge MCP à Cursor ?
Ouvrez ~/.cursor/mcp.json et ajoutez le serveur sous mcpServers, avec la configuration Cursor indiquée dans la section d'installation ci-dessus.
Quels outils SupaForge MCP fournit-il ?
Il expose 6 outils, dont list_environments, diff, sync, take_snapshot, create_migration.
Que compare SupaForge ?
Il compare tous les éléments qui constituent un projet Supabase, notamment le schéma, les politiques RLS, le storage, la configuration auth, les edge functions, les cron jobs, les webhooks et bien plus encore.
Est-il sûr d'appliquer des changements à une base de données de production ?
Oui, c'est sûr par défaut. Chaque écriture nécessite le flag --apply, et les actions destructives comme la suppression de tables nécessitent le flag --allow-destructive. L'outil s'exécute également dans une transaction unique afin qu'en cas d'échec, la cible subisse un rollback.
Puis-je tester les migrations avant de les appliquer ?
Oui, vous pouvez utiliser le flag --prove pour répéter la migration sur une copie temporaire afin de vous assurer qu'elle reproduit la source sans perte de lignes.
Prend-il en charge le PostgreSQL classique ?
Oui, il fonctionne avec des cibles PostgreSQL classiques, bien que certaines fonctionnalités spécifiques à Supabase comme les webhooks ou certaines extensions puissent être ignorées.