Harness

officiel

Accédez aux données de la plateforme Harness et interagissez avec elles, y compris les pipelines, les dépôts, les journaux et les registres d'artefacts.

Que pouvez-vous faire avec Harness MCP ?

  • Parcourir les ressources Harness — Demandez à votre assistant de répertorier les pipelines, services, environnements, organisations, projets, indicateurs de fonctionnalité ou données de coûts via harness_list.
  • Inspecter une ressource spécifique — Récupérez les détails de n’importe lequel des 274 types de ressources Harness avec harness_get.
  • Créer des ressources — Demandez à votre assistant de créer des ressources Harness via harness_create.
  • Travailler sur plusieurs projets — Découvrez dynamiquement les organisations et les projets, puis lancez des requêtes couvrant plusieurs projets, comme la recherche des exécutions ayant échoué dans tous les projets.
  • Utiliser des invites de workflow prédéfinies — Déclenchez 35 modèles d’invites pour des tâches telles que le débogage de pipelines ayant échoué, l’examen des métriques DORA ou le triage des vulnérabilités.

Documentation

Serveur MCP Harness 2.0

MCP Toplist

Un serveur MCP (Model Context Protocol) qui donne aux agents d’IA un accès complet à la plateforme Harness.io grâce à 11 outils consolidés et 274 types de ressources.

Pourquoi utiliser ce serveur MCP

La plupart des serveurs MCP associent un outil à chaque point de terminaison d’API. Pour une plateforme aussi vaste que Harness, cela représente plus de 240 outils — et les LLM sélectionnent moins bien les outils à mesure que leur nombre augmente. Les fenêtres de contexte se remplissent de schémas, et chaque nouveau point de terminaison nécessite du nouveau code.

Ce serveur fonctionne autrement :

  • 11 outils, 274 types de ressources. Un système de répartition fondé sur un registre achemine harness_list, harness_get, harness_create, etc. vers n’importe quelle ressource Harness — pipelines, services, environnements, organisations, projets, indicateurs de fonctionnalité, données de coûts, et bien plus. Le LLM choisit parmi 11 outils plutôt que des centaines.
  • Couverture complète de la plateforme. 44 ensembles d’outils par défaut couvrant CI/CD, GitOps, Feature Flags, Cloud Cost Management, Security Testing, Chaos Engineering, Database DevOps, Internal Developer Portal, Software Supply Chain, Infrastructure as Code Management, Release Management, Governance, Service Overrides, Knowledge Graph, et bien plus. La couverture Ansible et l’évaluation de l’observabilité sont disponibles en option, au besoin.
  • Flux de travail multi-projets prêts à l’emploi. Les agents découvrent dynamiquement les organisations et les projets — aucune variable d’environnement codée en dur n’est nécessaire. Demandez « affiche les exécutions en échec dans tous les projets » et l’agent peut parcourir toute la hiérarchie du compte.
  • 35 modèles d’invite. Des invites prédéfinies pour les flux de travail courants : créer et déployer des applications de bout en bout, déboguer les pipelines en échec, examiner les métriques DORA, trier les vulnérabilités, optimiser les coûts cloud, auditer le contrôle d’accès, planifier les déploiements d’indicateurs de fonctionnalité, examiner les demandes de tirage, approuver les pipelines en attente, et bien plus.
  • Fonctionne partout. Transport stdio pour les clients locaux (Claude Desktop, Cursor, Devin Desktop), transport HTTP pour les déploiements distants ou partagés, compatible avec Docker et Kubernetes.
  • Démarrage sans configuration. Il suffit de fournir une clé API Harness. L’ID du compte est extrait automatiquement des jetons PAT et SAT, les valeurs par défaut de l’organisation et du projet sont facultatives, et le filtrage des ensembles d’outils permet de n’exposer que ce dont vous avez besoin.
  • Extensible par conception. Pour ajouter une ressource Harness, il suffit d’ajouter un fichier de données déclaratif — aucun nouvel enregistrement d’outil, aucune modification de schéma ni mise à jour d’invite.

Prérequis

Avant d’installer ou de lancer le serveur, vous avez besoin d’une clé API Harness :

  1. Connectez-vous à votre compte Harness
  2. Accédez à Mon profil → Clés API → + Nouvelle clé API
  3. Créez un nouveau jeton sous la clé API — cela génère un PAT ou un SAT au format <prefix>.<accountId>.<tokenId>.<secret>
  4. Enregistrez le jeton dans un endroit sûr — vous en aurez besoin à l’étape suivante

Pour obtenir des instructions détaillées, consultez le Guide de démarrage rapide de l’API Harness.

Démarrage rapide

Option 0 : MCP Harness hébergé

Si le service MCP hébergé est activé pour votre compte Harness, les clients compatibles avec les serveurs MCP distants peuvent se connecter directement au point de terminaison géré au lieu d’exécuter le serveur localement.

Important : Le service MCP hébergé utilise Harness Platform OAuth, et non HARNESS_API_KEY. Il doit également être activé/configuré pour chaque compte par l’assistance Harness avant de pouvoir utiliser le point de terminaison.

Consultez MCP Harness hébergé pour des exemples de configuration.

Option 1 : npx (recommandée)

Aucune installation requise — lancez simplement la commande :

HARNESS_API_KEY=pat.xxx.xxx.xxx npx harness-mcp-v2@latest

Vous pouvez aussi configurer la clé API dans votre client d’IA (voir Configuration du client ci-dessous).

# Stdio transport (default — for Claude Desktop, Cursor, Devin Desktop, etc.)
HARNESS_API_KEY=pat.xxx npx harness-mcp-v2

# HTTP transport (for remote/shared deployments)
HARNESS_API_KEY=pat.xxx npx harness-mcp-v2 http --port 8080

Remarque : L’ID du compte est extrait automatiquement des jetons PAT et SAT (pat.<accountId>... ou sat.<accountId>...). HARNESS_ACCOUNT_ID n’est donc nécessaire que pour les clés API qui ne contiennent pas de segment de compte.

Option 2 : Installation globale

npm install -g harness-mcp-v2

# Then run directly
harness-mcp-v2

Option 3 : Compiler à partir des sources

Pour le développement ou la personnalisation :

git clone https://github.com/harness/mcp-server.git
cd mcp-server
pnpm install
pnpm build

# Run
pnpm start              # Stdio transport
pnpm start:http         # HTTP transport
pnpm inspect            # Test with MCP Inspector

Bundle de l’annuaire MCP d’Anthropic

Le manifeste du bundle MCPB se trouve dans [mcp-directory/](mcp-directory/), et l’icône du bundle de 512×512 est suivie dans [icon.png](icon.png) à la racine du dépôt. L’archive empaquetée contient à la racine manifest.json, icon.png, server/, package.json, npm-shrinkwrap.json, ainsi que node_modules/ de production.

Pour réduire la taille de l’archive, créez les packages MCPB à partir d’un répertoire de préparation :

pnpm prepare:mcpb

Le répertoire de préparation est créé dans dist/mcpb/, avec les dépendances de production installées depuis npm-shrinkwrap.json selon la disposition à plat de npm. L’interface de ligne de commande MCPB officielle, dont la version est épinglée, le valide et crée dist/harness-mcp-server-<version>.mcpb.

Les balises de version correspondant à v*.*.* publient automatiquement ce bundle dans la version GitHub correspondante. Pour ajouter ce bundle à une version existante sans republier sur npm, lancez manuellement le workflow Release avec son entrée release_tag (par exemple, v3.2.20). Le workflow récupère et compile cette balise exacte avant de remplacer uniquement son artefact MCPB versionné.

Utilisation de l’interface de ligne de commande

harness-mcp-v2 [stdio|http] [--port <number>]

Options:
  --port <number>  Port for HTTP transport (default: 3000, or PORT env var)
  --help           Show help message and exit
  --version        Print version and exit

Par défaut, le transport est stdio si aucun n’est spécifié. Utilisez http pour les déploiements distants ou partagés.

Transport HTTP

En mode HTTP, le serveur expose :

Point de terminaisonMéthodeDescription
/mcpPOSTPoint de terminaison MCP JSON-RPC (initialisation + requêtes de session)
/mcpGETFlux SSE pour les messages initiés par le serveur (progression, sollicitation)
/mcpDELETEMettre fin à une session MCP active
/mcpOPTIONSPré-vérification CORS
/healthGETVérification de l’état — renvoie { "status": "ok", "sessions": <count> }
/.well-known/oauth-protected-resourceGETMétadonnées RFC 9728 en modes oauth et oauth-proxy
/.well-known/oauth-protected-resource/mcpGETMétadonnées RFC 9728 tenant compte du chemin pour la ressource /mcp par défaut
/.well-known/oauth-authorization-serverGETMétadonnées RFC 8414 du courtier intégré en mode oauth-proxy
/oauth/authorizeGETDémarrer la connexion du client MCP via le fournisseur en amont et HarnessID
/oauth/upstream/callbackGETRappel du fournisseur d’identité en amont
/oauth/harnessid/callbackGETRappel de connexion HarnessID
/oauth/tokenPOSTRenvoyer ou actualiser les jetons en amont pour le client MCP ; ne renvoie jamais de jetons HarnessID

Le transport HTTP fonctionne en mode basé sur les sessions. Une nouvelle session MCP est créée sur initialize, le serveur renvoie un en-tête mcp-session-id, et les requêtes suivantes pour cette session doivent inclure le même en-tête.

Contraintes opérationnelles en mode HTTP :

  • Définissez HARNESS_MCP_AUTH_TOKEN pour les déploiements mono-utilisateur et multi-utilisateur partagés ou accessibles à distance. Lorsqu’il est défini, chaque requête POST, GET et DELETE vers /mcp doit inclure Authorization: Bearer <token>.
  • Le mode OAuth accepte les jetons d’accès HarnessID au lieu de HARNESS_MCP_AUTH_TOKEN et peut être lié à une adresse autre que loopback sans désactiver l’option de refus d’accès non authentifié.
  • Le mode proxy OAuth accepte un jeton d’un fournisseur d’identité en amont, l’échange en interne contre un jeton HarnessID par utilisateur et exige le jeton en amont pour chaque requête.
  • Par défaut, les liaisons mono-utilisateur et multi-utilisateur autres que loopback nécessitent HARNESS_MCP_AUTH_TOKEN. Pour exécuter le serveur sans authentification sur une interface autre que loopback, définissez explicitement HARNESS_MCP_ALLOW_UNAUTHENTICATED_HTTP=true.
  • POST /mcp sans mcp-session-id doit être une requête initialize.
  • POST /mcp, GET /mcp et DELETE /mcp pour les sessions existantes nécessitent l’en-tête mcp-session-id.
  • GET /mcp est utilisé pour les notifications SSE (mises à jour de progression et invites de sollicitation).
  • Les sessions inactives sont supprimées après MCP_SESSION_TTL_MS millisecondes lorsqu’aucune requête ni aucun flux SSE n’est actif (valeur par défaut 1800000, soit 30 minutes).
  • GET /health est le seul point de terminaison non-MCP.
  • La taille du corps des requêtes est limitée par HARNESS_MAX_BODY_SIZE_MB (valeur par défaut : 10 Mo).
  • Définissez x-harness-pipeline-version: 0 ou 1 sur la requête initialize pour sélectionner les ressources de pipeline V0 ou V1 pour cette session HTTP.
  • Définissez x-harness-auto-approve-risk: none|low_write|medium_write|high_write|all sur la requête initialize pour choisir un seuil d’approbation automatique plus strict par session. Le serveur plafonne cette valeur au niveau HARNESS_AUTO_APPROVE_RISK du déploiement ; une session peut donc réduire le plafond d’approbation configuré, mais pas l’augmenter.

Mode OAuth HarnessID

Définissez HARNESS_MCP_MODE=oauth pour permettre aux clients MCP distants de découvrir HarnessID et de terminer le flux OAuth 2.1 Authorization Code avec PKCE. Le mode OAuth est disponible uniquement avec le transport HTTP. Les valeurs par défaut de production pour HarnessID, la ressource MCP et le routage de l’API sont intégrées :

HARNESS_MCP_MODE=oauth

Par défaut, l’émetteur est https://id.harness.io/idp/realms/HarnessIDP, la ressource https://mcp.harness.io/mcp, le client OAuth mcp-client et l’URL de base de l’API Harness https://mcp.harness.io/cli. Ne les remplacez que pour l’assurance qualité, le développement local ou un autre environnement Harness.

HARNESS_API_KEY ne doit pas être défini dans ce mode. HARNESS_MCP_OAUTH_JWKS_URI prend par défaut la valeur <issuer>/protocol/openid-connect/certs, et HARNESS_ACCOUNT_ID n’est pas nécessaire, car le compte provient du jeton. Si l’ensemble d’outils facultatif appsec (HARNESS_TOOLSETS=+appsec) est activé, les sessions doivent également transmettre x-harness-appsec-api-key dans la requête initialize (les jetons OAuth HarnessID ne sont jamais transmis à api.traceable.ai).

Le serveur publie les métadonnées de ressource protégée RFC 9728 et renvoie ce défi lorsqu’un client n’est pas authentifié :

HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer resource_metadata="https://mcp.harness.io/.well-known/oauth-protected-resource/mcp"

Il valide la signature RS256 du jeton d’accès HarnessID, iss, son expiration et sub à l’aide du point de terminaison JWKS configuré, et vérifie que le jeton a été émis pour HARNESS_MCP_OAUTH_CLIENT_ID au moyen de la revendication azp. HARNESS_MCP_OAUTH_RESOURCE est l’identifiant de ressource protégée RFC 9728 utilisé pour la découverte et les défis. Les jetons d’accès HarnessID actuels utilisent aud: account plutôt que l’URL MCP ; la ressource n’est donc pas comparée à aud.

L’ID du compte provient de la revendication HARNESS_MCP_OAUTH_ACCOUNT_CLAIM du jeton (account_id par défaut), renseignée par la portée HarnessID organization. Chaque session stocke le jeton d’accès de l’appelant et le transmet à l’API Harness sous la forme Authorization: Bearer, afin que les règles RBAC et les journaux d’audit Harness reflètent l’utilisateur connecté plutôt qu’un PAT partagé. La session est liée au sub et au compte avec lesquels elle a été créée : une requête ultérieure peut contenir un jeton actualisé, mais un jeton associé à un autre utilisateur ou compte est rejeté.

En général, les clients n’ont besoin que de l’URL de la ressource MCP :

{
  "mcpServers": {
    "harness": {
      "url": "https://mcp.harness.io/mcp"
    }
  }
}

Le client lit les métadonnées de ressource protégée, découvre HARNESS_MCP_OAUTH_ISSUER, puis utilise les métadonnées RFC 8414 de ce serveur d’autorisation. Si le client ne prend pas en charge l’enregistrement dynamique des clients, utilisez l’ID client préenregistré mcp-client.

Consultez OAuth HarnessID pour un serveur MCP auto-hébergé pour la liste de vérification Keycloak QA et les commandes de validation.

Mode proxy OAuth avec fournisseur d’identité en amont

Le mode proxy OAuth nécessite un client HarnessID confidentiel. L’équipe Harness ID crée ce client et fournit l’ID client ainsi que le secret client. Contactez l’équipe Harness ID avant d’activer ce mode.

Définissez HARNESS_MCP_MODE=oauth-proxy lorsqu’un client MCP ne doit détenir qu’un jeton d’un fournisseur d’identité en amont. Le nom du client public peut être quelconque. Définissez HARNESS_MCP_BROKER_CLIENT_ID sur le même nom que celui utilisé par le client MCP. Le courtier OAuth intégré lance la connexion au fournisseur en amont, termine la connexion HarnessID dans le même flux et ne renvoie au client MCP que les jetons d’accès et d’actualisation en amont. À chaque requête /mcp, le serveur valide le jeton en amont et utilise un jeton d’accès HarnessID par utilisateur mis en cache, qu’il renouvelle avec le jeton d’actualisation avant son expiration. Si aucune correspondance entre le fournisseur en amont et HarnessID n’est trouvée, le serveur renvoie 401 afin que le client se reconnecte. Les jetons HarnessID restent sur le serveur. Les jetons d’actualisation, les jetons d’accès mis en cache et l’état OAuth temporaire sont chiffrés au repos. Ce mode est réservé au transport HTTP. Il nécessite également l’émetteur et l’audience en amont, ainsi qu’une clé de coffre stable de 32 octets. Consultez Mode proxy OAuth du fournisseur d’identité en amont pour la configuration et les commandes de test MCP de bout en bout.

Mode multi-utilisateur

Définissez HARNESS_MCP_MODE=multi-user pour les déploiements HTTP partagés où chaque client s’authentifie en tant qu’utilisateur Harness différent. Dans ce mode :

  • HARNESS_API_KEY ne doit pas être défini dans la configuration du serveur — le serveur ne détient aucun identifiant Harness.
  • Chaque session doit fournir x-harness-api-key dans la requête initialize. x-harness-account-id est requis uniquement lorsque la clé API n’intègre pas de segment de compte.
  • Les sessions peuvent également fournir les en-têtes x-harness-org et x-harness-project pour définir la portée par défaut de la session.
  • Si l’ensemble d’outils facultatif appsec (HARNESS_TOOLSETS=+appsec) est activé, les sessions qui appellent des ressources appsec_* doivent également fournir x-harness-appsec-api-key dans la requête initialize (x-harness-api-key de la session n’est jamais transmis à api.traceable.ai).
  • La clé API Harness est transmise à chaque appel d’API Harness effectué pour cette session ; la piste d’audit dans Harness reflète donc l’utilisateur réel.
  • HARNESS_MCP_AUTH_TOKEN est indépendant et peut toujours être utilisé comme contrôle supplémentaire au niveau du transport.
# Health check
curl http://localhost:3000/health

# MCP initialize request (capture mcp-session-id response header)
# In multi-user mode, x-harness-api-key is required on initialize.
# x-harness-account-id is needed only for API keys without an embedded account segment.
curl -i -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer $HARNESS_MCP_AUTH_TOKEN" \
  -H "x-harness-api-key: $HARNESS_API_KEY" \
  -H "x-harness-account-id: $HARNESS_ACCOUNT_ID" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

# Subsequent MCP request (use returned session ID)
curl -X POST http://localhost:3000/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer $HARNESS_MCP_AUTH_TOKEN" \
  -H "mcp-session-id: <session-id>" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'

# Terminate session
curl -X DELETE http://localhost:3000/mcp \
  -H "Authorization: Bearer $HARNESS_MCP_AUTH_TOKEN" \
  -H "mcp-session-id: <session-id>"

HARNESS_MCP_ALLOWED_HOSTS contrôle la validation de l’en-tête Host pour la protection contre le rebinding DNS, et CORS limite les origines du navigateur. Aucun des deux ne constitue une authentification ; utilisez HARNESS_MCP_AUTH_TOKEN ou une passerelle/un proxy inverse authentifié pour contrôler l’accès.

Configuration du client

Remarque : HARNESS_ORG et HARNESS_PROJECT sont facultatifs. Ils définissent l’ID d’organisation et l’ID de projet utilisés lorsqu’ils ne sont pas spécifiés pour chaque appel d’outil. Les agents peuvent découvrir dynamiquement les organisations et les projets à l’aide de harness_list(resource_type="organization") et harness_list(resource_type="project"). Les noms obsolètes HARNESS_DEFAULT_ORG_ID et HARNESS_DEFAULT_PROJECT_ID sont toujours acceptés pour assurer la rétrocompatibilité.

Harness MCP hébergé

Harness prend également en charge un point de terminaison MCP hébergé pour les comptes dont le service géré est activé. Cette option est utile si vous souhaitez utiliser un point de terminaison MCP distant partagé plutôt que d’exécuter npx harness-mcp-v2 ou d’héberger vous-même le transport HTTP.

Important : l’authentification MCP hébergée utilise OAuth de la plateforme Harness. Elle n’utilise pas HARNESS_API_KEY dans la configuration du client. La disponibilité de MCP hébergé est configurée pour chaque compte Harness ; vous devrez donc contacter l’assistance Harness pour activer/configurer ce paramètre avant de l’utiliser.

Le point de terminaison hébergé https://mcp.harness.io/mcp est un service géré. La configuration MCP côté client dans Claude, Cursor ou Cowork ne peut pas remplacer l’environnement Harness vers lequel il achemine les requêtes. Pour Harness0 ou un autre environnement SaaS Harness privé, demandez à l’assistance Harness d’activer/configurer MCP hébergé pour cet environnement, ou exécutez le serveur local/auto-hébergé et définissez HARNESS_BASE_URL sur l’hôte Harness cible.

Exemple de MCP hébergé :

{
  "mcpServers": {
    "harness-prod1-mcp": {
      "url": "https://mcp.harness.io/mcp",
      "auth": {
        "CLIENT_ID": "mcp-client"
      }
    }
  }
}

Exemple avec des entrées hébergées et locales :

{
  "mcpServers": {
    "harness-hosted": {
      "url": "https://mcp.harness.io/mcp",
      "auth": {
        "CLIENT_ID": "mcp-client"
      }
    },
    "harness-local": {
      "command": "/absolute/path/to/npx",
      "args": ["-y", "harness-mcp-v2@latest"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/directory/containing/node:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

Dépannage de npx ENOENT ou node: No such file or directory

Il s’agit d’un échec de lancement du processus client, et non d’un échec d’authentification Harness. Le serveur MCP n’a pas encore démarré ; modifier HARNESS_API_KEY n’aura donc aucun effet sur spawn npx ENOENT.

Les applications graphiques (Cursor, Claude Desktop, Devin Desktop, VS Code) n’héritent pas toujours du PATH de votre shell ; elles peuvent donc ne pas trouver npx ou node après le rechargement de la configuration. Pour résoudre ce problème, utilisez des chemins absolus et définissez explicitement PATH dans le bloc env :

{
  "mcpServers": {
    "harness": {
      "command": "/absolute/path/to/npx",
      "args": ["-y", "harness-mcp-v2"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

Trouvez vos chemins avec which npx et which node dans un terminal, puis vérifiez que le répertoire contenant node figure dans la valeur PATH ci-dessus. Emplacements courants :

  • Homebrew (macOS) : /opt/homebrew/bin/npx
  • nvm : ~/.nvm/versions/node/v20.x.x/bin/npx (exécutez nvm which current pour trouver le chemin exact)
  • Node système : /usr/local/bin/npx

Claude Desktop (claude_desktop_config.json)

npx (sans installation)

{
  "mcpServers": {
    "harness": {
      "command": "/absolute/path/to/npx",
      "args": ["-y", "harness-mcp-v2@latest"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/directory/containing/node:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

node (installation locale)

npm install -g harness-mcp-v2
{
  "mcpServers": {
    "harness": {
      "command": "/absolute/path/to/harness-mcp-v2",
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/directory/containing/node:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

Claude Code (via claude mcp add)

npx (sans installation)

claude mcp add harness -- npx harness-mcp-v2

node (installation locale)

npm install -g harness-mcp-v2
claude mcp add harness -- harness-mcp-v2

Définissez ensuite HARNESS_API_KEY dans votre environnement ou dans le fichier .env.

Cursor (.cursor/mcp.json)

npx (sans installation, recommandé pour les configurations Cursor locales)

{
  "mcpServers": {
    "harness": {
      "command": "/absolute/path/to/npx",
      "args": ["-y", "harness-mcp-v2@latest"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/directory/containing/node:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

Exécutez which npx dans un terminal et utilisez le chemin complet obtenu pour command ; ajoutez le répertoire indiqué par which node au début de PATH.

node (installation locale)

npm install -g harness-mcp-v2
{
  "mcpServers": {
    "harness": {
      "command": "/absolute/path/to/harness-mcp-v2",
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/directory/containing/node:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

Exécutez which harness-mcp-v2 après npm install -g harness-mcp-v2 et utilisez le chemin complet obtenu pour command ; ajoutez le répertoire indiqué par which node au début de PATH.

Devin Desktop (~/.windsurf/mcp.json)

npx (sans installation)

{
  "mcpServers": {
    "harness": {
      "command": "/absolute/path/to/npx",
      "args": ["-y", "harness-mcp-v2@latest"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/directory/containing/node:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

node (installation locale)

npm install -g harness-mcp-v2
{
  "mcpServers": {
    "harness": {
      "command": "/absolute/path/to/harness-mcp-v2",
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "PATH": "/directory/containing/node:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

Vous utilisez une compilation locale à partir des sources ?

Remplacez la commande par le chemin vers votre index.js compilé :

{
  "command": "node",
  "args": ["/absolute/path/to/harness-mcp-v2/build/index.js", "stdio"]
}

Passerelle MCP

Le serveur MCP Harness est entièrement compatible avec les passerelles MCP — des proxys inverses qui fournissent une authentification centralisée, une gouvernance, un routage des outils et une observabilité pour plusieurs serveurs MCP. Comme le serveur implémente le protocole MCP standard avec les transports stdio et HTTP, il fonctionne derrière toute passerelle compatible MCP sans modification du code.

Pourquoi utiliser une passerelle ?

  • Gestion centralisée des identifiants — aucune clé API dans les configurations des agents
  • Gouvernance et journalisation d’audit pour tous les appels d’outils au sein des équipes
  • Un point de terminaison unique pour les agents au lieu de N connexions à N serveurs MCP
  • Contrôle d’accès — limiter les outils accessibles à chaque équipe

Docker MCP Gateway

Enregistrez le serveur dans la configuration de votre Docker MCP Gateway :

{
  "mcpServers": {
    "harness": {
      "command": "npx",
      "args": ["harness-mcp-v2"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx"
      }
    }
  }
}

Portkey

Ajoutez le serveur MCP Harness à votre Portkey MCP Gateway pour bénéficier d’une gouvernance d’entreprise, du suivi des coûts et du routage multi-LLM :

{
  "mcpServers": {
    "harness": {
      "command": "npx",
      "args": ["harness-mcp-v2"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx"
      }
    }
  }
}

LiteLLM

Ajoutez-le à votre configuration du proxy LiteLLM :

mcp_servers:
  - name: harness
    command: npx
    args:
      - harness-mcp-v2
    env:
      HARNESS_API_KEY: "pat.xxx.xxx.xxx"

Envoy AI Gateway

Le serveur fonctionne avec la prise en charge MCP d’Envoy AI Gateway via le transport HTTP :

# Start the server in HTTP mode
HARNESS_API_KEY=pat.xxx.xxx.xxx npx harness-mcp-v2 http --port 8080

Configurez ensuite Envoy pour acheminer les requêtes vers http://localhost:8080/mcp en tant que backend MCP en amont.

Kong

Utilisez le module d’extension AI MCP Proxy de Kong pour exposer le serveur MCP Harness via votre infrastructure de passerelle Kong existante.

Autres passerelles

Toute passerelle prenant en charge la spécification MCP (Microsoft MCP Gateway, IBM ContextForge, Cloudflare Workers, etc.) peut servir de proxy pour ce serveur. Pour les passerelles basées sur stdio, utilisez le transport par défaut. Pour les passerelles basées sur HTTP, démarrez le serveur avec le transport http et dirigez la passerelle vers le point de terminaison /mcp.

Docker

Compilez et exécutez le serveur dans un conteneur Docker :

# Build the image
pnpm docker:build

# Run with your .env file
pnpm docker:run

# Or run directly with env vars
docker run --rm -p 3000:3000 \
  -e HARNESS_API_KEY=pat.xxx.xxx.xxx \
  -e HARNESS_ACCOUNT_ID=your-account-id \
  harness-mcp-server

Par défaut, le conteneur fonctionne en mode HTTP sur le port 3000 et intègre une vérification d’état.

Kubernetes

Déployez sur un cluster Kubernetes à l’aide des manifestes fournis :

# 1. Edit the Secret with your real credentials
#    k8s/secret.yaml — replace HARNESS_API_KEY and HARNESS_ACCOUNT_ID

# 2. Apply all manifests
kubectl apply -f k8s/

# 3. Verify the deployment
kubectl -n harness-mcp get pods

# 4. Port-forward for local testing
kubectl -n harness-mcp port-forward svc/harness-mcp-server 3000:80
curl http://localhost:3000/health

Le déploiement exécute 2 réplicas avec des sondes de disponibilité et de vivacité, des limites de ressources et un contexte de sécurité non-root. Le Service expose le port 80 en interne (redirigé vers le port 3000 du conteneur).

Configuration

Le serveur charge automatiquement les variables d’environnement depuis un fichier .env à la racine du projet, s’il existe. Copiez .env.example vers .env et renseignez vos valeurs. Les variables d’environnement peuvent également être définies dans votre shell ou dans la configuration du client MCP.

VariableObligatoireValeur par défautDescription
HARNESS_MCP_MODENonsingle-userMode de déploiement : single-user, multi-user, oauth (jeton HarnessID direct) ou oauth-proxy (jeton du fournisseur d’identité en amont échangé contre un jeton HarnessID par utilisateur)
HARNESS_API_KEYOui*--Jeton d’accès personnel Harness ou jeton de compte de service. Obligatoire en mode single-user. Ne doit PAS être défini en mode multi-user, oauth ou oauth-proxy, où chaque session apporte ses propres identifiants
HARNESS_ACCOUNT_IDNon(à partir du PAT/SAT)Identifiant du compte Harness. Extrait automatiquement des jetons PAT/SAT en mode mono-utilisateur ; les sessions multi-utilisateurs peuvent fournir leur propre identifiant via x-harness-account-id lorsque la clé API n’en contient pas
HARNESS_BASE_URLNonhttps://app.harness.io (https://mcp.harness.io/cli en oauth et oauth-proxy)URL de base de l’API/de l’interface utilisateur Harness. oauth et oauth-proxy passent par défaut par le proxy MCP hébergé /cli ; les autres modes utilisent directement l’API SaaS Harness
HARNESS_MCP_OAUTH_ISSUERNonhttps://id.harness.io/idp/realms/HarnessIDPÉmetteur HarnessID comparé exactement à la revendication iss du jeton d’accès
HARNESS_MCP_OAUTH_RESOURCENonhttps://mcp.harness.io/mcpURL MCP canonique publique publiée comme identifiant de ressource RFC 9728
HARNESS_MCP_OAUTH_JWKS_URINon<issuer>/protocol/openid-connect/certsPoint de terminaison JWKS HarnessID utilisé pour valider les signatures des jetons d’accès RS256
HARNESS_MCP_OAUTH_CLIENT_IDNonmcp-clientClient HarnessID auquel le jeton d’accès doit être émis, vérifié par rapport à la revendication azp du jeton
HARNESS_MCP_OAUTH_ACCOUNT_CLAIMNonaccount_idRevendication du jeton d’accès contenant l’ID du compte Harness, renseignée par la portée HarnessID organization
HARNESS_MCP_OAUTH_SCOPESNonopenid profile email organizationPortées séparées par des espaces annoncées dans les métadonnées de ressource protégée RFC 9728
HARNESS_MCP_OAUTH_CLIENT_SECRETOui*--Secret confidentiel du client HarnessID émis par l’équipe Harness ID ; requis uniquement en mode oauth-proxy
HARNESS_MCP_OAUTH_EXTERNAL_SUB_CLAIMNonexternal_subRevendication du jeton HarnessID comparée au sujet ou à l’adresse e-mail en amont lors de l’association
HARNESS_MCP_OAUTH_PROXY_GRANTNonrefreshAutorisation pour les requêtes ultérieures en mode oauth-proxy : refresh ou jwt-bearer
HARNESS_MCP_OAUTH_PROXY_PUBLIC_URLOui*--Origine publique du courtier OAuth. Obligatoire en mode oauth-proxy et doit partager une origine avec HARNESS_MCP_OAUTH_RESOURCE
HARNESS_MCP_OAUTH_PROXY_VAULT_MODENonfilefile stocke le coffre chiffré sur le disque local d’un pod. redis partage les jetons d’actualisation et l’état de connexion entre les pods
HARNESS_MCP_OAUTH_PROXY_VAULT_PATHNon.harness-mcp/oauth-proxy-vault.encFichier chiffré contenant le jeton HarnessID et l’état de connexion, utilisé lorsque le mode de coffre est file
HARNESS_MCP_OAUTH_PROXY_VAULT_KEYOui*--Clé AES de 32 octets encodée en Base64, requise en mode oauth-proxy
HARNESS_MCP_OAUTH_PROXY_REDIS_URLOui*--URL rediss:// requise lorsque le mode de coffre est redis. redis:// nécessite HARNESS_ALLOW_HTTP=true. Redis 6.2 ou version ultérieure
HARNESS_MCP_OAUTH_PROXY_REDIS_KEY_PREFIXNonharness-mcp:oauthPréfixe des clés du coffre OAuth dans Redis
HARNESS_MCP_UPSTREAM_ISSUEROui*--Émetteur exact du jeton en amont, requis en mode oauth-proxy
HARNESS_MCP_UPSTREAM_AUDIENCEOui*--Audience exacte du jeton en amont, requise en mode oauth-proxy
HARNESS_MCP_UPSTREAM_JWKS_URINon<upstream issuer>/v1/keysPoint de terminaison JWKS RS256 en amont
HARNESS_MCP_UPSTREAM_SCOPESNonopenid profile email offline_accessPortées demandées par le courtier intégré et publiées au client MCP
HARNESS_MCP_UPSTREAM_OAUTH_CLIENT_IDOui*--Client OAuth confidentiel en amont utilisé par le courtier intégré
HARNESS_MCP_UPSTREAM_OAUTH_CLIENT_SECRETOui*--Secret du client OAuth en amont utilisé uniquement par le serveur
HARNESS_MCP_UPSTREAM_DISCOVERY_URINon<upstream issuer>/.well-known/openid-configurationPoint de terminaison de découverte OIDC en amont
HARNESS_MCP_UPSTREAM_EMAIL_DOMAINSNon--Domaines séparés par des virgules. L’association par e-mail nécessite email_verified=true et un domaine figurant dans cette liste. Une liste vide désactive l’association par e-mail
HARNESS_MCP_BROKER_ISSUERNonURL publique du proxy OAuthÉmetteur du serveur d’autorisation découvert par le client MCP
HARNESS_MCP_BROKER_CLIENT_IDNoncursor-harness-mcpID du client OAuth public. N’importe quel nom convient si le client MCP est configuré avec la même valeur
HARNESS_MCP_BROKER_REDIRECT_URISNon(vide)URI de redirection séparés par des virgules. Une valeur vide rejette tous les rappels. * n’autorise que les http/https de bouclage. Les schémas personnalisés doivent être indiqués exactement
HARNESS_MCP_BROKER_CODE_TTL_MSNon60000Durée de validité des codes d’autorisation à usage unique émis au client MCP
HARNESS_MCP_BROKER_TRANSACTION_TTL_MSNon600000Durée de validité maximale de la transaction d’autorisation par navigateur enchaînée
HARNESS_FME_API_KEYNon--Identifiant facultatif FME/Split Admin mono-utilisateur/autohébergé, utilisé pour les ressources fme_ en mode legacy (workspace_id) uniquement. FME legacy n’est pas disponible en mode OAuth ; les jetons HarnessID ne sont donc jamais transmis à api.split.io ; utilisez plutôt la portée native Harness org_id+project_id. Ne doit pas être défini en mode multi-user, oauth ou oauth-proxy
HARNESS_FME_BASE_URLNonhttps://api.split.ioURL de base de l’API Split/FME Admin utilisée par les ressources fme_ en mode legacy (workspace_id) uniquement. Les URL HTTP nécessitent HARNESS_ALLOW_HTTP=true pour le développement local. Le mode natif Harness (org_id+project_id) ignore ce paramètre et utilise plutôt les valeurs standard HARNESS_API_KEY/HARNESS_BASE_URL
HARNESS_APPSEC_API_KEYNon--Jeton facultatif de l’API Traceable Platform mono-utilisateur, utilisé par les ressources appsec_ (HARNESS_TOOLSETS=+appsec). HARNESS_API_KEY, la session x-harness-api-key et les jetons OAuth HarnessID ne sont jamais transmis à Traceable. Ne doit pas être défini en mode multi-user, oauth ou oauth-proxy (les sessions hébergées fournissent x-harness-appsec-api-key pour chaque session)
HARNESS_APPSEC_BASE_URLNonhttps://api.traceable.aiURL de base de l’API GraphQL Traceable utilisée par les ressources appsec_. Les URL HTTP nécessitent HARNESS_ALLOW_HTTP=true pour le développement local
HARNESS_APPSEC_UI_URLNonhttps://app.traceable.aiURL de base de l’interface Web Traceable utilisée pour les liens profonds des ressources appsec_ (dérivée automatiquement de HARNESS_APPSEC_BASE_URL si elle n’est pas définie)
HARNESS_ORGNon--ID de l’organisation. Utilisé lorsque org_id n’est pas spécifié pour un appel d’outil. Si omis, org_id doit être fourni explicitement. Les agents peuvent également découvrir les organisations de manière dynamique via harness_list(resource_type="organization")
HARNESS_PROJECTNon--ID du projet. Utilisé lorsque project_id n’est pas spécifié pour un appel d’outil. Les agents peuvent également découvrir les projets de manière dynamique via harness_list(resource_type="project")
HARNESS_API_TIMEOUT_MSNon30000Délai d’expiration des requêtes HTTP, en millisecondes
HARNESS_MAX_RETRIESNon3Nombre de tentatives pour les échecs temporaires (429, 5xx)
HARNESS_MAX_BODY_SIZE_MBNon10Taille maximale du corps des requêtes HTTP, en Mo, pour le transport http
HARNESS_RATE_LIMIT_RPSNon10Limitation du débit des requêtes côté client (requêtes par seconde) vers les API Harness
LOG_LEVELNoninfoNiveau de journalisation : debug, info, warn, error
HARNESS_TOOLSETSNon(valeurs par défaut)Liste d’ensembles d’outils séparés par des virgules. Une valeur vide charge les ensembles d’outils par défaut. Prend en charge +name pour inclure explicitement les ensembles d’outils facultatifs et -name pour retirer les valeurs par défaut (voir Filtrage des ensembles d’outils)
HARNESS_READ_ONLYNonfalseBloquer toutes les opérations de modification (création, mise à jour, suppression, exécution). Seules les opérations de liste et de récupération sont autorisées. Utile pour les environnements partagés/de démonstration
HARNESS_SCHEMA_MODENoncompactcompact (par défaut) ou full. Le mode compact remplace l’énumération des types de ressources par outil par une chaîne simple et raccourcit la description des champs, réduisant d’environ moitié la liste d’outils envoyée au modèle (voir docs/schema-budget.md). Les types sont découverts via harness_describe. Définissez full pour intégrer tous les types de ressources.
HARNESS_MCP_APPSNonoffVues MCP Apps. off (par défaut) conserve les résultats textuels uniquement. auto fournit la ressource ui://harness/app et ajoute des données de vue aux résultats harness_get, harness_execute et harness_status uniquement pour les hôtes qui déclarent l’extension io.modelcontextprotocol/ui ; les autres clients reçoivent toujours des résultats textuels inchangés
HARNESS_AUTO_APPROVE_RISKNonnoneSeuil d’approbation automatique fondé sur le risque pour les workflows autonomes. Les opérations dont le risque est inférieur ou égal à ce seuil sont exécutées sans confirmation. Valeurs : none, low_write, medium_write, high_write, all. Voir Elicitation
HARNESS_SKIP_ELICITATIONNonfalseObsolète — utilisez plutôt HARNESS_AUTO_APPROVE_RISK=all. Conservé pour assurer la rétrocompatibilité
HARNESS_ALLOW_HTTPNonfalseAutoriser les HARNESS_BASE_URL non HTTPS. Par défaut, le serveur impose HTTPS pour des raisons de sécurité. Définissez cette valeur sur true uniquement pour le développement local avec une instance Harness sans TLS
HARNESS_PIPELINE_VERSIONNon0(Alpha) Version du YAML de pipeline. 0 charge le type de ressource pipeline et exclut pipeline_v1 ; 1 charge pipeline_v1 et exclut pipeline. Les sessions HTTP peuvent remplacer cette valeur lors de l’initialisation avec x-harness-pipeline-version: 0 ou 1
HARNESS_MCP_ALLOWED_HOSTSNon--Noms d’hôte, séparés par des virgules, autorisés par la validation de l’en-tête Host du transport HTTP. mcp.harness.io est autorisé par défaut pour les liaisons localhost ; ajoutez ici les domaines du proxy ou personnalisés
HARNESS_MCP_AUTH_TOKENNon--Jeton Bearer statique requis sur les routes HTTP /mcp lorsqu’il est défini. Requis par défaut pour les liaisons mono-utilisateur et multi-utilisateur hors boucle locale. Doit être désactivé en mode oauth
HARNESS_MCP_ALLOW_UNAUTHENTICATED_HTTPNonfalseAutoriser explicitement le transport HTTP sans authentification sur les liaisons hors boucle locale. À utiliser uniquement derrière un autre contrôle authentifié
HARNESS_MCP_TRUST_PROXYNon0Nombre de sauts de proxy inverse / d’équilibreur de charge à approuver pour la résolution de l’adresse IP du client (Express trust proxy). Définissez cette valeur sur le nombre de proxys devant le serveur afin que la limitation du débit par IP utilise l’adresse du véritable client plutôt que celle du pair de la socket du proxy
HARNESS_MCP_LOG_FILENon~/.claude/harness-mcp.logFichier utilisé pour les diagnostics de déconnexion ou de plantage de stdio lorsque stderr risque de ne plus être disponible
HARNESS_LOG_UNSAFE_BODIESNonfalseInclure les corps bruts des requêtes et des réponses dans les journaux. Désactivé par défaut, car les corps peuvent contenir des secrets ; à activer uniquement pour le débogage local
HARNESS_AUDIT_FILENon--Ajouter les événements d’audit à un fichier JSON délimité par des retours à la ligne pour une collecte locale durable
HARNESS_AUDIT_WEBHOOK_URLNon--Point de terminaison HTTPS qui reçoit les événements d’audit groupés. Les URL HTTP nécessitent HARNESS_ALLOW_HTTP=true pour le développement local
HARNESS_AUDIT_WEBHOOK_TOKENNon--Jeton Bearer facultatif envoyé au webhook d’audit
HARNESS_AUDIT_WEBHOOK_BATCH_SIZENon10Nombre d’événements d’audit à regrouper avant l’envoi au webhook
HARNESS_AUDIT_WEBHOOK_FLUSH_MSNon5000Durée maximale de conservation des événements d’audit avant leur envoi au webhook
OTEL_EXPORTER_OTLP_ENDPOINTNon--Active les spans d’audit OpenTelemetry lorsque les packages OpenTelemetry facultatifs sont installés
HARNESS_SEARCH_PROVIDERNonlocalMoteur de recherche sémantique : local (embeddings ONNX en processus, valeur par défaut), remote (service de recherche externe via HTTP, requis en mode multi-utilisateur) ou none (désactiver la recherche sémantique et utiliser uniquement la recherche par mots-clés scatter-gather). Utilisez none dans les environnements isolés ou lorsque le chargement du modèle au démarrage n’est pas souhaitable
HARNESS_SEARCH_SERVICE_URLNon--URL de base du service de recherche distant lorsque HARNESS_SEARCH_PROVIDER=remote (par exemple, http://search-svc:8080). Requise avec le fournisseur remote
HARNESS_SEARCH_SERVICE_HEADERSNon--Objet JSON contenant les en-têtes envoyés avec chaque requête au service de recherche distant. Prend en charge tous les schémas d’authentification : {"Authorization":"Bearer tok"}, {"x-api-key":"key"} ou plusieurs en-têtes internes de service à service
HARNESS_HF_CACHE_DIRNon/tmp/hf-cacheRépertoire du cache du modèle @huggingface/transformers utilisé par le fournisseur de recherche local. L’image Docker intègre le modèle dans /app/.cache/hf pour éviter les téléchargements à l’exécution. Dans les déploiements de production, définissez cette valeur sur le chemin d’un volume persistant
HARNESS_DIAGNOSE_LOG_FETCH_CONCURRENCYNon3Nombre maximal de téléchargements simultanés de blobs de journaux lancés par harness_diagnose lors de la récupération des journaux des étapes en échec. Augmentez cette valeur uniquement si la latence du diagnostic est principalement due au temps de récupération des journaux et que le pod dispose de suffisamment de mémoire

Recherche sémantique

harness_search utilise le routage sémantique pour réduire les appels API scatter-gather avant de les distribuer à Harness. Trois fournisseurs de recherche sont disponibles :

FournisseurQuand l’utiliser
local (par défaut)Mode stdio mono-utilisateur. Exécute all-MiniLM-L6-v2 en processus via @huggingface/transformers. Télécharge un modèle d’environ 23 MB lors de la première utilisation ; les démarrages suivants utilisent le cache.
remoteMode HTTP multi-utilisateur (hébergé par Harness). Délègue la vectorisation et la récupération à un service de recherche externe. L’isolation des locataires est assurée via tenant_id — les connaissances et documents statiques utilisent global, tandis que les données d’entité propres à chaque compte utilisent l’ID du compte.
noneDésactive entièrement la recherche sémantique ; revient au scatter-gather par mots-clés sur tous les types de ressources.

Configuration du fournisseur distant :

HARNESS_SEARCH_PROVIDER=remote
HARNESS_SEARCH_SERVICE_URL=http://search-svc:8080

# Auth — any scheme via HARNESS_SEARCH_SERVICE_HEADERS (JSON object):
HARNESS_SEARCH_SERVICE_HEADERS='{"Authorization":"Bearer <token>"}'   # standard bearer
HARNESS_SEARCH_SERVICE_HEADERS='{"x-api-key":"<key>"}'               # API key header
HARNESS_SEARCH_SERVICE_HEADERS='{"x-harness-token":"<svc-token>"}'   # internal service-to-service
# Multiple headers (e.g. service mesh + tenant routing):
HARNESS_SEARCH_SERVICE_HEADERS='{"x-harness-token":"<tok>","x-tenant":"<id>"}'
# No auth (service mesh / mTLS handles it):
# omit HARNESS_SEARCH_SERVICE_HEADERS entirely

Tester le fournisseur distant en local avec le service de simulation inclus (sans dépendances externes) :

# 1. Create a venv and install FastAPI
python3 -m venv .venv-stub
.venv-stub/bin/pip install fastapi uvicorn

# 2. Start the stub (in-memory, cosine similarity, corpus + tenant filtering)
.venv-stub/bin/uvicorn stub-search-service:app --port 8082

# 3. Build the MCP server
pnpm build

# 4. Run the integration smoke test
node test-remote-provider.mjs
# Expected output:
#   available: true
#   indexed 2 docs
#   entity search results: pipeline:ts-test score=... corpus=entities
#   knowledge search results: schema:trigger score=...
#   all-corpus search results: (merged, sorted by score)
#   isolation check (other-acct, should be empty): PASS

# 5. Tear down
kill $(lsof -ti :8082)

Le service de simulation (stub-search-service.py) implémente le même contrat /v1/health, /v1/ingest et /v1/search que le service de recherche de production. Il utilise une simple vectorisation par sac de caractères, ce qui évite tout téléchargement de modèle — les résultats sont sémantiquement plausibles, mais ne sont pas de qualité production.

Application obligatoire de HTTPS

HARNESS_BASE_URL doit utiliser HTTPS par défaut. Si vous définissez une URL non HTTPS (par exemple, http://localhost:8080), le serveur refusera de démarrer avec le message suivant :

HARNESS_BASE_URL must use HTTPS (got "http://..."). If you need HTTP for local development, set HARNESS_ALLOW_HTTP=true.

Journalisation d’audit

Toutes les opérations de l’API Harness distribuées par le registre (list, get, create, update, delete et execute) émettent des événements d’audit structurés lorsque des destinations d’audit sont configurées. Les événements de modification incluent le mode de confirmation utilisé par l’élicitation ou l’approbation automatique lorsqu’un contexte de confirmation est présent ; les événements de lecture omettent actuellement les métadonnées de confirmation. Les outils locaux de métadonnées et de découverte de schémas qui contournent le registre, tels que harness_describe et harness_schema, ne font pas partie de ce flux d’audit. Une destination stderr est enregistrée par défaut, mais passe par le journaliseur habituel et respecte LOG_LEVEL ; configurez des destinations fichier ou webhook pour une collecte d’audit durable :

  • HARNESS_AUDIT_FILE ajoute des événements JSON délimités par des retours à la ligne pour une collecte locale.
  • HARNESS_AUDIT_WEBHOOK_URL envoie des lots { "events": [...] } à un webhook HTTPS, avec éventuellement HARNESS_AUDIT_WEBHOOK_TOKEN. Les lots en échec sont remis en file d’attente dans une capacité limitée, puis finalement abandonnés avec un avertissement plutôt que de bloquer l’exécution des outils.
  • OTEL_EXPORTER_OTLP_ENDPOINT active les spans d’audit lorsque les dépendances homologues facultatives d’OpenTelemetry sont installées. La destination réutilise un fournisseur de traceur existant s’il est enregistré ; sinon, elle initialise un exportateur OTLP autonome.

Chaque événement inclut le nom de l’outil, le type de ressource, l’opération, les identifiants, l’horodatage, le niveau de risque, le résultat, la méthode et le chemin HTTP, la durée et, le cas échéant, le mode de confirmation. Les destinations d’audit sont des mécanismes de télémétrie au mieux ; les problèmes de livraison sont consignés et ne rejouent jamais l’opération de l’API Harness sous-jacente, ni n’en modifient le déroulement. Pour en savoir plus sur la configuration OTel et les attributs des spans, consultez specs/005-otel-audit-sink.md.

Référence des outils

Le serveur expose 11 outils MCP. La plupart des outils API acceptent org_id et project_id comme remplacements facultatifs — s’ils sont omis, ils utilisent HARNESS_ORG et HARNESS_PROJECT. harness_describe ne fournit que des métadonnées locales et n’utilise pas de portée org/projet.

Prise en charge des URL : La plupart des outils destinés à l’API acceptent un paramètre url — collez une URL de l’interface Harness et le serveur en extrait automatiquement l’organisation, le projet, le type de ressource, l’ID de ressource, l’ID de pipeline et l’ID d’exécution. harness_describe n’accepte pas url.

Prise en charge des portées : Les types de ressources ayant des variantes au niveau du compte, de l’organisation ou du projet exposent supportedScopes dans harness_describe. Transmettez resource_scope lorsque vous avez besoin d’un niveau précis :

  • resource_scope: "account" transmet uniquement accountIdentifier.
  • resource_scope: "org" transmet accountIdentifier et orgIdentifier.
  • resource_scope: "project" transmet les identifiants du compte, de l’organisation et du projet.

Les ressources actuellement disponibles à plusieurs portées incluent connector, service, environment, infrastructure, secret, file_store, template, policy et policy_set. Si resource_scope est omis, le registre utilise la portée par défaut de la ressource et les valeurs par défaut configurées, sauf pour les ressources dont la portée est facultative, qui peuvent omettre l’organisation/le projet à moins qu’ils ne soient explicitement transmis. Les URL Harness peuvent également définir automatiquement la portée lorsque le chemin contient un contexte de niveau compte ou projet.

Sortie structurée : Chaque outil déclare un outputSchema MCP. harness_list normalise les réponses Harness de type liste en contenu structuré sous forme d’objet afin que les clients stricts puissent le valider : les tableaux de premier niveau deviennent { "items": [...], "total": <count>, "page": <page> }, et les clés d’enveloppe courantes telles que content, data, body, objects ou features sont remontées au niveau de items si nécessaire. La réponse textuelle contient toujours la charge utile JSON compacte renvoyée à tous les clients.

OutilDescription
harness_describeDécouvrir les types de ressources, les opérations et les champs disponibles. Aucun appel d’API — renvoie les métadonnées du registre local.
harness_schemaRécupérer les définitions exactes de schémas YAML/JSON et des exemples pour créer/mettre à jour des ressources. Les schémas de pipeline/modèle sont intégrés ; les schémas de connecteur, d’environnement, de service, de secret et d’infrastructure sont des schémas d’entités tenant compte de la portée, récupérés à partir d’instantanés intégrés ou de NG /yaml-schema ; les schémas release_process et release_activity sont récupérés en direct depuis RMG /api/yamlSchema. Prend en charge l’exploration approfondie via path.
harness_listRépertorier les ressources d’un type donné avec filtrage, recherche et pagination.
harness_getRécupérer une ressource à partir de son identifiant.
harness_createCréer une ressource. Prend en charge les pipelines intégrés et distants (adossés à Git). Demande la confirmation de l’utilisateur via elicitation.
harness_updateMettre à jour une ressource existante. Prend en charge les pipelines intégrés et distants (adossés à Git). Demande la confirmation de l’utilisateur via elicitation.
harness_deleteSupprimer une ressource. Demande la confirmation de l’utilisateur via elicitation. Opération destructive.
harness_executeExécuter une action sur une ressource (exécuter/réessayer un pipeline, importer un pipeline depuis Git, activer/désactiver un indicateur, synchroniser une application). Demande la confirmation de l’utilisateur via elicitation. Pour les exécutions de pipeline, utilisez le workflow de saisie des paramètres d’exécution ci-dessous (prend en charge l’expansion abrégée branch/tag/pr_number/commit_sha).
harness_searchEffectuer une recherche dans les types de ressources Harness à l’aide d’une seule requête. Utilise le routage sémantique (intégrations ONNX locales all-MiniLM-L6-v2, 384 dimensions) pour prédire les types de ressources pertinents à partir d’un corpus knowledge indexé au démarrage — ce qui réduit généralement le nombre de types d’environ 163 à 1–8 avant la recherche distribuée. Si le niveau de confiance sémantique est faible, utilise la recherche distribuée complète par mots-clés. La réponse inclut semantic_routed et types_skipped lorsque le routage est déclenché. Consultez docs/search-guidelines.md pour savoir comment rendre de nouveaux types de ressources détectables.
harness_diagnoseDiagnostiquer les ressources pipeline, connector, delegate et gitops_application (alias : execution -> pipeline, gitops_app -> gitops_application). Pour les pipelines, renvoie les durées des étapes et des tâches ainsi que les détails des échecs ; pour les connecteurs/applications déléguées/GitOps, renvoie des indicateurs ciblés sur l’état et le dépannage.
harness_statusObtenir un tableau de bord de santé du projet en temps réel — exécutions récentes, taux d’échec et liens profonds.

Workflow de recherche de schéma

Utilisez harness_schema avant de créer ou de mettre à jour des ressources basées sur YAML afin que les agents puissent reprendre les noms de champs et les contraintes exacts au lieu de les déduire à partir de la prose.

  • Les schémas intégrés comprennent pipeline, template, trigger, pipeline_v1, template_v1, inputSet_v1, overlayInputSet_v1 et agent-pipeline.
  • Les schémas d’entités comprennent connector, environment, service, secret et infrastructure. Ils tiennent compte de la portée (account, org ou project) et nécessitent org_id/project_id lorsque la portée sélectionnée l’exige.
  • Les définitions de Release Management (release_process, release_activity) récupèrent en direct le schéma JSON depuis RMG /api/yamlSchema (elles ne sont pas intégrées). Transmettez scope, org_id et project_id pour définir la portée sur une organisation ou un projet.
  • Les instantanés d’entités fournis sont utilisés en premier lorsqu’ils correspondent au compte d’exécution ; sinon, l’outil utilise l’API Harness NG /yaml-schema et met le résultat en cache.
  • Omettez path pour obtenir un résumé des champs/sections, puis transmettez un path séparé par des points pour examiner une définition imbriquée.

Exemples :

{ "resource_type": "pipeline", "path": "pipeline.stages" }
{
  "resource_type": "connector",
  "scope": "project",
  "org_id": "default",
  "project_id": "payments"
}

Les responsables de maintenance peuvent actualiser les instantanés d’entités fournis avec pnpm sync-entity-schemas lorsque les schémas YAML d’entités Harness changent.

Exemples d’outils

Découvrir les ressources disponibles :

{ "resource_type": "pipeline" }

Répertorier les organisations du compte :

{ "resource_type": "organization" }

Répertorier les projets d’une organisation :

{ "resource_type": "project", "org_id": "default" }

Répertorier les pipelines d’un projet :

{ "resource_type": "pipeline", "search_term": "deploy", "size": 10 }

Récupérer un service spécifique :

{ "resource_type": "service", "resource_id": "my-service-id" }

Exécuter un pipeline :

{
  "resource_type": "pipeline",
  "action": "run",
  "resource_id": "my-pipeline",
  "inputs": { "tag": "v1.2.3" },
  "wait": true
}

Activer/désactiver un indicateur de fonctionnalité :

{
  "resource_type": "feature_flag",
  "action": "toggle",
  "resource_id": "new_checkout_flow",
  "enable": true,
  "environment": "production"
}

Effectuer une recherche dans tous les types de ressources :

{ "query": "payment-service" }

Diagnostiquer une exécution par ID (mode résumé — par défaut) :

{ "execution_id": "abc123XYZ" }

Diagnostiquer à partir d’une URL Harness :

{ "url": "https://app.harness.io/ng/account/.../pipelines/myPipeline/executions/abc123XYZ/pipeline" }

Diagnostiquer la connectivité d’un connecteur :

{ "resource_type": "connector", "resource_id": "my_github_connector" }

Diagnostiquer l’état d’un délégué :

{ "resource_type": "delegate", "resource_id": "delegate-us-east-1" }

Diagnostiquer une application GitOps (avec options) :

{
  "resource_type": "gitops_application",
  "resource_id": "checkout-app",
  "options": { "agent_id": "gitops-agent-1" }
}

Obtenir le rapport d’exécution le plus récent d’un pipeline :

{ "pipeline_id": "my-pipeline" }

Mode de diagnostic complet avec YAML et journaux des tâches en échec :

{ "execution_id": "abc123XYZ", "summary": false }

Mode résumé avec journaux activés (le meilleur des deux) :

{ "execution_id": "abc123XYZ", "include_logs": true }

Obtenir l’état de santé du projet :

{ "org_id": "default", "project_id": "my-project", "limit": 5 }

Répertorier les schémas de base de données filtrés par type de migration :

{ "resource_type": "database_schema", "migration_type": "Liquibase" }

Répertorier les instances de base de données d’un schéma :

{ "resource_type": "database_instance", "dbschema_id": "my_schema" }

Obtenir le pipeline de création LLM résolu pour un schéma et une instance :

{ "resource_type": "database_llm_authoring_pipeline", "resource_id": "my_schema", "dbinstance_id": "prod_db" }

Répertorier les noms d’objets d’instantané (par exemple, les tables) d’une instance de schéma :

{
  "resource_type": "database_snapshot_object",
  "dbschema_id": "my_schema",
  "dbinstance_id": "prod_db",
  "object_type": "Table"
}

Obtenir les métadonnées complètes d’instantané pour des objets nommés spécifiques :

{
  "resource_type": "database_snapshot_object",
  "resource_id": "prod_db",
  "params": {
    "dbschema_id": "my_schema",
    "object_type": "Table",
    "object_names": ["users", "orders"]
  }
}

Workflow d’exécution de pipeline (recommandé)

Pour les pipelines v0, suivez cette séquence afin de réduire les erreurs de paramètres au moment de l’exécution :

  1. Découvrir les paramètres d’exécution requis
  • harness_get(resource_type="runtime_input_template", resource_id="<pipeline_id>")
  • Le modèle renvoyé indique les espaces réservés <+input> auxquels attribuer des valeurs.
  1. Choisir une stratégie de saisie
  • Variables simples : transmettez des inputs clé-valeur à plat (par exemple, {"branch":"main","env":"prod"}).

  • Entrées complexes/structurelles : utilisez input_set_ids (les blocs de codebase/build CI et les entrées de modèles imbriqués sont mieux gérés ainsi).

  • Clés abrégées de codebase CI (exécution de pipeline uniquement) :

    Clé abrégéeStructure développée
    branchbuild.type=branch, build.spec.branch=<value>
    tagbuild.type=tag, build.spec.tag=<value>
    pr_numberbuild.type=PR, build.spec.number=<value>
    commit_shabuild.type=commitSha, build.spec.commitSha=<value>
  • Contrainte : l’expansion des formes abrégées est ignorée lorsque inputs.build est déjà présent (un build explicite est prioritaire).

  1. Exécuter le pipeline
  • harness_execute(resource_type="pipeline", action="run", resource_id="<pipeline_id>", ...)

  • Pour les pipelines adossés à Git dont le YAML doit être chargé depuis une branche autre que celle par défaut, transmettez params.pipeline_branch (envoyé à Harness sous la forme branch). Ce sélecteur de définition explicite est prioritaire sur l’alias params.branch. inputs.branch sélectionne indépendamment la branche de codebase CI :

    {
      "resource_type": "pipeline",
      "action": "run",
      "resource_id": "deploy_app",
      "params": { "pipeline_branch": "feature/new-stage" },
      "inputs": { "branch": "main" },
      "wait": true
    }
    
  1. Facultatif : combiner les deux
  • Utilisez input_set_ids pour la structure de base et inputs pour les remplacements simples.

Pour les pipelines v1 :

  1. Récupérez harness_get(resource_type="runtime_input_template_v1", resource_id="<pipeline_id>"). Pour les pipelines adossés à Git, transmettez branch_name, connector_ref et repo_name via params.
  2. Utilisez chaque inputs[].details.name renvoyé comme clé de premier niveau dans harness_execute.inputs.
  3. Exécutez harness_execute(resource_type="pipeline_v1", action="run", resource_id="<pipeline_id>", inputs={...}). Le serveur place ces valeurs sous une racine YAML inputs: et envoie le corps inputs_yaml de l’API. Si des champs obligatoires ne sont pas résolus, l’outil renvoie une erreur de prévalidation avec les clés attendues et des ensembles d’entrées suggérés. Vous pouvez consulter les mappages abrégés disponibles avec harness_describe(resource_type="pipeline") (executeActions.run.inputShorthands).

Exécution dynamique de pipeline

Utilisez pipeline_dynamic_execution.run lorsqu’un agent ou un système externe génère le YAML complet du pipeline v0 à l’exécution et doit l’exécuter sur un squelette de pipeline Harness existant. Il ne remplace pas le fonctionnement normal de pipeline.run : le pipeline v0 enregistré doit déjà exister, Allow Dynamic Execution doit être activé au niveau du compte et du pipeline, et l’appelant doit disposer des autorisations Edit et Execute sur le pipeline.

{
  "resource_type": "pipeline_dynamic_execution",
  "action": "run",
  "resource_id": "deploy_app",
  "body": {
    "yaml": "pipeline:\n  identifier: deploy_app\n  name: Deploy App\n  stages: []"
  },
  "params": {
    "module_type": "CD",
    "notes": "agent-generated dynamic run",
    "notify_only_user": true
  }
}

Contraintes :

  • body doit être un objet comportant un champ yaml. Les corps bruts sous forme de chaîne sont rejetés par le schéma public harness_execute.
  • body.yaml peut être une chaîne YAML ou un objet de pipeline JSON ; le JSON est sérialisé en YAML avant la requête.
  • Les espaces réservés d’exécution <+input> ne sont pas résolus par cette API. Envoyez un YAML entièrement résolu.
  • Les ensembles d’entrées, l’exécution sélective des étapes, les nouvelles tentatives et les déclencheurs ne sont pas pris en charge par le point de terminaison d’exécution dynamique.
  • L’action est high_write et suit le processus normal de confirmation/approbation automatique. La réponse projette l’enveloppe de l’API vers { "execution_id": "...", "status": "..." } et inclut un lien d’exécution openInHarness lorsque les données de portée sont disponibles.

Si Harness rejette l’exécution au motif qu’elle n’est pas activée, vérifiez le paramètre Allow Dynamic Execution au niveau du compte ainsi que le bouton correspondant au niveau du pipeline, sous Pipeline -> Advanced Options -> Dynamic Execution Settings.

Analyse forensique des entrées d’exécution

Utilisez execution_inputs après une exécution pour examiner le YAML d’entrée fusionné qui a produit une exécution donnée. Cette fonction est utile lorsqu’un échec dépend de la fusion d’ensembles d’entrées, de branches d’ensembles d’entrées gérées par Git ou de valeurs de déclencheur/d’exécution difficiles à reconstituer à partir de la seule page d’exécution.

{
  "resource_type": "execution_inputs",
  "resource_id": "PLAN_EXECUTION_ID",
  "params": {
    "resolve_expressions": true,
    "resolve_expressions_type": "RESOLVE_ALL_EXPRESSIONS"
  }
}

La réponse get est projetée vers :

  • executionId - l’ID d’exécution du plan provenant de resource_id.
  • inputSetYaml - le YAML d’entrée d’exécution fusionné utilisé pour l’exécution, ou null.
  • inputSetTemplateYaml - le modèle d’entrée au moment de l’exécution, ou null.
  • resolvedYaml - le YAML avec expressions résolues lorsque resolve_expressions=true, sinon généralement null.
  • inputSetDetails - les ensembles d’entrées enregistrés ayant contribué, sous forme de paires { identifier, name }.
  • inputSetBranchName - la branche source des ensembles d’entrées gérés par Git, ou null.

execution_inputs est en lecture seule et présente un risque de lecture. Si resolve_expressions est omis, le serveur omet les paramètres de requête de l’API et Harness utilise son mode de résolution par défaut UNKNOWN.

Mode d’attente d’exécution de pipeline

Pour pipeline.run, pipeline.retry et pipeline_v1.run, transmettez wait: true pour que le serveur effectue des vérifications périodiques jusqu’à ce que l’exécution atteigne un état terminal. Cela permet de lancer un pipeline et d’en vérifier l’état dans un seul appel d’outil, au lieu de demander au client ou au LLM d’exécuter une boucle de vérification périodique.

{
  "resource_type": "pipeline",
  "action": "run",
  "resource_id": "deploy_app",
  "inputs": { "branch": "main" },
  "wait": true,
  "wait_timeout_seconds": 900,
  "wait_poll_interval_seconds": 5
}

Comportement du mode d’attente :

  • Le délai d’expiration par défaut est de 600 secondes ; la plage autorisée va de 10 à 7200 secondes.
  • L’intervalle initial entre les vérifications est de 3 secondes par défaut, augmente d’un facteur de 1,5 et est plafonné à 30 secondes.
  • En cas de réussite ou d’échec, la réponse inclut des champs tels que execution_id, execution_status, execution_terminal, execution_elapsed_ms et execution_poll_count.
  • Si le délai d’expiration est atteint, le déclenchement initial a tout de même réussi ; la réponse inclut execution_timed_out: true et _wait.hint avec le dernier état observé.
  • Si la vérification périodique échoue après la réussite du déclenchement, la réponse inclut _wait.error et une indication pour vérifier à nouveau. Ne relancez pas aveuglément le pipeline sans avoir confirmé que la première exécution n’est pas en cours.
  • Les états terminaux d’échec incluent _diagnose_hint pointant vers harness_diagnose(resource_type="execution", options={execution_id: "..."}).

Demander à l’agent AI DevOps de créer un pipeline :

{
  "prompt": "Create a pipeline that builds a Go app with Docker and deploys to Kubernetes",
  "action": "CREATE_PIPELINE"
}

Mettre à jour un service en langage naturel :

{
  "prompt": "Add a sidecar container for logging",
  "action": "UPDATE_SERVICE",
  "conversation_id": "prev-conversation-id",
  "context": [{ "type": "yaml", "payload": "<existing service YAML>" }]
}

Modes de stockage des pipelines

Les pipelines Harness peuvent être stockés de trois façons :

ModeDescriptionQuand l’utiliser
InlineYAML du pipeline stocké dans HarnessPar défaut. Configuration la plus simple, sans Git requis.
Remote (External Git)YAML du pipeline stocké dans GitHub, GitLab, Bitbucket, etc.Équipes utilisant des pipelines en tant que code gérés par Git avec un fournisseur externe.
Remote (Harness Code)YAML du pipeline stocké dans un dépôt Harness CodeÉquipes utilisant l’hébergement Git intégré de Harness.

Créer un pipeline inline (par défaut) :

// harness_create
{
  "resource_type": "pipeline",
  "body": {
    "yamlPipeline": "pipeline:\n  name: My Pipeline\n  identifier: my_pipeline\n  stages:\n    - stage:\n        name: Build\n        type: CI\n        spec:\n          execution:\n            steps:\n              - step:\n                  type: Run\n                  name: Echo\n                  spec:\n                    command: echo hello"
  }
}

Créer un pipeline distant (External Git — par exemple, GitHub) :

// harness_create
{
  "resource_type": "pipeline",
  "body": {
    "yamlPipeline": "pipeline:\n  name: Deploy Service\n  identifier: deploy_service\n  stages: []"
  },
  "params": {
    "store_type": "REMOTE",
    "connector_ref": "my_github_connector",
    "repo_name": "my-repo",
    "branch": "main",
    "file_path": ".harness/deploy-service.yaml",
    "commit_msg": "Add deploy pipeline via MCP"
  }
}

Créer un pipeline distant (Harness Code — aucun connecteur requis) :

// harness_create
{
  "resource_type": "pipeline",
  "body": {
    "yamlPipeline": "pipeline:\n  name: Build App\n  identifier: build_app\n  stages: []"
  },
  "params": {
    "store_type": "REMOTE",
    "is_harness_code_repo": true,
    "repo_name": "product-management",
    "branch": "main",
    "file_path": ".harness/build-app.yaml",
    "commit_msg": "Add build pipeline via MCP"
  }
}

Mettre à jour un pipeline distant :

// harness_update
{
  "resource_type": "pipeline",
  "resource_id": "deploy_service",
  "body": {
    "yamlPipeline": "pipeline:\n  name: Deploy Service\n  identifier: deploy_service\n  stages:\n    - stage:\n        name: Deploy\n        type: Deployment"
  },
  "params": {
    "store_type": "REMOTE",
    "connector_ref": "my_github_connector",
    "repo_name": "my-repo",
    "branch": "main",
    "file_path": ".harness/deploy-service.yaml",
    "commit_msg": "Update deploy pipeline via MCP",
    "last_object_id": "abc123",
    "last_commit_id": "def456"
  }
}

Importer un pipeline depuis un dépôt Git externe :

// harness_execute
{
  "resource_type": "pipeline",
  "action": "import",
  "params": {
    "connector_ref": "my_github_connector",
    "repo_name": "my-repo",
    "branch": "main",
    "file_path": ".harness/existing-pipeline.yaml"
  },
  "body": {
    "pipeline_name": "Existing Pipeline",
    "pipeline_description": "Imported from GitHub"
  }
}

Importer un pipeline depuis un dépôt Harness Code :

// harness_execute
{
  "resource_type": "pipeline",
  "action": "import",
  "params": {
    "is_harness_code_repo": true,
    "repo_name": "product-management",
    "branch": "main",
    "file_path": ".harness/existing-pipeline.yaml"
  },
  "body": {
    "pipeline_name": "Existing Pipeline"
  }
}

Créer un connecteur :

{
  "resource_type": "connector",
  "body": { "connector": { "name": "My Docker Hub", "identifier": "my_docker", "type": "DockerRegistry" } }
}

Supprimer un déclencheur :

{
  "resource_type": "trigger",
  "resource_id": "nightly-trigger",
  "pipeline_id": "my-pipeline"
}

Lister les ensembles d’entrées d’un pipeline :

{
  "resource_type": "input_set",
  "pipeline_id": "my-pipeline"
}

Récupérer un ensemble d’entrées spécifique :

{
  "resource_type": "input_set",
  "resource_id": "prod-inputs",
  "pipeline_id": "my-pipeline"
}

Créer un ensemble d’entrées :

{
  "resource_type": "input_set",
  "pipeline_id": "my-pipeline",
  "body": "inputSet:\n  name: Production Inputs\n  identifier: prod_inputs\n  pipeline:\n    identifier: my-pipeline\n    variables:\n      - name: env\n        type: String\n        value: production"
}

Mettre à jour un ensemble d’entrées :

{
  "resource_type": "input_set",
  "resource_id": "prod_inputs",
  "pipeline_id": "my-pipeline",
  "body": "inputSet:\n  name: Production Inputs\n  identifier: prod_inputs\n  pipeline:\n    identifier: my-pipeline\n    variables:\n      - name: env\n        type: String\n        value: production\n      - name: replicas\n        type: String\n        value: \"3\""
}

Supprimer un ensemble d’entrées :

{
  "resource_type": "input_set",
  "resource_id": "prod_inputs",
  "pipeline_id": "my-pipeline"
}

Types de ressources

274 types de ressources répartis sur 44 ensembles d’outils. Chaque type de ressource prend en charge un sous-ensemble d’opérations CRUD et des actions d’exécution facultatives.

Plateforme

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
organizationxxxxx
projectxxxxx

Pipelines

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
pipelinexxxxxrun, retry
pipeline_v1 (Alpha)xxxxxrun
pipeline_dynamic_executionrun
executionxxinterrupt
execution_inputsx
triggerxxxxx
pipeline_summaryx
input_setxxxxx
runtime_input_templatex
runtime_input_template_v1x
pipeline_resolved_yamlx
approval_instancexapprove, reject

Les deux types de ressources YAML de pipeline sont disponibles lorsque l’ensemble d’outils pipelines est activé. HARNESS_PIPELINE_VERSION et l’en-tête d’initialisation HTTP x-harness-pipeline-version définissent la préférence de version par défaut ; ils ne masquent pas l’autre version.

Agents IA

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
agentxxxxx
agent_runx

Services

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
servicexxxxx

Environnements

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
environmentxxxxxmove_configs

Connecteurs

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
connectorxxxxxtest_connection
connector_cataloguex
llm_modelx

Infrastructure

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
infrastructurexxxxxmove_configs

Secrets

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
secretxx

Journaux d’exécution

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
execution_logx

Piste d’audit

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
audit_eventxx

Délégués

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
delegatexx
delegate_tokenxxxxrevoke, get_delegates

Dépôts de code

Type de ressourceListeRécupérerCréerMettre à jourSupprimerActions d’exécution
repositoryxxxx
branchxxxx
commitxxxdiff, diff_stats
file_contentxxblame
tagxxx
repo_rulexx
space_rulexx

La création de commit valide directement une ou plusieurs actions sur des fichiers via l’API Harness Code, sans clonage. Transmettez body.title, body.branch et body.actions ; chaque action est CREATE, UPDATE, DELETE ou MOVE, et UPDATE nécessite le SHA du blob actuel.

La liste file_content renvoie tous les chemins à une référence ; la récupération renvoie le contenu d’un fichier ou d’un répertoire (omettez path ou transmettez-le vide pour la racine du dépôt ; les chemins imbriqués conservent les barres obliques). Omettez git_ref pour utiliser la branche par défaut du dépôt — ne devinez pas main.

Registres d’artefacts

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
registryxx
artifactx
artifact_versionx
artifact_filex

Stockage de fichiers

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
file_storexxxxxlist_children

file_store gère les fichiers et dossiers Harness File Store au moyen des outils génériques. Il prend en charge les portées compte, organisation et projet ; transmettez resource_scope="account"|"org"|"project" ou collez une URL Harness File Store afin que le serveur puisse déduire la portée et les identifiants.

Appels courants :

# List the account-level File Store.
harness_list(resource_type="file_store", resource_scope="account")

# Create a folder at the current scope root.
harness_create(resource_type="file_store", body={
  name: "scripts",
  type: "FOLDER",
  parent_identifier: "Root"
})

# Upload a UTF-8 script file. Use content_base64 instead for binary data.
harness_create(resource_type="file_store", body={
  name: "deploy.sh",
  type: "FILE",
  parent_identifier: "Root",
  content: "#!/usr/bin/env bash\n./deploy",
  mime_type: "text/x-shellscript",
  file_usage: "SCRIPT"
})

# Rename metadata without replacing file content.
harness_update(resource_type="file_store", resource_id="deploy_script", body={
  name: "deploy-prod.sh",
  type: "FILE",
  parent_identifier: "Root"
})

# List first-level children of a folder. This is a read-risk execute action.
harness_execute(resource_type="file_store", action="list_children",
  resource_id="scripts_folder", params={folder_name: "scripts"})

Contraintes du corps multipart :

  • La création et la mise à jour acceptent du JSON body, puis le convertissent en multipart/form-data pour /ng/api/file-store.
  • name, type (FILE ou FOLDER) et parent_identifier sont obligatoires ; utilisez la valeur littérale "Root" uniquement pour la racine de la portée sélectionnée.
  • La création de FILE exige exactement l'un des champs content (chaîne UTF-8) ou content_base64 (base64 valide et non vide). La mise à jour de FILE peut omettre le contenu pour les mises à jour des métadonnées uniquement, ou fournir exactement un champ de contenu pour remplacer le contenu.
  • La création et la mise à jour de FOLDER doivent omettre content et content_base64.
  • Le champ facultatif file_usage doit être MANIFEST_FILE, CONFIG ou SCRIPT ; les métadonnées scalaires facultatives telles que description, mime_type, path et tags doivent être des chaînes.
  • Le contenu téléversé est limité à 100 MB. Avant l'élicitation, les invites de confirmation masquent les aperçus de content, content_base64 et contentBase64.

list_children accepte soit une forme abrégée (resource_id avec params.folder_name, ou params.file_store_id/params.folder_identifier avec params.folder_name), soit un body complet de FileStoreNode avec identifier, name et type: "FOLDER". Les corps complets utilisent le parentIdentifier camelCase de Harness ; la forme abrégée peut utiliser params.parent_identifier.

Modèles

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
templatexxxxx

Les opérations sur les modèles utilisent les chemins du service Harness Template (/template/api/templates...). La création et la mise à jour exigent la chaîne YAML complète du modèle dans body.template_yaml ou body.yaml ; version_label cible une version précise pour la mise à jour ou la suppression, tandis qu'une suppression sans version_label supprime toutes les versions.

Tableaux de bord

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
dashboardxx
dashboard_datax

DevOps de bases de données

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
database_schemaxxxxx
database_instancexxxxx
database_snapshot_objectxx
database_llm_authoring_pipelinex

Gestion de l'infrastructure en tant que code (IaCM)

Les ressources IaCM sont activées par défaut et sont principalement limitées à la portée du projet. Commencez par iacm_workspace pour trouver les identifiants des espaces de travail, puis utilisez ce workspace_id pour les ressources d'espace de travail, les coûts et les différences d'activité. Utilisez iacm_variable_set pour les ensembles de variables réutilisables à la portée du compte, de l'organisation ou du projet. Le registre des fournisseurs est limité à la portée du compte.

iacm_module couvre les portées compte, organisation et projet. Par défaut, il utilise le registre du compte ; chaque opération (liste, obtention, création, mise à jour) envoie les mêmes paramètres de requête scope_org / scope_project, de sorte qu'un module créé est visible dans la portée où il a été créé. Sélectionnez la portée avec resource_scope="account" | "org" | "project" et org_id/project_id. La définition de portée est facultative : si resource_scope est omis, org_id/project_id ne s'appliquent que si vous les transmettez explicitement — les valeurs par défaut configurées de HARNESS_ORG/HARNESS_PROJECT ne sont pas appliquées, afin qu'une configuration de projet ambiante ne puisse pas enregistrer silencieusement un module de compte dans un projet. Les champs org/project propres au corps du module localisent son connecteur Git et n'ont aucun lien avec cette portée de visibilité.

La création et la mise à jour de iacm_workspace renvoient uniquement { policy_evaluation } — appelez ensuite harness_get pour récupérer l'espace de travail. La création et la mise à jour de iacm_variable_set et iacm_module renvoient la ressource elle-même. La création de iacm_provider renvoie uniquement { id } — appelez ensuite harness_get ; la mise à jour concerne uniquement les versions (POST/PUT /providers/{id}/version) — il n'existe pas de PUT des métadonnées. Les écritures de version peuvent renvoyer un corps vide ; HarnessClient normalise ce résultat en { status: "SUCCESS", message: "No content" }.

La mise à jour d'un ensemble de variables est un HTTP PUT avec des collections entièrement remplacées — appelez toujours harness_get d'abord, puis envoyez le corps complet souhaité par PUT (terraform_variables / environment_variables sont obligatoires lors de la mise à jour ; omis ou vides, ils effacent les connecteurs et les fichiers de variables). La mise à jour d'un module est également un PUT — privilégiez la séquence obtenir puis PUT pour les champs facultatifs. Les écritures sont medium_write et nécessitent une confirmation (élicitation ou confirm: true).

Le RBAC des ensembles de variables et du registre des fournisseurs (iac_variableset_*, iac_providerregistry_*) est actuellement expérimental dans Harness — les vérifications d'accès autorisent toujours les opérations jusqu'à ce que iac-server active l'application des règles. Le RBAC du registre des modules (iac_registry_view / iac_registry_edit) est actif et applicable. MCP transmet toujours le PAT/SAT de l'appelant sans modification.

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
iacm_workspacexxxx
iacm_variable_setxxxx
iacm_resourcex
iacm_modulexxxx
iacm_providerxxxx
iacm_workspace_costsx
iacm_activity_resource_changex

Flux de travail type :

  1. harness_list(resource_type="iacm_workspace", org_id="...", project_id="...") pour trouver l'espace de travail.
  2. harness_create / harness_update sur iacm_workspace pour créer à partir de zéro ou d'un modèle (associated_template), ou mettre à jour un espace de travail existant — la réponse contient uniquement { policy_evaluation }.
  3. harness_get(resource_type="iacm_workspace", workspace_id="...") pour récupérer l'espace de travail créé ou mis à jour.
  4. harness_list / harness_create / harness_update sur iacm_variable_set (éventuellement avec resource_scope) pour les ensembles de variables Terraform/env réutilisables — la réponse est la ressource VariableSet.
  5. harness_list / harness_create / harness_update sur iacm_module pour le registre des modules (name + system obligatoires ; ajoutez resource_scope avec org_id/project_id pour un module à portée d'organisation ou de projet) — la réponse est la ressource du module.
  6. harness_list / harness_create / harness_update sur iacm_provider pour le registre des fournisseurs du compte (body.type obligatoire pour la création ; la création renvoie uniquement { id } — appelez ensuite harness_get ; la mise à jour crée ou met à jour uniquement des versions) — la mise à jour d'une version peut renvoyer un succès avec un corps vide.
  7. harness_list(resource_type="iacm_resource", org_id="...", project_id="...", workspace_id="...") pour examiner les ressources Terraform, les sorties et les sources de données.
  8. harness_list(resource_type="iacm_workspace_costs", org_id="...", project_id="...", workspace_id="...") pour consulter les entrées de coût par exécution.
  9. harness_list(resource_type="iacm_activity_resource_change", org_id="...", project_id="...", activity_id="...", workspace_id="...") pour examiner les différences de ressources avant/après d'une activité de planification, d'application ou de destruction.

Les réponses de liste IaCM exposent page_count comme nombre d'éléments de la page actuelle uniquement (sauf iacm_variable_set, qui n'est pas paginé). Lorsque has_more est vrai, continuez à demander la page suivante, dont la numérotation commence à 1, et additionnez les nombres de chaque page si vous avez besoin du total.

Portail développeur interne (IDP)

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
idp_entityxx
scorecardxx
scorecard_checkxx
scorecard_statsx
scorecard_check_statsx
idp_scorexx
idp_workflowxexecute
idp_tech_docx

Demandes de fusion

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
pull_requestxxxxclose, merge
pr_reviewerxxsubmit_review
pr_commentxxxresolve, unresolve
pr_checkx
pr_activityx

Utilisez harness_execute(resource_type="pull_request", action="close", ...) pour effectuer une opération de fermeture explicite. harness_update accepte également body.state (open ou closed) et achemine les changements d'état vers le point de terminaison dédié de l'état des demandes de fusion Harness Code ; envoyez les modifications du titre/de la description dans un appel de mise à jour distinct.

Utilisez harness_list(resource_type="pr_activity", filters={type: ["comment", "code-comment"]}, ...) pour lire les commentaires des demandes de fusion. Utilisez pr_comment pour les opérations d'écriture de commentaires.

Utilisez harness_execute(resource_type="pr_comment", action="resolve", ...) pour résoudre un fil de commentaires et action="unresolve" pour le rouvrir ; aucun des deux ne prend de corps. comment_id doit être le id d'une ligne de pr_activity dont le parent_id est null ; l'API rejette les identifiants de réponse.

Gestion des versions

Les ressources de gestion des versions (RMG) sont activées par défaut. Les ressources de définition (release_process, release_activity) prennent en charge les opérations de liste, d'obtention, de création, de mise à jour et de suppression avec body.yaml ; appelez harness_schema(resource_type="release_process"|"release_activity") avant la création ou la mise à jour. Les ressources d'exécution surveillent les versions en cours — la plupart des opérations de liste exigent release_id (UUID de harness_list resource_type=release, ou identifiant d'URL de l'interface utilisateur tel que identifier-1.0.0-abc). Collez une URL de version RMG dans harness_list pour renseigner automatiquement release_id.

Les appels RMG utilisent ${HARNESS_BASE_URL}/gateway/rmg avec une portée de compte définie par l'en-tête Harness-Account. La portée organisation/projet utilise une définition de portée par en-têtes lorsque org_id/project_id sont fournis. release_execution_phase est réservé aux listes — utilisez le champ identifier de chaque élément de phase comme params.phase_identifier lors de l'appel de harness_get sur les ressources d'entrée/sortie de phase (n'appelez pas harness_get sur release_execution_phase lui-même). Le filtrage de status des listes de versions est appliqué côté client à la page actuelle uniquement ; continuez la pagination avec les mêmes filtres lorsque les résultats peuvent s'étendre sur plusieurs pages.

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
release_processxxxxx
release_activityxxxxx
releasexx
release_execution_phasex
release_execution_taskx
release_execution_activityx
release_inputx
release_execution_phase_inputx
release_execution_phase_outputx
release_execution_activity_inputx
release_execution_activity_outputx

Flux de travail type :

  1. harness_list(resource_type="release_process", org_id="...", project_id="...") pour découvrir les définitions des processus d’orchestration.
  2. harness_schema(resource_type="release_process") (ou release_activity) avant la création ou la mise à jour ; puis harness_create / harness_update avec body.yaml.
  3. harness_list(resource_type="release", org_id="...", project_id="...") pour trouver les versions actives ou récentes (période de recherche rétrospective de 30 jours par défaut ; filters.status, filters.search_term, filters.days_back facultatifs).
  4. harness_get(resource_type="release", release_id="...") pour obtenir les détails d’une version.
  5. harness_list(resource_type="release_execution_phase", filters={ release_id: "..." }) pour connaître l’état des phases ; même release_id pour release_execution_task et release_execution_activity.
  6. harness_get sur release_input, release_execution_phase_input, release_execution_phase_output, release_execution_activity_output ou release_execution_activity_input à l’aide de release_id et de params.phase_identifier / params.activity_identifier / activity_execution_id, comme indiqué pour chaque ressource.

Recherche unifiée

L’ensemble d’outils facultatif unified-search (HARNESS_TOOLSETS=+unified-search) ajoute une recherche sémantique (fondée sur le sens) dans toutes les sources proposées par search-service. Les résultats sont limités au compte de l’appelant et filtrés selon le RBAC. Le compte doit disposer de l’indicateur de fonctionnalité de recherche sémantique.

Type de ressourceListerObtenirExécuter des actions
unified_searchxsearch
unified_search_sourcex
# 1. Search with the user's words (all sources)
harness_search(query="payments service that keeps crashing")

# 2. Optional: if a hit names a Knowledge Graph type, look it up or query it
harness_get(resource_type="kg_type", resource_id="<type id>", params={kind: "<kind>"})

# 3. Narrow with filters on the hits' metadata keys, per source
harness_execute(resource_type="unified_search", action="search", body={
  query: "payments service that keeps crashing",
  source_filters: {"<source>": {predicate: {field: "<metadata key>", op: "NE", values: [{string_value: "closed"}]}}}
})

harness_get(resource_type="unified_search_source") répertorie les sources. Consultez harness_describe(resource_type="unified_search") pour la syntaxe des filtres.

Cette fonctionnalité est distincte des fournisseurs de routage sémantique de Recherche sémantique, qui indexent les définitions et la documentation des ressources MCP afin de réduire la portée de la recherche distribuée de harness_search.

Vibe

L’ensemble d’outils vibe, activé par défaut, couvre le contrat Vibe Orchestrator BFF sous ${HARNESS_BASE_URL}/vibe/v1. Il utilise la connexion Harness existante et l’en-tête de compte, sans ajouter de paramètres de requête account/org/project ni de champs de portée aux corps des requêtes. L’équipe a validé le flux Vibe avec l’authentification par clé API Harness (PAT/SAT) ; aucun paramètre d’activation n’est donc requis pour les sessions par défaut. Les documents OpenAPI sélectionnés décrivent l’authentification par bearer/session ; le mode OAuth du serveur transmet le jeton bearer de la session en cours. Les tests de régression automatisés vérifient les deux chemins d’en-tête ; l’authentification de la passerelle reste soumise à la configuration de l’environnement cible.

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
vibe_projectxprepare, deploy
vibe_app_lifecyclexevents

L’API prend en charge deux méthodes d’envoi. Conservez les formats de requête natifs de l’API :

Source accessible à l’agent de codageFlux API
Lien ou connecteur de dépôt GitHubharness_create avec resource_type="vibe_project" et body.mode, ainsi que les champs propres au mode. Le contrat nomme github_link et github_connector, mais ne définit pas le format de leurs champs d’URL, de branche ou de connecteur ; ces champs sont transmis au backend sans inventer de correspondance.
Fichier ZIPAppelez prepare avec le nom de l’application et les métadonnées du fichier, téléversez les octets vers la cible signée renvoyée, puis appelez deploy.
Répertoire source localL’agent de codage archive localement les sources de l’espace de travail souhaitées dans un fichier ZIP, puis suit le flux ZIP. Un chemin local ou le contexte conversationnel ne constitue pas une source de téléversement prise en charge par l’API.

Lors de l’empaquetage d’un répertoire, incluez les sources, les manifestes, les fichiers de verrouillage, la configuration et les modifications non validées prévues qui sont nécessaires à la compilation. Excluez les identifiants, .git, les dépendances installées et les artefacts générés. L’empaquetage et le téléversement signé ont lieu là où les fichiers sont accessibles ; un serveur MCP hébergé ne peut pas lire le répertoire local de l’agent de codage.

Pour un fichier ZIP existant, préparez le téléversement :

{
  "resource_type": "vibe_project",
  "action": "prepare",
  "body": {
    "name": "demo-app",
    "file": {
      "path": "app.zip",
      "size_bytes": 12345,
      "content_type": "application/zip"
    }
  }
}

Transmettez ces informations à harness_execute. La taille doit correspondre à celle du fichier ZIP réel ; size_bytes, content_type et md5 sont facultatifs et peuvent être nuls. Les champs de préparation supplémentaires sont conservés pour la validation du backend, dans la mesure permise par l’OpenAPI. La préparation renvoie projectId, sourceId et upload, notamment le uploadUrl, le method, le headers et le expiresAt de chaque fichier. Téléversez directement les octets du fichier à l’aide de cette URL signée, de cette méthode et de ces en-têtes ; conservez l’URL à l’identique et n’ajoutez pas d’identifiants Harness à la requête de stockage. L’action de préparation ne lit ni ne téléverse les fichiers locaux.

Une fois le téléversement réussi, lancez explicitement le déploiement :

{
  "resource_type": "vibe_project",
  "action": "deploy",
  "resource_id": "<projectId returned by prepare>"
}

Pour les imports JSON, utilisez plutôt le id renvoyé. Le déploiement accepte également body: {"project_id": "<Vibe app id>"} ou params.app_id ; le champ transmis par l’API est en snake_case, project_id, même si la préparation renvoie projectId en camelCase. Le champ de premier niveau project_id de l’outil générique est un identifiant de portée Harness et n’est jamais utilisé comme identifiant d’application Vibe. L’import et la préparation créent l’application/la source ; aucun des deux ne lance le déploiement. Les écritures ne font pas l’objet de nouvelles tentatives automatiques, et le déploiement applique la politique de confirmation existante pour les opérations à haut risque.

Consultez la progression avec harness_get(resource_type="vibe_app_lifecycle", resource_id="<Vibe app id>"). Cette ressource conserve les URL des applications, les étapes d’exécution, les sous-étapes, les échecs, les lignes de journal et les détails de l’analyseur de compilation. L’action d’exécution events accepte resource_id ou params.app_id et consomme le point de terminaison SSE sous forme de lot fini : jusqu’à 20 événements JSON ou cinq secondes après la connexion, avec une limite de réponse de 1 MiB. Ces limites s’appliquent au point de terminaison Vibe. Le HARNESS_API_TIMEOUT_MS de la connexion limite également la durée totale de la connexion et de la consommation du flux ; son expiration renvoie une erreur de délai d’attente. Un lot terminé renvoie events et stop_reason (end, event_limit ou duration_limit), puis ferme le flux. Ni les échecs de connexion initiaux ni les interruptions de flux ne font l’objet de nouvelles tentatives. Les événements sont des différences temporaires sans curseur de reprise documenté ; utilisez la lecture de l’état du cycle de vie pour obtenir un instantané faisant autorité. Les deux lectures du cycle de vie sont disponibles en mode lecture seule.

Indicateurs de fonctionnalité

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
fme_workspacex
fme_environmentxxxxx
fme_feature_flagxxxxxkill, restore, reallocate, archive, unarchive
fme_feature_flag_definitionxxxxxkill, restore, reallocate
fme_rollout_statusx
fme_rule_based_segmentxxxx
fme_rule_based_segment_definitionxxenable, disable, change_request
fme_traffic_typex
fme_identityxx
fme_standard_segmentxx
fme_segment_keysxx
fme_segmentxxxxx
fme_segment_definitionxxxxxlist_keys, add_keys, remove_keys
fme_metricxxxxx
fme_event_typexx
fme_experimentxxxxx
fme_experiment_settingsxxx
fme_experiment_alertingxx
fme_experiment_resultx

Ressources FME (Split.io) — les ressources fme_* prennent en charge la portée à double mode : les appels hérités transmettent workspace_id et utilisent l’API Split.io (api.split.io) ; les appels plus récents transmettent ensemble org_id+project_id et utilisent à la place les points de terminaison natifs de Harness (HARNESS_API_KEY/HARNESS_BASE_URL standard, avec la même authentification que toutes les autres ressources harness_*). Transmettre à la fois workspace_id et org_id/project_id dans le même appel, ou combiner org_id avec project_id seul, constitue une erreur — choisissez un seul mode par appel. Toutes les opérations ci-dessous sont disponibles en mode hérité, sans changement, sauf si la ressource est indiquée comme étant réservée à Harness. La couverture du mode natif Harness est actuellement plus limitée :

  • fme_workspace — aucun équivalent natif Harness ; réservé à l’ancien mode (utilisé pour découvrir les valeurs workspace_id).

  • fme_environment — list à double mode (workspace_id ou org_id+project_id). get/create/update/delete sont uniquement natifs Harness (/fme/api/v4/environments) — MCP n’a jamais eu de contrat workspace_id pour ces opérations. La liste native utilise les paramètres facultatifs offset/limit (maximum 100 ; harness_list size correspond à limit) ; l’enveloppe {data, limit, offset, totalCount} est promue en items/total. La création et la mise à jour natives utilisent isProduction (production est accepté comme alias). La mise à jour native utilise JSON Merge Patch ; name et isProduction ne peuvent pas être effacés. Nom limité à 15 caractères.

  • fme_feature_flag — double mode, les deux branches sont entièrement câblées. Mode natif Harness (org_id+project_id) : list/get/create/delete appellent /fme/api/v4/feature-flags (corps pour create : name, trafficType, facultatifs description/tags/owners, selon CreateFeatureFlagRequest) ; update envoie un merge-patch à /fme/api/v4/feature-flags/{name} ; archive/unarchive appellent /fme/api/v4/feature-flags/{name}/archive|unarchive (comment facultatif uniquement — pas de title, selon ArchiveUnarchiveRequest) ; kill/restore/reallocate appellent /fme/api/v4/feature-flag-definitions/{name}/kill|restore|reallocate avec environment_id comme paramètre de requête (comment/title facultatifs, selon FeatureFlagDefinitionActionRequest).

  • fme_feature_flag_definition — get/create/update restent à double mode (workspace_id ou org_id+project_id). list/delete/kill/restore/reallocate sont uniquement natifs Harness (org_id+project_id) — MCP n’a jamais eu de contrat workspace_id pour ces opérations. La liste native exige feature_flag_name et utilise offset/limit (100 par défaut, maximum 100) ; elle ne prend pas environment_id. La suppression et l’exécution exigent environment_id. Kill/restore/reallocate correspondent aux mêmes actions que pour fme_feature_flag. Le corps des opérations get/create/update correspond à l’ancien mode (treatments, defaultTreatment, defaultRule, facultatifs rules/baselineTreatment/trafficAllocation/comment), avec en plus title facultatif en mode natif Harness. La mise à jour native utilise JSON Merge Patch.

  • fme_rollout_status — list à double mode. Transmettez org_id+project_id (recommandé) ou l’ancien workspace_id, désormais obsolète. La pagination native utilise offset/limit (maximum 100 ; harness_list size correspond à limit) ; les résultats sont promus en items/total. Chaque élément comporte id, name et, facultativement, description.

  • fme_rule_based_segment — (Obsolète — voir fme_segment.) Le mode natif Harness est rejeté pour toutes les opérations (list/get/create/delete) — utilisez plutôt fme_segment ; cette ressource prend uniquement en charge le contrat workspace_id de l’ancien mode.

  • fme_rule_based_segment_definition — (Obsolète — voir fme_segment_definition.) Le mode natif Harness est rejeté pour toutes les opérations/actions (list/update/enable/disable/change_request) — utilisez plutôt fme_segment_definition (aucun équivalent enable/disable/change_request n’y est disponible) ; cette ressource prend uniquement en charge le contrat workspace_id/environment_id de l’ancien mode.

  • fme_traffic_type — list à double mode. Transmettez org_id+project_id (recommandé) ou l’ancien workspace_id, désormais obsolète. La pagination native utilise offset/limit (maximum 100 ; harness_list size correspond à limit) ; les résultats sont promus en items/total. Chaque élément comporte id et name (pas de displayAttributeId).

  • fme_identity — create/update ne sont pas encore implémentés lorsque org_id+project_id sont transmis ensemble ; sinon, l’appel se poursuit normalement en mode ancien.

  • fme_standard_segment — obsolète. L’ancien workspace_id appelle toujours Split v2. Le mode natif Harness est rejeté — utilisez fme_segment.

  • fme_segment_keys — list/update restent en mode ancien (workspace_id / environment_id+segment_name). Le mode natif Harness (org_id+project_id) est rejeté — utilisez fme_segment_definition pour exécuter list_keys/add_keys/remove_keys.

  • fme_segment — mode natif uniquement (org_id+project_id). CRUD. list/get/update/delete exigent segment_type : STANDARD | LARGE | RULE_BASED. Corps de création : name, trafficType, segmentType ; facultatifs : description, tags, owners.

  • fme_segment_definition — mode natif uniquement. CRUD et exécution de list_keys/add_keys/remove_keys. La mise à jour porte uniquement sur la description. La suppression échoue avec hasDependents tant que des clés subsistent.

  • fme_metric — mode natif Harness uniquement (aucune prise en charge de l’ancien workspace_id). list/get/create/update/delete sont câblés à /fme/api/v4/metrics (list harness_list size correspond à limit). create exige spread, même si le CreateMetricRequest du backend le rend facultatif (valeur par défaut PER) — il s’agit d’un contrat plus strict uniquement côté MCP, car son omission modifie silencieusement la sémantique d’une métrique RATE. update est un JSON Merge Patch ; name/trafficType sont immuables et ne sont pas acceptés. delete est une suppression définitive (sans archivage/restauration) — classée destructive.

  • fme_event_type — mode natif Harness uniquement (aucune prise en charge de l’ancien workspace_id). Lecture seule : list/get sont câblés à /fme/api/v4/event-types ; id est le nom de l’événement. Seuls les types d’événements ayant enregistré des événements au cours des 30 derniers jours sont visibles ; get renvoie une erreur 404 pour un type d’événement hors du périmètre des types de trafic de l’espace de travail demandeur, ou inactif depuis plus de 30 jours. Filtres de liste : name (sous-chaîne), traffic_type (par ID ou nom), offset/limit (harness_list size correspond à limit). Utilisez cette ressource pour découvrir les véritables ID de types d’événements avant d’en référencer un dans le filtre baseEventTypes/filterEventType ou event_type_ids de fme_metric, plutôt que de deviner un ID.

  • fme_experiment — mode natif Harness uniquement (aucune prise en charge de l’ancien workspace_id). CRUD câblé à /fme/api/v4/experiments. list exige parent_type (FEATURE_FLAG, AI_CONFIG ; CONFIG renvoie 404) et cible par défaut les expériences ACTIVE, sauf si status est transmis. create exige environment_id (paramètre de requête) ainsi que parent/name/startAt/endAt/baselineTreatment/comparisonTreatments dans le corps ; le parent doit exister dans cet environnement. update est un JSON Merge Patch ; parent et environment ne peuvent pas être modifiés. delete est une suppression définitive — classée destructive. owners est facultatif lors de la création/mise à jour : chaque entrée est {type: "USER", id or email} ou {type: "GROUP", identifier}. rule (libellé de règle de ciblage auquel les résultats sont associés ; lors de la création, la valeur par défaut est "default" s’il est omis ; lors de la mise à jour, null l’efface) et tags ([{name}] ; lors de la mise à jour, remplace la liste ; null/[] l’efface) sont facultatifs lors de la création/mise à jour. list accepte un filtre de tableau tags (expériences comportant au moins un des noms de balise) ; les éléments incluent tags et rule.

  • fme_experiment_settings — paramètres statistiques et de surveillance d’une seule expérience (type de test, seuil de significativité, correction des comparaisons multiples, taille minimale de l’échantillon, période d’examen, réduction de la variance). get/update/delete uniquement — relation 1:1 avec l’expérience, sans list. get renvoie toujours les paramètres appliqués (remplacement propre à l’expérience ou valeurs par défaut de l’organisation) et ne renvoie jamais 404, sauf si l’expérience elle-même n’existe pas. update est un JSON Merge Patch et crée implicitement le remplacement au niveau de l’expérience. delete rétablit les valeurs par défaut de l’organisation (opération idempotente) — classé destructive, bien que non permanent.

  • fme_experiment_alerting — indique si une expérience est abonnée aux alertes de régression de significativité. get/update uniquement. get renvoie {id, isEnabled} et indique isEnabled: false lorsqu’aucune règle d’alerte n’existe ; il ne renvoie 404 que si l’expérience elle-même n’existe pas. update est un JSON Merge Patch avec un booléen isEnabled obligatoire.

  • fme_experiment_result — résultats évalués par métrique pour la dernière exécution de calcul d’une expérience. list uniquement (pas de get — les résultats n’ont pas d’identifiant propre). Une ligne par paire (métrique, traitement de comparaison) pour toutes les catégories de métriques. Filtres facultatifs : metric_ids, comparisons. Reflète uniquement la dernière exécution — aucun accès à l’historique.

En mode mono-utilisateur/autohébergé, l’authentification en mode ancien utilise un jeton Bearer provenant de HARNESS_FME_API_KEY, avec comme solution de repli un HARNESS_API_KEY qui n’est pas un espace réservé. HARNESS_FME_API_KEY peut être une clé d’administration Split héritée ou un PAT/SAT Harness avec droits FME, mais il est rejeté en mode multi-user afin que les déploiements partagés ne puissent pas remplacer les identifiants de chaque utilisateur de session. Les identifiants OAuth et de routage de service hébergés pour les API de la plateforme Harness n’authentifient pas les requêtes directes vers Split.io. fme_feature_flag prend en charge la gestion complète du cycle de vie en mode ancien : création (requiert traffic_type_id), liste, récupération, mise à jour des métadonnées, suppression et actions d’exécution kill/restore/reallocate/archive/unarchive. Utilisez fme_traffic_type pour découvrir les ID de types de trafic, fme_identity pour créer/mettre à jour les attributs d’identité, et fme_standard_segment / fme_segment_keys pour examiner les segments standard et ajouter des clés de membre. fme_rule_based_segment fournit les opérations CRUD pour les segments de ciblage, tandis que fme_rule_based_segment_definition gère les règles de segment propres à chaque environnement, avec activation/désactivation et processus d’approbation des demandes de modification.

GitOps

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
gitops_agentxx
gitops_agent_metricsx
gitops_argo_projectx
gitops_app_project_mappingxxxximport
gitops_autocreate_logx
gitops_applicationxxsync
gitops_clusterxx
gitops_repositoryxx
gitops_applicationsetxx
gitops_repo_credentialxx
gitops_app_eventx
gitops_pod_logx
gitops_managed_resourcex
gitops_resource_actionx
gitops_dashboardx
gitops_app_resource_treex
gitops_cluster_linkxxx

Ingénierie du chaos

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
chaos_experimentxxxxxrun, stop, list_metadata, update_cron
chaos_experiment_runx
chaos_experiment_variablex
chaos_component_variablex
chaos_input_setxxxxx
chaos_experiment_templatexxxxxcreate_from_template, list_revisions, get_variables, get_yaml, compare_revisions
chaos_probexxxxlist_metadata, enable, verify, get_manifest
chaos_probe_in_runx
chaos_probe_templatexxxxxget_variables
chaos_infrastructurexxxxx
chaos_k8s_infrastructurexxxxxcheck_health, get_yaml, get_manifest, helm_command
chaos_enabled_infrastructurex
chaos_environmentx
chaos_hubxxxxxlist_metadata
chaos_hub_faultx
chaos_faultxxxlist_metadata, get_variables, get_yaml
chaos_fault_templatexxxxxlist_revisions, get_variables, get_yaml, compare_revisions
chaos_fault_experiment_runx
chaos_actionxxxxxlist_metadata, get_manifest
chaos_action_templatexxxxxlist_revisions, get_variables, compare_revisions
chaos_loadtestxxxxxrun, stop, estimate_workers, convert_har
chaos_loadtest_runxxstatus, live_metrics, ai_insights, generate_ai_insights
chaos_servicexxxxxlist_experiment_runs, list_load_tests
custom_servicexxxx
chaos_application_mapxxx
discovered_agentx
discovered_namespacex
discovered_servicex
discovered_network_mapx
chaos_guard_conditionxxxxx
chaos_guard_rulexxxxxenable
chaos_recommendationxx
chaos_onboardingxxxxstats, confirm_discovery, onboard_services, confirm_service_onboarding, trigger_risk_scan, risk_scan, confirm_risk_scan, list_services, confirm_network_map, confirm_experiment_creation, confirm_experiment_run, skip, stop
chaos_pipeline_onboardingxxxxcan_onboard
chaos_riskxx
chaos_dr_testxx
scanned_riskxxoccurrences, summary_by_service
chaos_risk_rulexxxxx
chaos_risk_scanxxxxxretry, abort, report, report_download, heatmap, submit_findings
chaos_dashboardxxx
chaos_image_registryxxxresolve

Gestion des coûts cloud (CCM)

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
cost_perspectivexxxxx
cost_breakdownx
cost_timeseriesx
cost_summaryxx
cost_recommendationxxupdate_state, override_savings, create_jira_ticket, create_snow_ticket
cost_anomalyx
cost_anomaly_summaryx
cost_categoryxx
cost_account_overviewx
cost_filter_valuex
cost_recommendation_statsx
cost_recommendation_detailx
cost_commitmentx
ai_budgetxxxxx
ai_budget_overviewx
ai_budget_consumptionx
ai_budget_override_requestxxxapprove, reject

Informations sur l'ingénierie logicielle (SEI)

Les ressources SEI sont regroupées pour optimiser l'utilisation des jetons. Utilisez les paramètres metric ou aspect pour les données DORA, les détails de l'équipe/de l'arborescence organisationnelle et les informations sur l'IA.

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
sei_metricx
sei_productivity_metricx
sei_dora_metricxPasser metric : deployment_frequency, change_failure_rate, mttr, lead_time ou *_drilldown
sei_teamxx
sei_team_detailxPasser aspect : integrations, developers, integration_filters
sei_org_treexx
sei_org_tree_detailxxPasser aspect : efficiency_profile, productivity_profile, business_alignment_profile, integrations, teams
sei_business_alignmentxxPasser aspect : feature_metrics, feature_summary, drilldown pour get
sei_ai_usagexxPasser aspect : metrics, breakdown, summary, top_languages
sei_ai_adoptionxxPasser aspect : metrics, breakdown, summary
sei_ai_impactxPasser aspect : pr_velocity, rework
sei_ai_raw_metricx

Assurance de la chaîne d’approvisionnement logicielle (SCS)

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
scs_artifact_sourcex
artifact_securityxx
scs_artifact_componentx
scs_artifact_remediationx
scs_chain_of_custodyx
scs_compliance_resultx
code_repo_securityxx
scs_sbomx

Coffre-fort de preuves

Evidence Vault stocke les attestations in-toto (preuves SDLC). La liste prend en charge les portées compte/organisation/projet via resource_scope. Les filtres de texte libre singuliers (pipeline, artifact seul, gitoid) utilisent search_term ; une contrainte Name supplémentaire utilise filters.subject_name ; le condensat du contenu du sujet utilise filters.subject_digest. La récupération recherche par gitoid_sha256 et nécessite org_id/project_id (depuis la ligne de la liste). Le téléchargement (action download de harness_execute) renvoie un download_url à durée limitée — affichez toujours ce lien à l’utilisateur. Nécessite l’indicateur de fonctionnalité SCS_EVIDENCE_VAULT.

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
attestationxxdownload

Orchestration des tests de sécurité (STO)

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
security_issuex
security_issue_filterx
security_exemptionxxapprove, reject
remediation_diffx

La création de security_exemption est une opération high_write. Le serveur déduit requester_id du PAT authentifié, définit exemptFutureOccurrences=true et attribue par défaut la valeur 30 à duration_days si elle n’est pas fournie. Pour répertorier les exemptions, transmettez une petite taille de page explicite (par exemple filters: { "status": "Pending", "size": 5 }) et suivez le _nextPageHint renvoyé dans chaque réponse.

Flux d’exécution des exemptions de sécurité :

  • Utilisez harness_list avec resource_type="security_exemption" et un status explicite, tel que Pending, Approved, Rejected, Expired ou Canceled.
  • Utilisez harness_execute avec action="approve" et un body.scope obligatoire : CURRENT, ACCOUNT, ORG ou PROJECT. CURRENT approuve l’exemption à sa portée existante ; les autres portées utilisent en interne le point de terminaison de promotion STO. Si body.approver_id est omis, le serveur le renseigne automatiquement à partir de l’utilisateur authentifié ; body.comment est facultatif.
  • Utilisez action="reject" pour rejeter une exemption. Si body.approver_id est omis, il est également renseigné automatiquement.
  • Il n’existe pas d’action d’exécution promote distincte. Utilisez action="approve" avec un body.scope différent de CURRENT lorsque le résultat demandé est une approbation à la portée du compte, de l’organisation ou du projet.

Contrôle d’accès

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
userxx
user_groupxxxxx
service_accountxxxx
rolexxxx
role_assignmentxx
resource_groupxxxx
permissionx

Gouvernance

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
policyxxxxx
policy_setxxxxx
policy_evaluationxx

Gel des déploiements

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
freeze_windowxxxxxtoggle_status
global_freezexmanage

Remplacements de service

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
service_overridexxxxx

Paramètres

Type de ressourceListerObtenirCréerMettre à jourSupprimerExécuter des actions
settingx

Prompts MCP

DevOps

PromptDescriptionParamètres
build-deploy-appFlux de travail CI/CD de bout en bout : analyser un dépôt git, générer un pipeline CI (compiler et envoyer une image Docker), découvrir ou générer des manifestes K8s, créer un pipeline CD et effectuer le déploiement — avec des tentatives automatiques en cas d’échec de la CI (jusqu’à 5 tentatives) et de la CD (jusqu’à 3 tentatives avec l’autorisation de l’utilisateur). Si les tentatives sont épuisées, fournit des liens profonds vers l’interface Harness pour toutes les ressources créées afin de faciliter l’analyse manuelle.repoUrl (obligatoire), imageName (obligatoire), projectId (facultatif), namespace (facultatif)
debug-pipeline-failureAnalyser une exécution ayant échoué : accepte un ID d’exécution, un ID de pipeline ou une URL Harness. Récupère la répartition des étapes et des tâches, les détails de l’échec, les informations sur le délégué et les journaux de l’étape ayant échoué via harness_diagnose, puis fournit une analyse de la cause racine et des correctifs suggérés. Suit automatiquement les échecs des pipelines en chaîne.executionId (facultatif), projectId (facultatif)
pipeline_summarizerRécupérer et résumer TOUS les journaux des tâches d’une exécution de pipeline. Utilise harness_diagnose avec include_logs: true, include_all_step_logs: true pour récupérer le journal de chaque tâche, puis présente un tableau indiquant le nom de l’étape, son état, sa durée et ce qui s’est passé (résumé basé sur les journaux). N’ignore AUCUNE étape.executionId (facultatif), projectId (facultatif)
create-pipelineGénérer un nouveau YAML de pipeline à partir d’exigences en langage naturel, en examinant les ressources existantes pour obtenir du contextedescription (obligatoire), projectId (facultatif)
create-agentCréer de manière interactive un agent IA Harness — vérifier les agents existants (en détectant le format de spécification actuel agent.uses ou le format hérité agent.step.group.steps lors d’une mise à jour), recueillir les exigences, générer la spécification de l’agent au format approprié, la confirmer avec l’utilisateur, puis créer ou mettre à jour via harness_create/harness_updateagent_name (obligatoire), task_description (obligatoire), org_id (facultatif), project_id (facultatif)
onboard-serviceAccompagner l’intégration d’un nouveau service avec ses environnements et un pipeline de déploiementserviceName (obligatoire), projectId (facultatif)
dora-metrics-reviewExaminer les métriques DORA (fréquence de déploiement, taux d’échec des changements, MTTR, délai de mise en production) avec une classification Elite/High/Medium/Low et des recommandations d’améliorationteamRefId (facultatif), dateStart (facultatif), dateEnd (facultatif)
setup-gitops-applicationAccompagner l’intégration d’une application GitOps — vérifier l’agent, le cluster et le dépôt, puis créer l’applicationagentId (obligatoire), projectId (facultatif)
chaos-resilience-testConcevoir une expérience de chaos pour tester la résilience d’un service à l’aide d’injections de pannes, de sondes et de résultats attendusserviceName (obligatoire), projectId (facultatif)
feature-flag-rolloutPlanifier et exécuter le déploiement progressif d’un indicateur de fonctionnalité dans plusieurs environnements, avec des garde-fousflagIdentifier (obligatoire), projectId (facultatif)
migrate-pipeline-to-templateAnalyser un pipeline existant et en extraire des modèles réutilisables d’étapes et de tâchespipelineId (obligatoire), projectId (facultatif)
delegate-health-checkVérifier la connectivité et l’état du délégué, ainsi que le statut du jeton, et résoudre les problèmes d’infrastructureprojectId (facultatif)
developer-portal-scorecardExaminer les tableaux de bord IDP des services et repérer les lacunes à combler pour améliorer l’expérience des développeursprojectId (facultatif)
pending-approvalsTrouver les exécutions de pipeline en attente d’approbation, afficher les détails et proposer d’approuver ou de rejeterprojectId (facultatif), orgId (facultatif), pipelineId (facultatif)

FinOps

PromptDescriptionParamètres
optimize-costsAnalyser les données de coûts du cloud, faire ressortir les recommandations et les anomalies, classées selon les économies potentiellesprojectId (facultatif)
cloud-cost-breakdownAnalyser en détail les coûts du cloud par service, environnement ou cluster, avec analyse des tendances et détection des anomaliesperspectiveId (facultatif), projectId (facultatif)
commitment-utilization-reviewAnalyser l’utilisation des instances réservées et des plans d’économies afin de repérer le gaspillage et d’optimiser les engagementsprojectId (facultatif)
cost-anomaly-investigationExaminer les anomalies de coûts — déterminer la cause racine, les ressources touchées et les mesures correctivesprojectId (facultatif)
rightsizing-recommendationsExaminer et hiérarchiser les recommandations de dimensionnement adapté, avec la possibilité de créer des tickets Jira ou ServiceNowprojectId (facultatif), minSavings (facultatif)

DevSecOps

PromptDescriptionParamètres
security-reviewExaminer les problèmes de sécurité dans les ressources Harness et suggérer des mesures correctives selon leur gravitéprojectId (facultatif), severity (facultatif, par défaut : critical,high)
vulnerability-triageTrier les vulnérabilités de sécurité dans les pipelines et les artefacts, et les hiérarchiser selon leur gravité et leur exploitabilitéprojectId (facultatif), severity (facultatif)
sbom-compliance-checkAuditer la nomenclature logicielle (SBOM) et la conformité des artefacts — risques liés aux licences, violations des politiques et vulnérabilités des composantsartifactId (facultatif), projectId (facultatif)
supply-chain-auditAudit de bout en bout de la sécurité de la chaîne d’approvisionnement logicielle — provenance, chaîne de traçabilité et conformité aux politiquesprojectId (facultatif)
security-exemption-reviewExaminer les dérogations de sécurité en attente et prendre des décisions d’approbation ou de rejet par lotprojectId (facultatif)
bulk-exemption-createCréer des dérogations de sécurité justifiées pour plusieurs problèmes STO, avec des indications précises sur la portée et la duréeprojectId (obligatoire), exemption_type (obligatoire), reason (obligatoire), filtres de problèmes (facultatif)
access-control-auditAuditer les autorisations des utilisateurs, les comptes trop privilégiés et les attributions de rôles afin d’appliquer le principe du moindre privilègeprojectId (facultatif), orgId (facultatif)

Harness Code

PromptDescriptionParamètres
code-reviewExaminer une pull request — analyser le diff, les commits, les vérifications et les commentaires afin de fournir des retours structurés sur les bogues, la sécurité, les performances et le stylerepoId (obligatoire), prNumber (obligatoire), projectId (facultatif)
pr-summaryGénérer automatiquement un titre et une description de PR à partir de l’historique des commits et du diff d’une brancherepoId (obligatoire), sourceBranch (obligatoire), targetBranch (facultatif, par défaut : main), projectId (facultatif)
branch-cleanupAnalyser les branches d’un dépôt et recommander la suppression des branches obsolètes ou fusionnéesrepoId (obligatoire), projectId (facultatif)

Ressources MCP

URI de ressourceDescriptionType MIME
pipeline:///{pipelineId}Définition YAML du pipelineapplication/x-yaml
pipeline:///{orgId}/{projectId}/{pipelineId}YAML du pipeline (avec portée explicite)application/x-yaml
executions:///recentRésumés des 10 dernières exécutions du pipelineapplication/json
schema:///pipelineSchéma JSON du pipeline Harnessapplication/schema+json
schema:///templateSchéma JSON du modèle Harnessapplication/schema+json
schema:///triggerSchéma JSON du déclencheur Harnessapplication/schema+json
schema:///pipeline_v1 (Alpha)Schéma JSON du pipeline Harness V1 (format simplifié des étapes et des actions)application/schema+json
schema:///agent-pipelineSchéma JSON du pipeline d’agent IA Harnessapplication/schema+json
agent-docs:///legacy-formatRéférence du format de spécification d’agent hérité (agent.step.group.steps / PLUGIN_TASK), lue par l’invite create-agent lors de la mise à jour d’un agent existant au format héritétext/markdown

Filtrage des ensembles d’outils

Par défaut, 44 ensembles d’outils sur 50 sont activés. Cinq ensembles d’outils sont activables à la demande et exclus des paramètres par défaut :

  • ansible — Harness Ansible (inventaires, playbooks, hôtes, activité). Activable à la demande, car sa portée est limitée au projet et il introduit des concepts dont de nombreux utilisateurs n’ont pas besoin.
  • appsec — Sécurité des applications et des API Traceable (inventaire des API, spécifications OpenAPI, exemples de spans, types de données sensibles, activités de menaces à l’exécution, événements de sécurité, analyses AST et tendances de l’inventaire). Activable à la demande, car il nécessite un HARNESS_APPSEC_API_KEY dédié et cible api.traceable.ai.
  • autonomous_work — Harness Development Harness (travail autonome). Activable à la demande ; consultez la description de l’ensemble d’outils pour connaître sa portée.
  • observability-evaluations — Règles d’évaluation planifiée de la télémétrie de production. Activable à la demande, car il dépend du plan de contrôle de notation déployé.
  • unified-search — Recherche sémantique dans toutes les sources desservies par le service de recherche. Activable à la demande, car le backend n’est pas déployé sur tous les clusters et la fonctionnalité est activée par indicateur pour chaque compte (voir Recherche unifiée).
  • registries-v3 — Registre d’artefacts Harness v3 (packages, versions, fichiers, métadonnées, analyses, exceptions de pare-feu). Activable à la demande jusqu’à la mise en place des écritures v3, afin que les agents n’aient pas à distinguer les registres/artefacts v1 des packages/versions v3.

Ajouter des ensembles d’outils avec le préfixe +

Utilisez le préfixe + pour inclure explicitement les ensembles d’outils activables à la demande, en plus de tous les ensembles par défaut :

# Explicitly include Ansible alongside all defaults
HARNESS_TOOLSETS=+ansible

Supprimer des ensembles d’outils par défaut

Utilisez le préfixe - pour exclure les ensembles d’outils dont vous n’avez pas besoin :

# Remove chaos and ccm from defaults
HARNESS_TOOLSETS=-chaos,-ccm

Combiner + et -

# Add Ansible, remove chaos
HARNESS_TOOLSETS=+ansible,-chaos

Liste d’autorisation explicite

Une liste explicite séparée par des virgules (sans préfixes) remplace entièrement les paramètres par défaut. Seuls les ensembles d’outils répertoriés sont activés :

# Only expose pipelines, services, and connectors
HARNESS_TOOLSETS=pipelines,services,connectors

Noms d’ensembles d’outils disponibles :

Ensemble d’outilsTypes de ressources
platformorganization, project
pipelinespipeline, pipeline_v1, pipeline_dynamic_execution, execution, execution_inputs, trigger, pipeline_summary, input_set, approval_instance, runtime_input_template, pipeline_resolved_yaml, runtime_input_template_v1
agentsagent
servicesservice
environmentsenvironment
connectorsconnector, connector_catalogue, llm_model
infrastructureinfrastructure
secretssecret
logsexecution_log
auditaudit_event
delegatesdelegate, delegate_token
repositoriesrepository, branch, commit, file_content, tag, repo_rule, space_rule
registriesregistry, artifact, artifact_version, artifact_file, quarantine
registries-firewallartifact_scan, bulk_scan_evaluation, firewall_exception, firewall_exception_version
file_storefile_store
templatestemplate, template_v1
dashboardsdashboard, dashboard_data
idpidp_entity, scorecard, scorecard_check, scorecard_stats, scorecard_check_stats, idp_score, idp_score_summary, idp_workflow, idp_tech_doc
pull-requestspull_request, pr_reviewer, pr_comment, pr_check, pr_activity
feature-flagsfme_workspace, fme_environment, fme_feature_flag, fme_feature_flag_definition, fme_rollout_status, fme_rule_based_segment, fme_rule_based_segment_definition, fme_traffic_type, fme_identity, fme_standard_segment, fme_segment_keys, fme_segment, fme_segment_definition, fme_metric, fme_event_type, fme_experiment, fme_experiment_settings, fme_experiment_alerting, fme_experiment_result
gitopsgitops_agent, gitops_agent_metrics, gitops_argo_project, gitops_app_project_mapping, gitops_autocreate_log, gitops_application, gitops_cluster, gitops_repository, gitops_applicationset, gitops_repo_credential, gitops_app_event, gitops_pod_log, gitops_managed_resource, gitops_resource_action, gitops_dashboard, gitops_app_resource_tree, gitops_cluster_link
chaoschaos_experiment, chaos_experiment_run, chaos_experiment_variable, chaos_component_variable, chaos_input_set, chaos_experiment_template, chaos_probe, chaos_probe_in_run, chaos_probe_template, chaos_infrastructure, chaos_k8s_infrastructure, chaos_enabled_infrastructure, chaos_environment, chaos_hub, chaos_hub_fault, chaos_fault, chaos_fault_template, chaos_fault_experiment_run, chaos_action, chaos_action_template, chaos_loadtest, chaos_loadtest_run, chaos_service, custom_service, chaos_application_map, discovered_agent, discovered_namespace, discovered_service, discovered_network_map, chaos_guard_condition, chaos_guard_rule, chaos_recommendation, chaos_onboarding, chaos_pipeline_onboarding, chaos_risk, chaos_dr_test, scanned_risk, chaos_risk_rule, chaos_risk_scan, chaos_dashboard, chaos_image_registry
ccmcost_perspective, cost_perspective_folder, cost_breakdown, cost_timeseries, cost_summary, cost_recommendation, cost_anomaly, cost_anomaly_drilldown, cost_anomaly_summary, cost_budget, cost_budget_variance, cost_budget_group, cost_category, cost_account_overview, cost_filter_value, cost_recommendation_filter, cost_recommendation_count, cost_recommendation_stats, cost_recommendation_detail, cost_commitment, unit_metric, ai_budget, ai_budget_overview, ai_budget_consumption, ai_budget_override_request
seisei_metric, sei_productivity_metric, sei_dora_metric, sei_team, sei_team_detail, sei_org_tree, sei_org_tree_detail, sei_business_alignment, sei_ai_usage, sei_ai_adoption, sei_ai_impact, sei_ai_raw_metric
scsscs_artifact_source, artifact_security, scs_artifact_component, scs_component_search, scs_component_dependencies, scs_artifact_remediation, scs_chain_of_custody, scs_compliance_result, scs_bom_violation, code_repo_security, scs_component_remediation, scs_remediation_pr, scs_auto_pr_config, scs_component_enrichment, scs_component_vulnerability, scs_oss_risk_summary, scs_project_security_overview, scs_sbom_drift, scs_component_drift, scs_sbom
evidence-vaultattestation
stosecurity_issue, security_issue_filter, pipeline_security_issue, pipeline_security_step, security_exemption, security_exemption_bulk, remediation_diff
dbopsdatabase_schema, database_instance, database_snapshot_object, database_changeset_existence, database_default_authoring_instance, database_llm_authoring_pipeline, database_execute_llm_authoring_pipeline
autonomous_work (opt-in)work_item, work_timeline, work_budget, work_phase, work_phase_artifact, work_artifact, budget, budget_usage, work_class, work_trigger, capability, risk_evaluator, team, member, member_template, software_component, content_source_connector
access_controluser, user_group, service_account, role, role_assignment, resource_group, permission
governancepolicy, policy_set, policy_evaluation
freezefreeze_window, global_freeze
overridesservice_override
settingssetting
knowledge-graphkg_queryable_type_summary, kg_grammar, hql_query
semantic-layerkg_type, kg_related_type
unified-search (opt-in)unified_search, unified_search_source
ai-evalseval_dataset, eval_dataset_item, evaluation, eval_run, eval_run_item, eval_run_by_eval, eval_metric, eval_metric_set, eval_metric_set_entry, eval_suite, eval_suite_evaluation, eval_suite_run, eval_target, eval_annotation, eval_analytics, eval_git_settings, eval_git_registration, eval_prompt, online_eval
observability-evaluations (opt-in)observability_eval
iacmiacm_workspace, iacm_variable_set, iacm_resource, iacm_module, iacm_provider, iacm_workspace_costs, iacm_activity_resource_change
ansible (opt-in)ansible_inventory, ansible_playbook, ansible_host, ansible_host_activity, ansible_activity
registries-v3 (opt-in)package, package_version, package_file, registry_metadata, package_metadata, version_metadata, file_metadata, metadata_key, metadata_value
incidentsincident
alertsalert
deploysdeploy
runbooksrunbook, runbook_execution
release-managementrelease_process, release_activity, release, release_execution_phase, release_execution_task, release_execution_activity, release_input, release_execution_phase_input, release_execution_phase_output, release_execution_activity_input, release_execution_activity_output
vibevibe_project, vibe_app_lifecycle
timelinesactivity_timeline
appsec (opt-in)appsec_api, appsec_api_spec, appsec_api_span, appsec_entity, appsec_vulnerability, appsec_threat_activity, appsec_security_event, appsec_ast_scan, appsec_inventory_trend, appsec_datatype

Architecture

                 +------------------+
                 |   AI Agent       |
                 |  (Claude, etc.)  |
                 +--------+---------+
                          |  MCP (stdio or HTTP)
                 +--------v---------+
                |    MCP Server     |
                | 11 Generic Tools  |
                 +--------+---------+
                          |
                 +--------v---------+
                |    Registry       |  <-- Declarative resource definitions
                | 50 Toolsets (44 default) |
                |  274 Resource Types|
                 +--------+---------+
                          |
                 +--------v---------+
                 |  HarnessClient    |  <-- Auth, retry, rate limiting
                 +--------+---------+
                          |  HTTPS
                 +--------v---------+
                 |  Harness REST API |
                 +-------------------+

Fonctionnement

  1. Les outils sont des verbes génériques : harness_list, harness_get, etc. Ils acceptent un paramètre resource_type qui les dirige vers le point de terminaison d’API approprié.
  2. Le registre associe chaque resource_type à un ResourceDefinition — une structure de données déclarative qui spécifie la méthode HTTP, le chemin d’URL, les correspondances des paramètres de chemin et de requête, ainsi que la logique d’extraction de la réponse.
  3. La distribution résout la définition de la ressource, construit la requête HTTP (substitution du chemin, paramètres de requête, injection du compte/de l’organisation/du projet tenant compte de resource_scope), appelle l’API Harness via HarnessClient et extrait les données de réponse pertinentes.
  4. Le filtrage des ensembles d’outils (HARNESS_TOOLSETS) détermine quelles définitions de ressources sont chargées dans le registre au démarrage.
  5. La sortie structurée est déclarée avec MCP outputSchema ; harness_list convertit les tableaux et les enveloppes de listes courantes en structuredContent de forme objet pour les clients stricts.
  6. Les liens profonds sont automatiquement ajoutés aux réponses et fournissent des URL directes vers l’interface utilisateur Harness pour chaque ressource.
  7. Le mode compact supprime les métadonnées détaillées des résultats de liste et ne conserve que les champs exploitables (identité, état, type, horodatages, liens profonds) afin de réduire au minimum l’utilisation de jetons.

Ajouter un nouveau type de ressource

Créez un nouveau fichier dans src/registry/toolsets/ ou ajoutez une ressource à un ensemble d’outils existant :

// src/registry/toolsets/my-module.ts
import type { ToolsetDefinition } from "../types.js";

export const myModuleToolset: ToolsetDefinition = {
  name: "my-module",
  displayName: "My Module",
  description: "Description of the module",
  resources: [
    {
      resourceType: "my_resource",
      displayName: "My Resource",
      description: "What this resource represents",
      toolset: "my-module",
      scope: "project",                    // "project" | "org" | "account"
      identifierFields: ["resource_id"],
      listFilterFields: ["search_term"],
      operations: {
        list: {
          method: "GET",
          path: "/my-module/api/resources",
          queryParams: { search_term: "search", page: "page", size: "size" },
          responseExtractor: (raw) => raw,
          description: "List resources",
        },
        get: {
          method: "GET",
          path: "/my-module/api/resources/{resourceId}",
          pathParams: { resource_id: "resourceId" },
          responseExtractor: (raw) => raw,
          description: "Get resource details",
        },
      },
    },
  ],
};

Importez-la ensuite dans src/registry/index.ts et ajoutez-la au tableau ALL_TOOLSETS. Aucune modification des fichiers d’outils n’est nécessaire.

Développement

# Build
pnpm build

# Watch mode
pnpm dev

# Type check
pnpm typecheck

# Run tests
pnpm test

# Watch tests
pnpm test:watch

# Interactive MCP Inspector
pnpm inspect

# Refresh generated README counts from the built registry
pnpm docs:generate

# Verify README counts and clone instructions are current
pnpm docs:check

# Sync and verify JSON Schemas used by harness_schema
pnpm sync-schemas
pnpm check-schema-coverage

Structure du projet

src/
  index.ts                          # Entrypoint, transport setup
  config.ts                         # Env var validation (Zod)
  client/
    harness-client.ts               # HTTP client (auth, retry, rate limiting)
    types.ts                        # Shared API types
  registry/
    index.ts                        # Registry class + dispatch logic
    types.ts                        # ResourceDefinition, ToolsetDefinition, etc.
    toolsets/                        # One file per toolset (declarative data)
      platform.ts
      pipelines.ts
      services.ts
      ccm.ts
      access-control.ts
      ...
  tools/                            # 11 generic MCP tools
    harness-list.ts
    harness-get.ts
    harness-create.ts
    harness-update.ts
    harness-delete.ts
    harness-execute.ts
    harness-search.ts
    harness-diagnose.ts
    harness-describe.ts
    harness-status.ts
    harness-schema.ts

  resources/                        # MCP resource providers
    pipeline-yaml.ts
    execution-summary.ts
  prompts/                          # MCP prompt templates
    build-deploy-app.ts             # DevOps: end-to-end build & deploy workflow
    debug-pipeline.ts               # DevOps: debug failed executions
    create-pipeline.ts              # DevOps: generate pipeline from requirements
    onboard-service.ts              # DevOps: onboard new service
    dora-metrics.ts                 # DevOps: DORA metrics review
    setup-gitops.ts                 # DevOps: GitOps application setup
    chaos-resilience.ts             # DevOps: chaos experiment design
    feature-flag-rollout.ts         # DevOps: progressive flag rollout
    migrate-to-template.ts          # DevOps: extract templates from pipeline
    delegate-health.ts              # DevOps: delegate health check
    developer-scorecard.ts          # DevOps: IDP scorecard review
    optimize-costs.ts               # FinOps: cost optimization
    cloud-cost-breakdown.ts         # FinOps: cost deep-dive
    commitment-utilization.ts       # FinOps: RI/savings plan analysis
    cost-anomaly.ts                 # FinOps: anomaly investigation
    rightsizing.ts                  # FinOps: rightsizing recommendations
    security-review.ts              # DevSecOps: security issue review
    vulnerability-triage.ts         # DevSecOps: vulnerability triage
    sbom-compliance.ts              # DevSecOps: SBOM compliance audit
    supply-chain-audit.ts           # DevSecOps: supply chain audit
    exemption-review.ts             # DevSecOps: exemption approval
    access-control-audit.ts         # DevSecOps: access control audit
    code-review.ts                  # Harness Code: PR code review
    pr-summary.ts                   # Harness Code: auto-generate PR summary
    branch-cleanup.ts               # Harness Code: stale branch cleanup
    pending-approvals.ts            # Approvals: find and act on pending approvals
  utils/
    cli.ts                          # CLI arg parsing (transport, port)
    errors.ts                       # Error normalization
    logger.ts                       # stderr-only logger
    progress.ts                     # MCP progress & logging notifications
    rate-limiter.ts                 # Client-side rate limiting
    deep-links.ts                   # Harness UI deep link builder
    response-formatter.ts           # Consistent MCP response formatting
    compact.ts                      # Compact list output for token efficiency
tests/
  config.test.ts                    # Config schema validation tests
  utils/
    response-formatter.test.ts
    deep-links.test.ts
    errors.test.ts
  registry/
    registry.test.ts                # Registry loading, filtering, dispatch tests

Sollicitation de confirmation

Les outils d’écriture (harness_create, harness_update, harness_delete, harness_execute) utilisent la sollicitation de confirmation MCP pour demander confirmation à l’utilisateur lorsque le niveau de risque de l’action l’exige — uniquement pour les opérations medium_write, high_write et destructive. Les créations, mises à jour et lectures à faible risque (par exemple, pipeline.create, pipeline.update, hql_query.run) s’effectuent sans invite. Lorsqu’une invite s’affiche, l’utilisateur voit ce qui va se passer et accepte ou refuse, ce qui garantit une véritable approbation humaine pour les opérations qui modifient ou exécutent effectivement quelque chose.

Fonctionnement :

  1. Le LLM appelle un outil d’écriture présentant un risque medium_write+ (par exemple, harness_delete, harness_execute pipeline.run). Les créations, mises à jour et lectures à faible risque ne déclenchent pas d’invite.
  2. Le serveur envoie au client une demande de sollicitation de confirmation contenant un résumé de l’opération et une case à cocher confirm (cochée par défaut).
  3. L’utilisateur consulte les détails et clique sur Accepter (avec confirm coché) ou sur Refuser / Annuler.
  4. Si l’utilisateur accepte avec confirm: true, l’opération se poursuit. Si l’utilisateur accepte avec confirm décoché, refuse ou annule, l’opération est bloquée et le LLM en est informé (un refus explicite fait autorité et ne peut pas être contourné par confirm: true dans l’appel de l’outil).

Prise en charge par les clients :

ClientPrise en charge de la sollicitation de confirmation
CursorOui
VS Code (Copilot)Oui
Claude DesktopPas encore
Devin DesktopPas encore
MCP InspectorOui

Le comportement de la sollicitation de confirmation varie selon le risque de l’opération lorsque le client ne la prend pas en charge :

Niveau de risqueLe client prend en charge la sollicitation de confirmationconfirm: true transmisComportement
read, low_writequelconquequelconquePoursuite sans invite — aucune invite ne s’affiche (confirm n’a aucun effet à ce niveau de risque)
medium_write, high_write, destructiveOuiquelconqueDemande de confirmation à l’utilisateur. Poursuite uniquement si l’utilisateur accepte avec confirm: true (valeur par défaut du schéma). Un refus explicite, une annulation ou une acceptation avec confirm: false (l’utilisateur a décoché la case) fait autorité et ne peut pas être contourné par confirm: true dans l’appel de l’outil. Une acceptation sans le champ confirm est considérée comme un échec du client à afficher une invite utilisable — possibilité de récupération en réessayant avec confirm: true
medium_write, high_write, destructiveNonNonBLOCAGE (renvoie une erreur avec une indication pour réessayer avec confirm: true)
medium_write, high_write, destructiveNonOuiPoursuite (activation explicite pour l’automatisation non interactive)
quelconque (égal ou inférieur à HARNESS_AUTO_APPROVE_RISK)quelconquequelconqueApprobation automatique sans invite

Si elicitInput échoue à l’exécution (erreur de transport, méthode non prise en charge) pour une opération de niveau medium_write+, l’appel est bloqué, sauf si l’appelant transmet confirm: true. confirm: true est pris en compte comme solution de repli lorsque le client n’a pas pu afficher d’invite ou a renvoyé une acceptation dégénérée ({action: "accept"} sans le champ de confirmation), mais ne remplace pas un refus ou une annulation explicite d’un client ayant terminé l’échange de sollicitation de confirmation.

Mode autonome

Le mode autonome signifie que le serveur exécute toutes les opérations — y compris les écritures et les actions destructrices — sans demander de confirmation. Activez-le en définissant :

HARNESS_AUTO_APPROVE_RISK=all

Il s’agit de la limite supérieure définie au niveau du déploiement : une fois activée, les sessions individuelles ne peuvent pas la dépasser (mais elles peuvent choisir un seuil plus strict pour chaque session via l’en-tête x-harness-auto-approve-risk).

Ou dans la configuration de votre client MCP :

{
  "mcpServers": {
    "harness": {
      "command": "npx",
      "args": ["harness-mcp-v2"],
      "env": {
        "HARNESS_API_KEY": "pat.xxx.xxx.xxx",
        "HARNESS_AUTO_APPROVE_RISK": "all"
      }
    }
  }
}

Autonomie partielle : vous pouvez également approuver automatiquement les opérations jusqu’à un niveau de risque donné, tout en continuant à demander confirmation pour les opérations plus risquées :

# Auto-approve reads and low-risk writes; prompt for medium_write, high_write, destructive
HARNESS_AUTO_APPROVE_RISK=low_write

# Auto-approve up to high-risk writes; only prompt for destructive operations
HARNESS_AUTO_APPROVE_RISK=high_write
ValeurOpérations approuvées automatiquement
none (par défaut)Aucune — aucun seuil d’approbation automatique
low_writeLectures + écritures à faible risque
medium_writeLectures + écritures à faible et moyen risque
high_writeLectures + écritures à faible, moyen et haut risque
allToutes les opérations, y compris les opérations destructrices

Avertissement concernant le mode autonome : HARNESS_AUTO_APPROVE_RISK=all ignore la confirmation pour toutes les opérations, y compris harness_delete. À utiliser avec prudence et envisagez de l’associer à HARNESS_TOOLSETS pour limiter les types de ressources disponibles.

Remarque sur la migration : HARNESS_SKIP_ELICITATION=true est toujours pris en charge et correspond à HARNESS_AUTO_APPROVE_RISK=all. Un avertissement de dépréciation est consigné sur stderr. Si les deux sont définis, HARNESS_AUTO_APPROVE_RISK est prioritaire.

Sécurité

  • Les secrets ne sont jamais exposés. Le type de ressource secret ne renvoie que des métadonnées (nom, type, portée) — les valeurs secrètes ne sont jamais incluses dans les réponses.
  • Les opérations nécessitant une confirmation utilisent la sollicitation de confirmation lorsqu’elle est disponible. Lorsqu’une action d’écriture ou d’exécution présente un risque medium_write, high_write ou destructive, harness_create, harness_update, harness_delete et harness_execute tentent d’obtenir une confirmation MCP avant de poursuivre (voir Sollicitation de confirmation). Les actions à faible risque (read, low_write — par exemple, pipeline.create, pipeline.update, hql_query.run) s’effectuent sans invite.
  • Les opérations à risque moyen ou supérieur échouent de manière sécurisée. Si la confirmation ne peut pas être obtenue pour les opérations medium_write, high_write ou destructive, elles sont bloquées au lieu d’être exécutées à l’aveugle. Pour les flux de travail autonomes, remplacez ce comportement avec HARNESS_AUTO_APPROVE_RISK.
  • CORS est limité à la même origine. Le transport HTTP n’autorise que les requêtes de même origine, ce qui empêche les attaques CSRF provenant de sites malveillants ciblant le serveur MCP sur localhost.
  • Limitation du débit HTTP. Le transport HTTP limite le débit à 60 requêtes par minute et par adresse IP afin d’éviter les inondations de requêtes.
  • Limitation du débit de l’API. Le client de l’API Harness limite le débit à 10 requêtes par seconde afin d’éviter de dépasser les limites de débit en amont.
  • La pagination est limitée. Les requêtes de liste sont plafonnées à 10 000 éléments au total et à 100 par page afin d’éviter l’épuisement de la mémoire.
  • Nouvelles tentatives avec temporisation exponentielle. Les échecs temporaires (HTTP 429, 5xx) font l’objet de nouvelles tentatives avec une temporisation exponentielle et une gigue.
  • Liaison à localhost. Le transport HTTP se lie à 127.0.0.1 par défaut — il n’est pas accessible depuis le réseau.
  • Aucune journalisation sur stdout. Tous les journaux sont envoyés vers stderr afin d’éviter de corrompre le transport JSON-RPC stdio.

Compétences complémentaires

Le serveur MCP Harness fonctionne bien avec Harness Skills — une collection de compétences Claude Code prêtes à l’emploi (commandes slash) conçues pour les flux de travail Harness courants. Installez-les en complément de ce serveur MCP pour bénéficier d’automatisations de haut niveau telles que /deploy, /rollback, /triage et bien d’autres, sans rédiger de prompts personnalisés.

Dépannage et problèmes courants

SymptômeCause probableQue faire
HARNESS_ACCOUNT_ID is required when the API key does not include an account ID segment...La clé API n’est pas dans un format pris en charge et limité au compte (pat.<accountId>... ou sat.<accountId>...), donc l’ID du compte ne peut pas être déduitDéfinissez explicitement HARNESS_ACCOUNT_ID
Unknown transport: "..." au démarrageArgument de transport CLI non pris en chargeUtilisez uniquement stdio ou http
Invalid HARNESS_TOOLSETS: ... au démarrageUn ou plusieurs noms de jeux d’outils ne sont pas reconnusUtilisez uniquement les noms de Filtrage des jeux d’outils (correspondance exacte)
HTTP mcp-session-id header is required...Une requête de session a été envoyée sans en-tête de sessionEnvoyez d’abord initialize, puis incluez mcp-session-id dans POST/GET/DELETE /mcp
HTTP Session not found...La session a expiré après MCP_SESSION_TTL_MS millisecondes d’inactivité ou a déjà été ferméeRelancez initialize pour créer une nouvelle session, puis réessayez avec le nouvel en-tête
HTTP 405 Method Not Allowed sur /mcpMéthode non prise en charge pour le point de terminaison MCPUtilisez uniquement POST, GET, DELETE ou OPTIONS
HTTP Invalid requestCorps JSON invalide ou corps de requête dépassant HARNESS_MAX_BODY_SIZE_MBValidez la taille et la structure de la charge utile JSON ; augmentez HARNESS_MAX_BODY_SIZE_MB si nécessaire
Unknown resource_type "..." des outilsLe type de ressource est mal orthographié ou filtré via HARNESS_TOOLSETSAppelez harness_describe (avec éventuellement search_term) pour découvrir les types valides
Missing required field "... for path parameter ..."Un appel limité à un projet/une organisation ne contient pas les identifiants requisDéfinissez HARNESS_ORG/HARNESS_PROJECT ou transmettez org_id/project_id pour chaque appel d’outil
resource_scope "org" requires org_id... ou resource_scope "project" requires project_id...Une ressource à portée multiple a été forcée à la portée organisation/projet sans identifiants suffisantsTransmettez les org_id/project_id manquants, configurez HARNESS_ORG/HARNESS_PROJECT, ou utilisez resource_scope: "account" si pris en charge
Read-only mode is enabled ... operations are not allowedHARNESS_READ_ONLY=true bloque la création/la mise à jour/la suppression/l’exécutionDéfinissez HARNESS_READ_ONLY=false si des opérations d’écriture sont prévues
L’exécution du pipeline échoue lors des vérifications préalables à cause d’entrées obligatoires non résoluesLe inputs fourni ne couvrait pas les espaces réservés d’exécution requisRécupérez runtime_input_template, fournissez les clés simples manquantes ou utilisez input_set_ids pour les entrées structurelles
Les raccourcis CI du pipeline (branch, tag, pr_number, commit_sha) n’ont pas été appliquésinputs.build était déjà fourni ; l’expansion des raccourcis a donc été volontairement ignoréeSupprimez inputs.build pour utiliser l’expansion des raccourcis, ou conservez la structure complète explicite build
L’exécution du pipeline a chargé la mauvaise révision YAMLLa définition du pipeline est stockée dans Git et l’exécution ne précisait pas la branche de pipeline souhaitéeTransmettez params.pipeline_branch à l’action run ; cela correspond à Harness branch
wait: true a renvoyé _wait.errorLe déclenchement du pipeline a réussi, mais l’interrogation côté serveur a échouéRevérifiez le execution_id avec harness_get(resource_type="execution", ...) avant de décider s’il faut relancer
wait: true a renvoyé execution_timed_out: trueL’exécution n’a pas atteint un état terminal avant wait_timeout_secondsUtilisez le execution_id renvoyé pour revérifier l’état ; attendez un état terminal avant d’exécuter harness_diagnose
Les journaux d’exécution sont vides ou les téléchargements de blobs renvoient 403Les URL des blobs de journaux hébergés par Harness nécessitent le chemin client/authentification Harness configuré, en particulier pour les hôtes internes ou autogérésGardez HARNESS_BASE_URL pointé vers l’hôte Harness cible et utilisez harness_get(resource_type="execution_log", ...) ou harness_diagnose(..., include_logs=true) plutôt que de contourner le client MCP
Operation declined by user / Operation cancelled by userL’utilisateur a refusé ou annulé la boîte de dialogue de confirmation de sollicitation — décision faisant autoritéVérifiez les détails de l’opération avec l’utilisateur ; confirm: true ne contourne pas un refus explicite. L’utilisateur doit accepter la demande
Operation blocked: the client could not surface a usable confirmation promptLe client ne prend pas en charge la sollicitation, elicitInput a échoué ou a renvoyé une acceptation dégénéréeRéessayez avec confirm: true pour une automatisation non interactive, ou utilisez un client prenant en charge la sollicitation
body.template_yaml (or body.yaml) is required pour la création/la mise à jour d’un modèleLes API de modèles attendent une charge utile YAML complèteFournissez une chaîne template_yaml complète dans body ; pour les suppressions, transmettez version_label afin de supprimer une version (omettez-le pour supprimer toutes les versions)
HARNESS_BASE_URL must use HTTPS au démarrageHARNESS_BASE_URL est défini sur une URL HTTPUtilisez HTTPS ou définissez HARNESS_ALLOW_HTTP=true pour le développement local

Licence

MIT