DevOps

This plugin connects your Claude Code environment to Vercel so you can trigger builds, list and inspect deployments, and stream runtime logs without opening the Vercel dashboard. It reads project settings, pulls domain and alias information, and shows build status and duration. You can trigger a new production or preview deployment, set or remove an alias, and view the deployment URL straight from your editor. It sends commands to Vercel's API to fetch environment variables, show build output as it happens, and display the last few log lines for any deployment. You can roll back to a previous deployment, cancel a running build, and check usage metrics like bandwidth or function invocations for a given deployment. It also maps domains and lets you check DNS verification status. Authentication uses your Vercel token so actions run under your account; the plugin shows which team and project you're operating on and warns when sensitive variables are exposed. It parses build errors and highlights failing steps so you can jump to the right file or commit. The UI returns URLs and deployment IDs you can copy into PRs or issue trackers. Imagine fixing a production issue: you pull recent logs, identify a failing serverless function, trigger a quick patch deploy, and if needed roll back to the previous deployment — all without switching windows. That flow saves context switches when you need to diagnose failures or update domains during a ticket-driven bugfix.

Install and run Terraform commands from Claude Code: init, fmt, validate, plan, apply, destroy, import, taint, output and state. It talks to a Terraform MCP Server that runs terraform binaries, reads your HCL files and module folders, and returns plan JSON, stdout/stderr and exit codes. You can request a human-readable plan diff, ask for the resources affected, or fetch remote state and resource attributes without leaving your editor. The plugin reads workspace and backend settings, accepts environment variables and var files, and runs targeted applies or refreshes. It can upload or download state snapshots, run show on a plan file, and parse plan details into resources to add comments or approvals. It also checks for formatting and validation errors and can run terraform fmt / validate as part of a pre-commit check you trigger from Claude Code. Use it to generate a concise change summary, fetch outputs for downstream scripts, or run a safe plan then produce an approved apply command. It shows plan diffs and resource counts so reviewers see exactly what changes will occur. Example: instead of switching to a shell to run terraform plan, open the module in Claude Code, ask for a plan and a list of tainted resources, then request apply after an approval—saving context switches when reviewing and applying PR-linked infrastructure changes.

Hook into your git workflow and get a risk score before you commit. The tool reads your pending diff, calls the PagerDuty API to pull incident records for the last 90 days, and maps incident metadata to the files and services your diff touches. It parses incident summaries, deduplicates by service and file path, and produces a numeric risk score plus a short breakdown: which files are linked to recent outages, how many incidents, when the last incident occurred, and whether any incidents are still marked active or unresolved. The plugin runs locally as a pre-commit or pre-push check, authenticates with your PagerDuty account, and caches recent incident data for speed. It flags high-risk hunks inline with your diff and outputs a concise report you can read in CI logs or your terminal. It also offers a JSON output you can pipe into other tools and a threshold you can fail builds on if the risk score exceeds your policy. Imagine fixing a config change that touches an auth module and seeing an immediate alert: three incidents in the last 30 days tied to that module, last incident still open — abort the commit and open a patch request instead. That saves you from toggling between the terminal, the PagerDuty site, and your repo UI to cross-check history, and it prevents deployments that would trigger on-call pages.

Endor Labs connects your code and CI/CD pipelines to a security scanner that reads repos, Docker images, Terraform and Kubernetes manifests, and pull requests. It runs static analysis and dependency checks, maps findings to specific files and lines, and returns a prioritized list of vulnerabilities with suggested fixes. The plugin pulls reports from the Endor Labs engine and shows exact remediation steps you can paste into PRs or issues. It checks container layers for unsafe binaries, scans IaC for misconfigurations, and tracks secret-like patterns across commits. You can ask it to re-scan a branch, filter results by severity or file path, and fetch historical reports for a given commit hash. The plugin also records evidence links back to the original rule and CVE entries so you can validate the discovery. The integration posts concise summaries you can include in CI logs, and it generates patch-ready snippets that update the offending lines. It flags policy violations that block merges and lets you mark findings as false positives or exceptions, keeping triage inside the same workflow. Imagine reviewing a large feature branch: instead of switching to a separate portal, you run the scan from your PR, see failing rules, copy suggested edits, and push fixes without leaving the code host. That saves time during reviews and prevents context switching between tools when closing security gaps before merge.

This plugin lets you deploy and operate Railway projects from within Claude Code so you don't need to open the dashboard. Run commands to spin up services, push code, tail logs, inspect builds, and watch deployment status. You can create new services, run one-off containers, open a port tunnel to a running service, and roll back to a previous deployment from the terminal. It reads and writes environment variables and secrets, manages custom domains and SSL, and controls multi-region deployments. The plugin talks to Postgres, Redis, MongoDB, S3-compatible storage, and other Railway service types. It pulls service metadata, streams live logs, checks health, and shows resource counts and billing metadata when available. You can run migrations, trigger backups, scale instances, and run a bash shell inside any service. Commands include create service, up/down, logs, env:set, env:unset, deploy, rollback, and attach. It maps project state to readable responses, returns structured JSON when requested, and records deployment IDs so you can reference or revert them later. In practice, use it to rotate a secret, push a hotfix, and tail logs to confirm the fix without opening the Railway web UI or your CI pipeline. That saves minutes when you're troubleshooting incidents or iterating on a production bug fix and prevents context switching between chat, terminal, and the dashboard.

Build and deploy serverless applications on Cloudflare's global network using Workers, Durable Objects, and the Agents SDK. Includes Wrangler CLI integration for local development and MCP server support for seamless infrastructure management.

Reads your existing GCP account and Terraform state, parses resource definitions, and pulls actual billing data. It maps GCP services (for example Compute Engine, GKE, Cloud SQL, Cloud Storage, IAM) to equivalent AWS resources (EC2/EKS, RDS, S3, IAM) and flags constructs that don’t have 1:1 matches. The tool checks Terraform modules, identifies hard-coded GCP providers, and generates a migration inventory with resource counts, inter-dependencies, and estimated data transfer paths. Fetches current AWS on-demand and reserved pricing and applies region-specific rates to give a line-item cost comparison. It generates Terraform sketches or CloudFormation snippets for the mapped AWS resources, and annotates them with the changes you’ll need (machine types, networking, IAM roles). The planner validates basic constraints like subnet sizes, VPC peering, and service limits and reports likely blockers. Produces a five-phase migration plan: discovery, design, proof-of-concept, data sync and cutover, and validation & rollback. Each phase includes concrete commands, Terraform workspaces to run, a recommended cutover window, and smoke-test steps. It also evaluates whether a lift-and-shift, re-platform, or stay-put option is cheaper and safer, and it records the confidence level of each recommendation. Imagine migrating a multi-region web app with GKE, Cloud SQL, and BigQuery: the plugin reads your Terraform state, maps clusters to EKS, converts SQL to RDS, pulls AWS pricing, and spits out a step-by-step cutover plan. That saves hours of manual mapping, spreadsheet pricing, and console hopping, and avoids bouncing between cloud consoles and separate cost tools during planning.

Fastly Agent Toolkit gives Claude working knowledge of the Fastly CDN platform and the Fastly Agent Toolkit GitHub repo. It reads and writes VCL snippets, runs the VCL linter, builds and runs Compute@Edge projects locally, and maps service versions to active configurations. You get six focused tools that cover code authoring, linting, local Compute execution, service management, cache/security rules, and deployment via the Fastly CLI and API. It opens and edits VCL files, checks them for syntax and best-practice issues, and suggests specific fixes. It runs your Compute app locally, watches console output, and helps you iterate by rebuilding and reloading the local runtime. For services it pulls service lists, inspects active backends and dictionaries, and creates or clones service versions. For delivery and ops it checks and updates caching rules, manages ACLs and TLS settings, and posts deploy commands through the CLI or API. It pulls real-time logs and metrics when available, and it records deployment IDs and version numbers so you can track rollbacks and audits. Imagine editing VCL, testing a Compute worker, and deploying a version without leaving your terminal or switching between the Fastly docs, CLI, and a separate editor. That flow saves time when you need to fix a cache rule, verify logs, and push a hotfix during a production incident.

Deploy on AWS connects your code repo and AWS account so you can deploy from Claude Code without hopping between consoles. It reads your repository, detects common deployment artifacts (Dockerfile, SAM template, CloudFormation), builds artifacts, pushes Docker images to ECR, packages Lambda functions, and runs CloudFormation or CDK deploys. It creates or updates IAM roles, security groups, and ECS/EKS services as defined in your templates and reports progress with deploy logs and status updates. The plugin runs commands in a controlled environment: it builds images, tags and pushes to registries, runs sam package/deploy or cdk synth/deploy, applies CloudFormation stacks, and can roll back on failure. It pulls logs from CloudWatch, streams recent events, and surfaces resource-level errors so you can fix code or infra without guessing which step failed. It connects to the GitHub repository at https://github.com/awslabs/agent-plugins for configuration examples and deploy workflows. Use it to run repeatable deploys from a chat context: trigger a staging deploy, watch the stack creation, fetch logs, and promote the same build to production without leaving Claude Code. In a real-world sprint you can deploy a hotfix, confirm Lambda logs show the fix, and roll back a bad release — all while avoiding manual console clicks or juggling multiple AWS tools, saving minutes to hours on each incident.

Netlify Skills brings detailed, programmatic access to Netlify's platform inside Claude Code: serverless functions, edge compute, blob storage, forms, image optimization, databases, object storage, and deployment automation. It includes mappings for Netlify CLI commands and configuration files so you can read and edit site.toml, netlify.toml, and function manifests with clear, actionable changes. The plugin reads Netlify docs and the GitHub repo for context, generates code samples for serverless and edge handlers, maps environment variables and build settings, and sends API calls to validate endpoints and settings. It checks build logs, pulls deploy status, watches function invocations, and runs common CLI tasks when you ask. It also tracks and reports limits (bandwidth, invocations) and surfaces the right API shapes for forms and blob storage requests. Included are 12 focused skill references that document current API signatures, runtime options, and deployment flows so Claude can give precise snippets and config edits. The plugin connects concrete Netlify actions to developer tasks: generate a deploy command, scaffold a function, or fix a redirect rule without guessing file locations. For example, when you integrate form handling, image optimization, and an edge auth check into a single site, Netlify Skills lets you generate the edge function, update netlify.toml, run the local CLI deploy, and check logs — all without switching tabs between docs, CLI, and the Netlify UI. That saves time and prevents context switching during tight release windows.

End-to-end serverless development on AWS — design functions, wire up services, deploy, and debug without leaving Claude Code.Build and deploy serverless applications on AWS without leaving your editor. This plugin gives Claude the knowledge to work with Lambda, API Gateway, EventBridge, and Step Functions, plus it connects directly to your AWS resources so you can manage them in real time. You can scaffold new projects with SAM CLI or CDK, design event-driven architectures, handle deployments across multiple environments, and set up CI/CD pipelines—all with AI assistance guiding you through each step.

PostHog for Claude connects Claude Code to your PostHog instance so you can query events, inspect user journeys, and read cohorts without writing API calls. It reads event tables, pulls property filters, and maps session timelines into plain-English summaries. You can ask for top events, retention curves, or funnel drop-offs and it returns the underlying queries and a human summary you can copy into notes or tickets. It also toggles feature flags, creates and updates experiments, and records rollout changes. It sends flag updates to PostHog, checks experiment status, and watches for metric regressions. Error tracking and LLM cost metrics are exposed as simple queries you can run — ask for "top errors this week" or "LLM spend by project" and it returns counts, trends, and links to the raw events. Use it when you want to skip the dashboard and get answers inside your workflow: ask Claude for a cohort list, then flip a flag and start an experiment without switching tools. That saves time during incident triage or A/B test setup — you stay in chat while you pull the query, update a flag, and record the change in your ticket system.

Open Sentry error data right where you code. Authenticate with your Sentry API token and the plugin reads issue lists, recent events, and full stack traces from the projects you select. It pulls severity, environment, release, event timestamps, user impact counts, tags, and breadcrumbs so you can see the exact call path that led to an error without opening a browser tab. Ask natural language questions to find related issues, filter by tag or release, or show all regressions in the last 24 hours. The plugin maps frames in stack traces to source files and shows suspect commits and release links. You can jump straight to the Sentry event, open the issue view, or copy a permalink to paste in a PR or chat. The tool highlights trending errors, groups by fingerprint, and shows sampling rates and error frequency graphs inline. It also exposes affected user counts and environments so you can prioritize fixes and decide whether to roll back a release or patch a handler. For example, when a monitoring alert fires at 2 AM you can pull the top new errors, read stack traces, and open the implicated source files in your editor all in one place—no context switching between Slack, Sentry, and your codebase. That saves time when triaging incidents and writing urgent fixes. GitHub: https://github.com/getsentry/sentry-for-ai

Sonatype Guide connects Claude Code to Sonatype's intelligence so your editor can scan project dependencies for known supply-chain risk. It reads manifests and lockfiles (package.json, pom.xml, go.mod, etc.), pulls vulnerability and policy data, and highlights packages with known CVEs, problematic licenses, or low quality scores. It shows the vulnerable version, the vulnerability ID, and the risk score so you can decide what to change. From inside the editor you can run a full dependency scan or a quick check on a single file. The plugin recommends safer versions, lists the delta between your version and a suggested upgrade, and maps transitive dependency chains so you see the true source of risk. It also checks licensing flags and quality indicators so you can assess non-security issues before they hit production. Scan results include actionable items: package names, vulnerable ranges, suggested fixes, and links to the Sonatype intelligence entry for each issue. You can copy a suggested version bump, open the advisory page, or record findings to your issue tracker. The plugin keeps results local to your workspace and updates as you edit files so you get immediate feedback while you code. In a real project you can run a scan when you open a pull request, see a flagged dependency, apply the suggested version, and push a tiny follow-up commit without leaving the editor — avoiding trips to a web console or separate scanner and saving the time of context switching during a release fix.