platform-mcp

MCP-Server für die Infrastrukturdienste des Clusters sonar-prod — Argo CD, Vault und Keycloak — mit SSO-Anmeldung (GitLab für Argo/Vault, FreeIPA für Keycloak).

Warum

Der Agent im Editor braucht Zugriff auf Argo CD, Vault und Keycloak, aber ein Dienstkonto darf man ihm nicht geben: Im Audit taucht statt einer Person ein gemeinsames Konto auf, und die Rechte wären umfassender als die jedes einzelnen Entwicklers.

Dieses Paket wird lokal installiert und führt eine normale SSO-Anmeldung über den Browser durch. Danach führt es Befehle im Namen des angemeldeten Benutzers aus: In den Audit-Logs ist der echte Login sichtbar, und die Rechte sind genau die, die die Gruppenmitgliedschaft gewährt.

Pro Dienst gibt es genau ein Werkzeug — argocd_exec, vault_exec und keycloak_exec, die Kommandozeilenargumente entgegennehmen. Unter der Haube stecken die offiziellen CLIs (argocd, vault, kcadm), daher ist alles verfügbar, was diese können. Ein neuer Dienst wird mit einer einzigen Interface-Implementierung hinzugefügt.

Related MCP server: mcp-read-only-argocd

Installation

Schritt 1. Zugriff auf die Paket-Registry

Wird einmal benötigt und gilt für alle folgenden Wege: Das Paket liegt in der npm-Registry dieses GitLab-Projekts, nicht im öffentlichen npm. Besorgen Sie sich ein Token mit der Berechtigung read_package_registry (persönliches Access Token oder Deploy-Token des Projekts) und fügen Sie es in ~/.npmrc ein:

@sonar:registry=https://git.sonar-corp.ru/api/v4/projects/98/packages/npm/
//git.sonar-corp.ru/api/v4/projects/98/packages/npm/:_authToken=<ваш gitlab токен>

Schritt 2. Anbindung an den Editor

Claude Code und Cursor — per Plugin. Das Repository ist selbst ein Plugin-Katalog, daher genügen zwei Befehle:

/plugin marketplace add https://github.com/K-manankov/platform-mcp.git
/plugin install platform-mcp

Die Adresse ist GitHub, nicht GitLab, und das ist kein Tippfehler — siehe Warum der Plugin-Katalog auf GitHub liegt.

Die Adressen von Argo CD, Vault und Keycloak sind bereits im Plugin hinterlegt — es muss nichts konfiguriert werden. Updates kommen von selbst: Das Plugin startet den Server über npx -y, also immer die neueste veröffentlichte Version. Das Plugin selbst aktualisieren — /plugin marketplace update.

Claude Desktop installiert Plugins dieses Formats nicht, daher wird der Eintrag dort manuell vorgenommen. Installieren Sie das Paket global:

npm install -g @sonar/platform-mcp

und fügen Sie es in claude_desktop_config.json ein (Settings → Developer → Edit Config). Der Pfad zu node und zum Server muss unbedingt absolut sein: GUI-Anwendungen auf macOS erben PATH nicht aus der Shell. Ihre Pfade ermitteln Sie mit which node und which platform-mcp:

{
  "mcpServers": {
    "platform": {
      "command": "/opt/homebrew/bin/node",
      "args": ["/opt/homebrew/lib/node_modules/@sonar/platform-mcp/dist/index.js"],
      "env": {
        "ARGOCD_BASE_URL": "https://argocd.infra.sonar-corp.ru",
        "VAULT_ADDR": "https://vault.infra.sonar-corp.ru",
        "KEYCLOAK_BASE_URL": "https://auth.infra.sonar-corp.ru",
        "PLATFORM_MCP_INSECURE": "true"
      }
    }
  }
}

Argo CD, Vault und Keycloak müssen in keiner der Varianten separat installiert werden: Der Server lädt die benötigten CLI-Versionen beim ersten Zugriff selbst herunter (siehe Woher argocd, vault und kcadm kommen). Für kcadm muss auf dem Rechner Java 17+ vorhanden sein.

Warum der Plugin-Katalog auf GitHub liegt

Claude Desktop bindet Plugin-Kataloge nur von GitHub ein. Außerdem lebt unser GitLab im internen Netzwerk und ist von außen grundsätzlich nicht erreichbar, sodass es git.sonar-corp.ru ohnehin nicht erreichen würde.

Deshalb bleibt der Quellcode in GitLab, und unter github.com/K-manankov/platform-mcp ist ein Spiegel der geschützten Branches eingerichtet. Geschützt ist ein Branch — main, und genau dieser wandert bei jedem Push zu GitHub. Eine Rücksynchronisierung gibt es nicht: Änderungen werden nur in GitLab vorgenommen, die GitHub-Kopie existiert für die Plugin-Installation.

Der Spiegel selbst gibt nichts Überflüssiges preis — dort liegen derselbe öffentliche npm-Paket und Adressen interner Dienste, die ohnehin nur aus dem Netzwerk aufgelöst werden. Geheimnisse gibt es im Repository nicht und darf es nicht geben: Zugriffstokens hält der Server in ~/.config/platform-mcp/, und das Registry-Token legt sich jeder selbst in ~/.npmrc an.

Das installierte Plugin nach Änderungen aktualisieren:

/plugin marketplace update sonar-infra
/plugin update platform-mcp

Anmeldung

VPN ist erforderlich: Die Namen argocd.infra.sonar-corp.ru, vault.infra.sonar-corp.ru und auth.infra.sonar-corp.ru werden nur von innerhalb des Netzwerks aufgelöst. Von außen fängt sie der öffentliche Wildcard *.infra.sonar-corp.ru ab, und die Anfrage geht still in die falsche Richtung — die Prüfung dig +short argocd.infra.sonar-corp.ru muss 192.168.88.106 ergeben.

Am einfachsten melden Sie sich direkt aus dem Dialog an: Bitten Sie den Agenten, argocd_login, vault_login oder keycloak_login aufzurufen, öffnen Sie den ausgegebenen Link und schließen Sie die Anmeldung ab. Ein Neustart des Editors ist nicht nötig.

Dasselbe aus dem Terminal, wenn das Paket global installiert ist:

export ARGOCD_BASE_URL=https://argocd.infra.sonar-corp.ru
export VAULT_ADDR=https://vault.infra.sonar-corp.ru
export KEYCLOAK_BASE_URL=https://auth.infra.sonar-corp.ru
export PLATFORM_MCP_INSECURE=true   # пока нет настоящих сертификатов, см. TLS

platform-mcp login             # во все настроенные сервисы подряд
platform-mcp login keycloak    # только в один

Ein Browser öffnet sich: für Argo CD und Vault — GitLab-SSO, für Keycloak — FreeIPA im Realm master (Client platform-mcp-cli, siehe Bootstrap in infra). Die Sitzungen landen in ~/.config/platform-mcp/ mit Rechten 0600 und sind für alle Editoren gemeinsam: Wer sich einmal angemeldet hat, ist überall angemeldet.

Über SSH oder in einem Devcontainer ohne Browser:

platform-mcp login --no-browser

Den Link aus der Ausgabe müssen Sie auf Ihrem eigenen Rechner öffnen; der Port 8085 (Argo CD), 8250 (Vault) oder 8280 (Keycloak) muss dabei auf den Host weitergeleitet sein, auf dem der Befehl läuft.

Anmeldung als Vault-Administrator

Die normale Anmeldung geht an den Mount-Punkt oidc, wo die Policy über die Untergruppenmitgliedschaft vergeben wird. Vollständige Rechte auf den Speicher liegen in einem separaten Mount oidc-admin und stehen nur Owner der Gruppe infra/k8s zu — warum das so ist, ist in platform/vault-config/40-groups.yaml beschrieben:

VAULT_OIDC_MOUNT=oidc-admin platform-mcp login vault

Konfiguration

Etwas zu ändern ist nicht nötig — die Adressen sind bereits im Plugin hinterlegt.

Cursor. Plugins → Configure für platform-mcp: URLs von Argo CD, Vault und Keycloak, PLATFORM_MCP_INSECURE und der Vault-OIDC-Mount (oidc — normale Anmeldung, oidc-admin — volle Rechte für Owner von infra/k8s). Die Defaults entsprechen dem Cluster sonar-prod.

Claude Code und manuelle Konfiguration. Falls etwas anderes benötigt wird (eigene Instanz, oidc-admin, eigene Verbote), überschreiben Sie die Werte über Umgebungsvariablen in der Editor-Konfiguration oder legen Sie sie in ~/.config/platform-mcp/config.json ab:

{
  "argocdUrl": "https://argocd.infra.sonar-corp.ru",
  "vaultUrl": "https://vault.infra.sonar-corp.ru",
  "keycloakUrl": "https://auth.infra.sonar-corp.ru",
  "vaultOidcMount": "oidc",
  "policy": {
    "requireConfirmation": true,
    "denyVaultPaths": ["kv/infra/"]
  }
}

Es genügt, die Adresse mindestens eines Dienstes zu setzen — die übrigen erscheinen dann einfach nicht in der Werkzeugliste.

Wenn keine Sitzung vorhanden oder sie abgelaufen ist, geben die Werkzeuge eine verständliche Fehlermeldung zurück, und der Agent kann argocd_login / vault_login / keycloak_login direkt aus dem Dialog aufrufen — ein Neustart des Editors ist nicht nötig. Diese Werkzeuge öffnen einen Browser und geben den Link sofort zurück, ohne auf den Abschluss der Anmeldung zu warten: Ein Mensch braucht für SSO Minuten, während das Request-Timeout bei MCP-Clients meist 60 Sekunden beträgt. Das Ergebnis wird mit einem separaten Aufruf *_auth_status geprüft.

Befehle

platform-mcp                    # MCP-сервер поверх stdio (так его запускает редактор)
platform-mcp login [сервис]     # интерактивный вход, --no-browser для headless
platform-mcp status [сервис]    # кто вошёл и до какого момента действует токен
platform-mcp logout [сервис]    # удалить сохранённую сессию

Der Dienst ist argocd, vault oder keycloak; ohne ihn gilt der Befehl für alle konfigurierten.

Werkzeuge

Pro Dienst: <dienst>_exec, <dienst>_login, <dienst>_auth_status, <dienst>_logout.

argocd_exec, vault_exec und keycloak_exec nehmen args entgegen — ein Array von Kommandozeilenargumenten:

argocd_exec { "args": ["app", "list", "-o", "json"] }
argocd_exec { "args": ["app", "sync", "team-a-api"] }
vault_auth_status   # сначала: username, role, policies
vault_exec  { "args": ["token", "lookup"] }
vault_exec  { "args": ["kv", "list", "kv/teams"] }
vault_exec  { "args": ["kv", "get", "kv/teams/team-a/postgres"] }
keycloak_exec { "args": ["get", "realms"] }
keycloak_exec { "args": ["get", "users", "-r", "sonar-prod", "-q", "username=alice"] }

Beginnen Sie bei Vault mit vault_auth_status: An den policies ist sofort zu erkennen, ob Zugriff auf KV besteht. ["token","lookup"] ist der CLI-Kanon (nicht lookup-self). sys/mounts liefert bei normalen OIDC-Benutzern oft 403 — nicht für Discovery verwenden. Exit-Code 2 bei kv list bedeutet meist „leer oder kein list-ACL“, nicht „anderen Mount versuchen“.

Argumente werden immer als Array übergeben und nie zu einem String zusammengefügt: Die Shell ist nicht beteiligt, daher bleiben ; und $(...) in Argumenten gewöhnlicher Text.

Adresse und Token setzt der Server ein. Flags, die sie überschreiben (--server, --auth-token, --config, --core bei Argo CD; -address, -tls-skip-verify bei Vault; --server, --config, --no-config bei Keycloak), sind verboten — sonst könnte das arbeitende Token aus der Umgebung des Kindprozesses an einen fremden Host geschickt werden.

Bestätigung gefährlicher Operationen

Lesende Befehle werden sofort ausgeführt. Für Argo CD und Vault erfordert alles andere eine Benutzerbestätigung.

Als mutierend gilt jeder Befehl, der nicht als lesend erkannt wird: Die Verb-Liste ist zur sicheren Seite hin abgeschlossen, daher fällt ein unbekannter Befehl unter die Bestätigung und rutscht nicht daran vorbei.

Wenn der Client MCP-Elicitation unterstützt, erscheint ein normaler Dialog. Wenn nicht, greift ein Ersatzschema: Der erste Aufruf liefert eine Beschreibung der Folgen und ein Einmal-Token, der zweite Aufruf mit diesem Token führt die Operation aus. Das Token lebt 5 Minuten und ist an die konkreten Argumente gebunden, daher funktioniert „eins bestätigt, anderes ausgeführt“ nicht, und der Agent kann es sich nicht selbst ausdenken.

Keycloak ist eine Ausnahme: Mutationen werden sofort ausgeführt, aber der Antwort an den Agenten wird eine Warnung hinzugefügt — die Konfiguration läuft über CR/Operator, manuelle Änderungen über kcadm kann der Operator beim Sync überschreiben. Bevorzugt sind Manifests in Git.

Gänzlich verboten sind:

• An- und Abmeldung (argocd login, vault login, kcadm config …) — die Sitzung verwaltet der Server selbst;

• Befehle, die nicht terminieren: vault server|agent|proxy|monitor, argocd app logs --follow;

• argocd admin — Verwaltung von Argo CD selbst;

• vault operator seal|step-down|init|rekey|generate-root|migrate — der Ausfall eines einzigen davon legt den gesamten Speicher lahm;

• Änderung von Infrastruktur-Anwendungen von Argo CD (argocd, vault, keycloak, cert-manager, ingress-nginx, …): Sie kommen aus Git über Merge Request, nicht aus einem Dialog mit dem Agenten. Lesen ist erlaubt.

Die Listen werden in config.json konfiguriert (policy.denyApplications, policy.denyVaultPaths).

Das ist ein Schutz vor Agentenfehlern, keine Sicherheitsgrenze. Ein Mitglied der Gruppe infra/k8s ist ohnehin Argo-CD-Administrator (g, infra/k8s, role:admin) und kann dasselbe über die UI tun. Rechte wirklich einschränken kann man nur durch Rollentrennung in argocd-rbac-cm und Vault-Policies.

Geheimnisse gelangen nicht in den Modellkontext

Werte von Geheimnissen werden aus Antworten herausgeschnitten, Schlüsselnamen und Metadaten bleiben erhalten:

• Vault — Werte aus kv get, read auf KV-Pfaden und unwrap. Antworten von kv list, kv metadata get, policy read, sys/mounts werden nicht angefasst: Dort gibt es keine Geheimnisse, und das Herausschneiden würde sie unbrauchbar machen.

• Argo CD — data und stringData bei Secret-Ressourcen, auch innerhalb der Felder manifest, liveState, targetState, wo Argo CD Manifests als Strings mit JSON darin liefert. base64 ist keine Verschlüsselung.

Umgehungen sind geschlossen: vault kv get -field=password druckt den nackten Wert an JSON vorbei, und -format=table bietet nichts zum Herausschneiden — beides wird mit einer Erklärung abgelehnt.

Wenn Werte im Dialog wirklich benötigt werden:

export PLATFORM_MCP_ALLOW_SECRET_VALUES=true

Bewusstes Opt-in: Danach wandern die Inhalte der Geheimnisse zum Modellanbieter. Standardmäßig sehen Sie Geheimnisse direkt in Vault ein.

Zusätzlich: Antworten länger als 100 KB werden mit einem Hinweis gekürzt, wie die Anfrage einzugrenzen ist, und die Ausgabe wird als Daten aus dem Cluster markiert — Manifests, Annotationen und Logs schreiben Menschen, und darin vorgefundene Anweisungen darf der Agent nicht ausführen.

Woher argocd, vault und kcadm kommen

Der Server arbeitet nicht über einen selbst geschriebenen REST-Client, sondern über die offiziellen CLIs: Argo CD hat gar keinen Node-Client, bei Vault ist der offizielle eine Go-Bibliothek und dasselbe Binary, bei der Keycloak-Admin-API ist es kcadm aus der Distribution. Die Vollständigkeit der Möglichkeiten entspricht dabei der des CLI.

Sie müssen nicht manuell installiert werden:

1. Wenn argocd / vault / kcadm (kcadm.sh) bereits im PATH liegt, wird es verwendet, nichts wird heruntergeladen.

2. Andernfalls wird beim ersten Zugriff eine festgelegte Version von den offiziellen Releases (github.com/argoproj/argo-cd, releases.hashicorp.com, github.com/keycloak/keycloak) für die aktuelle Plattform heruntergeladen. Für Keycloak — das gesamte Zip-Distribut (~170 MB): kcadm ist ein Java-Skript, kein separates Go-Binary.

3. Die Prüfsumme wird vor dem Entpacken und vor chmod +x verifiziert. Ohne diesen Schritt liefe alles auf „aus dem Internet laden und ausführen“ hinaus.

4. Die Datei wird in ~/.config/platform-mcp/bin/ abgelegt und danach wiederverwendet.

Für kcadm wird auf dem Rechner Java 17+ benötigt (java im PATH oder JAVA_HOME). Ohne sie gibt der Server eine verständliche Fehlermeldung zurück.

Der Download erfolgt bei der ersten Verwendung, nicht in postinstall: postinstall-Skripte werden vielerorts deaktiviert (npm ci --ignore-scripts), und die Installation bliebe still unvollständig.

Die Versionen sind in src/config.ts festgelegt und entsprechen den im Cluster ausgerollten (Argo CD v3.4.5, Vault 2.0.3, Keycloak 26.6.4). Bei einem Cluster-Update müssen sie auch hier angehoben werden.

TLS

argocd.infra.sonar-corp.ru, vault.infra.sonar-corp.ru und auth.infra.sonar-corp.ru haben derzeit keine echten Zertifikate: Im Ingress ist kein Secret mit Zertifikat angegeben, daher liefert ingress-nginx sein Standard-Selbstsigniertes aus (CN=Kubernetes Ingress Controller Fake Certificate, SAN ingress.local).

Solange das so ist, ist ein explizites Opt-in erforderlich:

export PLATFORM_MCP_INSECURE=true

Er deaktiviert die Zertifikatsprüfung für Node (OIDC-Login) und gibt bei jedem Start eine Warnung aus. Die Verbindung bleibt verschlüsselt, aber die Authentizität des Servers wird nicht bestätigt, und über diesen Kanal laufen Zugriffstokens. Bei kcadm ist bei fehlendem Truststore in der Konfiguration die Skip-Certificate-Validation aktiviert (Warnung in stderr der CLI).

NODE_EXTRA_CA_CERTS hilft hier nicht: Das SAN des Zertifikats (ingress.local) stimmt nicht mit dem Hostnamen überein, daher schlägt die Namensprüfung selbst mit vertrauenswürdiger Root-CA fehl.

Nach der Ausstellung normaler Zertifikate muss die Option entfernt werden. Wenn sie von einer internen CA signiert sind, reicht es, die Root anzugeben – die Variablen werden an untergeordnete CLIs vererbt:

export NODE_EXTRA_CA_CERTS=/path/to/internal-ca.pem   # для самого сервера (Node)
export SSL_CERT_FILE=/path/to/internal-ca.pem         # для argocd и vault (Go)

Wie das funktioniert

редактор ──stdio──▶ platform-mcp ──argv+env──▶ argocd ──▶ Argo CD
                    (OIDC, политика,  vault  ──▶ Vault
                     вырезание секретов) kcadm ──▶ Keycloak

Argo CD. Login – Authorization Code + PKCE über Dex. Verwendet wird der Public-Client argo-cd-cli, den Argo CD automatisch in Dex registriert, zusammen mit der Redirect-URI http://localhost:8085/auth/callback, daher muss argocd-cm für die Installation nicht geändert werden. Argo CD akzeptiert als Bearer genau das id_token, nicht das access_token – letzteres ist bei Dex undurchsichtig und wird vom API-Server nicht geprüft. Das Token wird über das Refresh-Token erneuert.

Die CLI wird mit --grpc-web gestartet: ingress-nginx proxyt in argocd-server normales HTTP/1.1 (configs.params.server.insecure: true), und reines gRPC erreicht ihn nicht.

Vault. Der Ablauf ist einfacher: PKCE ist nicht nötig, weil der Code gegen das Token von Vault selbst getauscht wird – das Secret der OAuth-Anwendung liegt in Vault. Vom Client wird verlangt, einen Listener auf http://localhost:8250/oidc/callback zu starten (dieser ist vorab in allowedRedirectURIs eingetragen) und code, state und client_nonce zurückzugeben. Den Parameter state generiert Vault selbst und legt ihn in den ausgegebenen Link – von dort wird er für die Prüfung des Redirects genommen. Das Token wird über auth/token/renew-self verlängert, solange renewable.

Keycloak. Authorization Code + PKCE über den Public-Client platform-mcp-cli im Realm master (wird einmalig im Bootstrap angelegt, Redirect http://localhost:8280/oidc/callback). Login – FreeIPA. In die Session wird das access_token gelegt (Admin-API). Vor kcadm schreibt der Server eine private kcadm.config nach ~/.config/platform-mcp/ – nicht die gemeinsame ~/.keycloak/kcadm.config.

Tokens werden an untergeordnete Prozesse nur über die Umgebung (Argo/Vault) oder über eine private Config-Datei (Keycloak) übergeben: In argv wären sie in ps für jeden Prozess des Benutzers sichtbar. Die Umgebung wird nicht vollständig vererbt – die CLI bekommt genau das, was sie braucht, ohne Geheimnisse benachbarter Dienste.

Sessions werden in eigenen Dateien gespeichert, nicht in ~/.config/argocd/config, ~/.vault-token und ~/.keycloak/kcadm.config: Der Provider rotiert das Token bei der Aktualisierung, und eine gemeinsame Datei würde dazu führen, dass normale CLIs im Terminal und dieser Server sich gegenseitig die Sessions invalidieren würden.

Entwicklung

npm install
npm run build
npm test

Die Tests decken die Klassifizierung von Befehlen und Verbote, das Herausschneiden von Secrets, Einmal-Bestätigungstokens, das Fehlen einer Shell beim Start der CLI und einen eigenen ZIP-Entpacker ab (dieser ist nötig, weil HashiCorp vault als Archiv ausliefert und es in Node keinen eingebauten Entpacker gibt).

Plugin

Das Repository ist gleichzeitig Plugin-Verzeichnis und Plugin selbst:

.claude-plugin/marketplace.json      каталог для Claude Code
.cursor-plugin/marketplace.json      каталог для Cursor
plugins/platform-mcp/
  .claude-plugin/plugin.json         манифест для Claude Code
  .cursor-plugin/plugin.json         манифест для Cursor
  .mcp.json                          сервер для Claude Code — ПЛОСКАЯ карта
  mcp.json                           тот же сервер для Cursor — с обёрткой mcpServers

Die Serverbeschreibung ist in zwei Formen dupliziert, und das ist keine Nachlässigkeit. Claude Code liest .mcp.json als flache Karte „Name → Server“: Mit dem Wrapper mcpServers übernimmt er den Server stillschweigend nicht – das Plugin wird installiert und gilt als aktiviert, aber es erscheinen keine Tools. Cursor hingegen nimmt die Datei über den Pfad aus mcpServers in seinem plugin.json, und funktionierende Plugins für Cursor verwenden die Form mit Wrapper. command/args und die env-Schlüssel stimmen überein; die env-Werte bei Cursor sind Platzhalter ${VAR} (Schema variables in plugin.json, Configure in der UI), bei Claude – literale Defaults. npm run check:manifests sorgt dafür, dass die Formen nicht auseinanderlaufen.

Der Servercode wird nicht ins Plugin kopiert: Beide Dateien starten das veröffentlichte Paket über npx, daher bleibt das Plugin aus wenigen kleinen Dateien bestehen und benötigt bei Serveränderungen keinen Neubau.

Änderungen kann man vor dem Push prüfen, indem man das Verzeichnis über einen lokalen Pfad anbindet:

/plugin marketplace add /путь/к/platform-mcp
/plugin install platform-mcp

Veröffentlichung

CI (.gitlab-ci.yml) veröffentlicht das Paket automatisch im GitLab-npm-Registry dieses Projekts über ein Tag der Form vX.Y.Z, die Authentifizierung erfolgt über das eingebaute CI_JOB_TOKEN, persönliche Tokens sind in CI nicht erforderlich.

Die Version ist in den Plugin-Manifesten dupliziert und muss dort ebenfalls angehoben werden:

npm version <major|minor|patch> --no-git-tag-version   # только package.json
# поправить version в обоих plugins/platform-mcp/*/plugin.json
npm run check:manifests                                # сверить
git commit -am "0.X.Y" && git tag v0.X.Y && git push --follow-tags

Abweichungen fängt CI ab: Der Job test gleicht die Versionen in den drei Manifesten und die Konsistenz der beiden Serverbeschreibungen ab, publish – die Version aus dem Tag mit package.json. Ohne das bliebe das Plugin beim Benutzer „unverändert“ bei frischem Server: Sowohl Claude Code als auch Cursor entscheiden anhand der version des Plugins, ob sie es aktualisieren.

Das Plugin muss nirgendwo separat veröffentlicht werden: Ein Push in main geht per Spiegel der geschützten Branches auf GitHub, und Benutzer übernehmen Änderungen über /plugin marketplace update. Beachten Sie, dass das Plugin aus dem Branch und nicht aus dem Tag installiert wird: Sobald eine Änderung in main gelandet ist, ist sie für alle verfügbar – selbst wenn die Version noch nicht per Tag veröffentlicht wurde.