Meta Capabilities

Synchronizes a custom audience segment from Snowflake to the Meta Ads platform for retargeting campaigns.

naftiko: "0.5"
info:
  label: "Advertising Audience Segment Sync"
  description: "Synchronizes a custom audience segment from Snowflake to the Meta Ads platform for retargeting campaigns."
  tags:
    - marketing
    - ads
    - snowflake
    - meta-graph
    - audience
capability:
  exposes:
    - type: mcp
      namespace: audience-ops
      port: 8080
      tools:
        - name: sync-audience-segment
          description: "Given a Snowflake audience query and Meta Ads account ID, execute the query to retrieve the audience segment, then upload and update the custom audience in Meta Ads Manager."
          inputParameters:
            - name: ads_account_id
              in: body
              type: string
              description: "The Meta Ads account ID to update the custom audience in."
            - name: custom_audience_id
              in: body
              type: string
              description: "The existing Meta custom audience ID to sync to."
            - name: audience_query
              in: body
              type: string
              description: "The Snowflake SQL query to retrieve the audience segment user IDs."
          steps:
            - name: get-audience
              type: call
              call: "snowflake.execute-query"
              with:
                query: "{{audience_query}}"
            - name: update-audience
              type: call
              call: "meta-graph.update-custom-audience"
              with:
                ads_account_id: "{{ads_account_id}}"
                audience_id: "{{custom_audience_id}}"
                users: "{{get-audience.results}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: meta-graph
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.meta_graph_token"
      resources:
        - name: custom-audiences
          path: "/{{audience_id}}/users"
          inputParameters:
            - name: audience_id
              in: path
          operations:
            - name: update-custom-audience
              method: POST

Retrieves a GitHub pull request diff and uses the Anthropic API to generate a structured code review summary, posting it as a PR comment.

naftiko: "0.5"
info:
  label: "AI-Assisted Code Review Summary"
  description: "Retrieves a GitHub pull request diff and uses the Anthropic API to generate a structured code review summary, posting it as a PR comment."
  tags:
    - ai
    - automation
    - anthropic
    - github
    - code-review
    - devops
capability:
  exposes:
    - type: mcp
      namespace: ai-code-review
      port: 8080
      tools:
        - name: summarize-pull-request
          description: "Given a GitHub pull request URL, retrieve the PR diff, generate a structured code review summary using Anthropic Claude, and post it as a comment on the pull request."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository containing the pull request (e.g., facebook/react)."
            - name: pull_request_number
              in: body
              type: integer
              description: "The pull request number to review."
          steps:
            - name: get-pr-diff
              type: call
              call: "github.get-pull-request-diff"
              with:
                repository: "{{repository}}"
                pull_number: "{{pull_request_number}}"
            - name: generate-review
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-opus-4-5"
                prompt: "Review this pull request diff and provide a structured summary covering: 1) What changed and why, 2) Potential issues or risks, 3) Suggestions for improvement. Diff: {{get-pr-diff.diff}}"
            - name: post-comment
              type: call
              call: "github.create-pr-comment"
              with:
                repository: "{{repository}}"
                pull_number: "{{pull_request_number}}"
                body: "## AI Code Review Summary\n\n{{generate-review.content[0].text}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-request-diff
          path: "/repos/{{repository}}/pulls/{{pull_number}}"
          inputParameters:
            - name: repository
              in: path
            - name: pull_number
              in: path
          operations:
            - name: get-pull-request-diff
              method: GET
        - name: pr-comments
          path: "/repos/{{repository}}/issues/{{pull_number}}/comments"
          inputParameters:
            - name: repository
              in: path
            - name: pull_number
              in: path
          operations:
            - name: create-pr-comment
              method: POST
    - type: http
      namespace: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST

After a production incident is resolved, retrieves incident timeline from Datadog and uses Anthropic Claude to generate a structured post-mortem document posted to Slack.

naftiko: "0.5"
info:
  label: "AI-Assisted Incident Post-Mortem"
  description: "After a production incident is resolved, retrieves incident timeline from Datadog and uses Anthropic Claude to generate a structured post-mortem document posted to Slack."
  tags:
    - ai
    - automation
    - anthropic
    - datadog
    - slack
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: ai-postmortem
      port: 8080
      tools:
        - name: generate-incident-postmortem
          description: "Given a Datadog incident ID and ServiceNow incident number, retrieve the incident timeline and event log, use Anthropic Claude to generate a structured post-mortem with root cause and action items, and post it to the engineering Slack channel."
          inputParameters:
            - name: datadog_incident_id
              in: body
              type: string
              description: "The Datadog incident ID with the event timeline."
            - name: servicenow_incident_number
              in: body
              type: string
              description: "The ServiceNow incident number for the resolved incident."
          steps:
            - name: get-incident-events
              type: call
              call: "datadog.get-incident-timeline"
              with:
                incident_id: "{{datadog_incident_id}}"
            - name: generate-postmortem
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-opus-4-5"
                prompt: "Write a structured production incident post-mortem document with sections: Summary, Timeline, Root Cause, Contributing Factors, Impact, and Action Items. Incident data: {{get-incident-events.timeline}}"
            - name: post-postmortem
              type: call
              call: "slack.post-message"
              with:
                channel: "incident-postmortems"
                text: "Post-Mortem Published - SNOW: {{servicenow_incident_number}}\n\n{{generate-postmortem.content[0].text}}"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v2"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: incident-timeline
          path: "/incidents/{{incident_id}}/timeline"
          inputParameters:
            - name: incident_id
              in: path
          operations:
            - name: get-incident-timeline
              method: GET
    - type: http
      namespace: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

On a GitHub Actions pipeline failure on a protected branch, creates a Jira bug, posts a Datadog deployment event, and alerts the engineering team on Slack.

naftiko: "0.5"
info:
  label: "CI/CD Pipeline Failure Handler"
  description: "On a GitHub Actions pipeline failure on a protected branch, creates a Jira bug, posts a Datadog deployment event, and alerts the engineering team on Slack."
  tags:
    - devops
    - cicd
    - github
    - jira
    - datadog
    - slack
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: devops-ops
      port: 8080
      tools:
        - name: handle-pipeline-failure
          description: "Given a GitHub Actions pipeline failure with repository, branch, commit SHA, and run URL, create a Jira bug, log a Datadog event, and post an alert to the engineering Slack channel."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository where the failure occurred (e.g., facebook/react)."
            - name: workflow_name
              in: body
              type: string
              description: "The GitHub Actions workflow name that failed."
            - name: branch
              in: body
              type: string
              description: "The branch on which the failure occurred."
            - name: run_url
              in: body
              type: string
              description: "URL to the failed GitHub Actions run."
            - name: commit_sha
              in: body
              type: string
              description: "The commit SHA for the failed run."
          steps:
            - name: create-bug
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "[CI Failure] {{repository}} / {{branch}} - {{workflow_name}}"
                description: "Workflow: {{workflow_name}}\nBranch: {{branch}}\nCommit: {{commit_sha}}\nRun: {{run_url}}"
            - name: log-event
              type: call
              call: "datadog.create-event"
              with:
                title: "CI Failure: {{repository}}/{{branch}}"
                text: "Workflow {{workflow_name}} failed at commit {{commit_sha}}"
                alert_type: "error"
            - name: notify-slack
              type: call
              call: "slack.post-message"
              with:
                channel: "engineering-alerts"
                text: "Pipeline Failure: {{repository}} | {{branch}} | {{workflow_name}} | Jira: {{create-bug.key}} | Run: {{run_url}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects a cloud cost anomaly on AWS or GCP, creates a ServiceNow change request and notifies the FinOps team via Slack.

naftiko: "0.5"
info:
  label: "Cloud Cost Anomaly Response"
  description: "When Datadog detects a cloud cost anomaly on AWS or GCP, creates a ServiceNow change request and notifies the FinOps team via Slack."
  tags:
    - cloud
    - finops
    - datadog
    - servicenow
    - slack
    - cost-management
capability:
  exposes:
    - type: mcp
      namespace: cloud-finops
      port: 8080
      tools:
        - name: respond-to-cost-anomaly
          description: "Given a Datadog cloud cost anomaly with cloud provider, service name, and excess amount, create a ServiceNow change request for the FinOps team and notify the cloud cost Slack channel."
          inputParameters:
            - name: cloud_provider
              in: body
              type: string
              description: "The cloud provider generating the anomaly: AWS or GCP."
            - name: service_name
              in: body
              type: string
              description: "The cloud service or workload generating the cost anomaly."
            - name: excess_amount_usd
              in: body
              type: number
              description: "Dollar amount exceeding the expected cost baseline."
          steps:
            - name: create-change
              type: call
              call: "servicenow.create-change"
              with:
                short_description: "{{cloud_provider}} cost anomaly: {{service_name}} exceeded by ${{excess_amount_usd}}"
                type: "normal"
                category: "cloud_cost"
            - name: notify-finops
              type: call
              call: "slack.post-message"
              with:
                channel: "cloud-finops"
                text: "Cost Anomaly: {{cloud_provider}}/{{service_name}} exceeded baseline by ${{excess_amount_usd}}. ServiceNow: {{create-change.number}}"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-request
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Datadog error rate monitor fires after a deployment, triggers a GitHub Actions rollback workflow and creates a ServiceNow emergency change request.

naftiko: "0.5"
info:
  label: "Datadog Deployment Rollback Trigger"
  description: "When a Datadog error rate monitor fires after a deployment, triggers a GitHub Actions rollback workflow and creates a ServiceNow emergency change request."
  tags:
    - devops
    - deployment
    - datadog
    - github
    - servicenow
    - rollback
capability:
  exposes:
    - type: mcp
      namespace: deployment-safety
      port: 8080
      tools:
        - name: trigger-deployment-rollback
          description: "Given a Datadog monitor alert with repository, environment, and target rollback version, create a ServiceNow emergency change, trigger the rollback GitHub Actions workflow, and log a Datadog event."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository to roll back."
            - name: environment
              in: body
              type: string
              description: "The environment to roll back: production or staging."
            - name: target_version
              in: body
              type: string
              description: "The stable version tag to roll back to (e.g., v3.2.1)."
          steps:
            - name: create-emergency-change
              type: call
              call: "servicenow.create-change"
              with:
                short_description: "Emergency rollback: {{repository}} to {{target_version}} in {{environment}}"
                type: "emergency"
                category: "software_deployment"
            - name: trigger-rollback
              type: call
              call: "github.trigger-workflow"
              with:
                repository: "{{repository}}"
                workflow_id: "rollback.yml"
                ref: "main"
            - name: log-event
              type: call
              call: "datadog.create-event"
              with:
                title: "Rollback triggered: {{repository}}/{{environment}} to {{target_version}}"
                alert_type: "warning"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-request
          path: "/table/change_request"
          operations:
            - name: create-change
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: workflow-dispatches
          path: "/repos/{{repository}}/actions/workflows/{{workflow_id}}/dispatches"
          inputParameters:
            - name: repository
              in: path
            - name: workflow_id
              in: path
          operations:
            - name: trigger-workflow
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST

When Datadog detects high Facebook News Feed latency, creates a Jira P1 incident and notifies the feed team in Slack.

naftiko: "0.5"
info:
  label: "Datadog Facebook Feed Latency Alert to Jira"
  description: "When Datadog detects high Facebook News Feed latency, creates a Jira P1 incident and notifies the feed team in Slack."
  tags:
    - platform
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: feed-latency
      port: 8080
      tools:
        - name: handle-feed-latency
          description: "Given a Datadog monitor ID for feed latency, create a Jira P1 and notify the feed team."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
          steps:
            - name: get-monitor
              type: call
              call: dd-feed.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-p1
              type: call
              call: jira-feed.create-issue
              with:
                project_key: "FEED"
                issuetype: "Incident"
                summary: "P1: Feed latency — {{get-monitor.name}}"
                priority: "Highest"
            - name: notify-feed
              type: call
              call: slack-feed.post-message
              with:
                channel: "feed-engineering"
                text: "FEED LATENCY P1: {{get-monitor.name}} | Jira: {{create-p1.key}}"
  consumes:
    - type: http
      namespace: dd-feed
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-feed
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-feed
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates weekly SLO compliance for the Facebook Graph API from Datadog and posts to Slack.

naftiko: "0.5"
info:
  label: "Datadog Graph API SLO Weekly Report"
  description: "Generates weekly SLO compliance for the Facebook Graph API from Datadog and posts to Slack."
  tags:
    - platform
    - datadog
    - slack
    - slo
capability:
  exposes:
    - type: mcp
      namespace: graph-api-ops
      port: 8080
      tools:
        - name: handle-graph-api-slo
          description: "Given a Datadog SLO ID, generate weekly report and post to Slack."
          inputParameters:
            - name: slo_id
              in: body
              type: string
              description: "Datadog SLO ID."
          steps:
            - name: get-slo
              type: call
              call: dd-graph.get-slo-history
              with:
                slo_id: "{{slo_id}}"
            - name: post-report
              type: call
              call: slack-graph.post-message
              with:
                channel: "graph-api"
                text: "Graph API SLO: Target: {{get-slo.target}}% | Actual: {{get-slo.overall_status}} | Budget: {{get-slo.error_budget_remaining}}%"
  consumes:
    - type: http
      namespace: dd-graph
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: slo
          path: "/slo/{{slo_id}}/history"
          inputParameters:
            - name: slo_id
              in: path
          operations:
            - name: get-slo-history
              method: GET
    - type: http
      namespace: slack-graph
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects Horizon Worlds latency spikes, creates a Jira incident and notifies the VR team in Slack.

naftiko: "0.5"
info:
  label: "Datadog Horizon Worlds Latency Alert"
  description: "When Datadog detects Horizon Worlds latency spikes, creates a Jira incident and notifies the VR team in Slack."
  tags:
    - vr
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: horizon-ops
      port: 8080
      tools:
        - name: handle-horizon-latency
          description: "Given a Datadog monitor ID, create a Jira incident and notify VR team."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
          steps:
            - name: get-monitor
              type: call
              call: dd-horizon.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: jira-horizon.create-issue
              with:
                project_key: "HORIZON"
                issuetype: "Incident"
                summary: "Horizon latency: {{get-monitor.name}}"
                priority: "High"
            - name: notify-vr
              type: call
              call: slack-vr.post-message
              with:
                channel: "horizon-engineering"
                text: "HORIZON LATENCY: {{get-monitor.name}} | Jira: {{create-incident.key}}"
  consumes:
    - type: http
      namespace: dd-horizon
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-horizon
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-vr
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Datadog infrastructure monitor fires for a production service, creates a ServiceNow incident and pages the on-call engineer via PagerDuty.

naftiko: "0.5"
info:
  label: "Datadog Infrastructure Alert to PagerDuty"
  description: "When a Datadog infrastructure monitor fires for a production service, creates a ServiceNow incident and pages the on-call engineer via PagerDuty."
  tags:
    - observability
    - infrastructure
    - datadog
    - servicenow
    - pagerduty
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: infra-monitoring
      port: 8080
      tools:
        - name: handle-infrastructure-alert
          description: "Given a Datadog infrastructure alert with service, host, and metric details, open a high-priority ServiceNow incident and trigger a PagerDuty escalation to the on-call engineer."
          inputParameters:
            - name: monitor_name
              in: body
              type: string
              description: "The Datadog monitor name that fired."
            - name: service_name
              in: body
              type: string
              description: "The affected production service name."
            - name: host
              in: body
              type: string
              description: "The affected host identifier."
            - name: alert_url
              in: body
              type: string
              description: "URL to the Datadog monitor alert."
          steps:
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Infrastructure alert: {{monitor_name}} on {{host}}"
                urgency: "1"
                category: "infrastructure"
            - name: page-oncall
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "Infra Alert: {{monitor_name}} on {{service_name}}"
                severity: "critical"
                body: "Host: {{host}}. Alert: {{alert_url}}. SNOW: {{create-incident.number}}"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST

Queries Datadog for Instagram API endpoint latency metrics.

naftiko: "0.5"
info:
  label: "Datadog Instagram API Latency Check"
  description: "Queries Datadog for Instagram API endpoint latency metrics."
  tags:
    - platform
    - datadog
    - instagram
capability:
  exposes:
    - type: mcp
      namespace: ig-ops
      port: 8080
      tools:
        - name: get-api-latency
          description: "Given an API endpoint name, return Instagram API latency metrics from Datadog. Use for SLA monitoring."
          inputParameters:
            - name: endpoint_name
              in: body
              type: string
              description: "Instagram API endpoint name."
          call: "dd-ig.get-metrics"
          with:
            query: "avg:instagram.api.latency{endpoint:{{endpoint_name}}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - type: http
      namespace: dd-ig
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: metrics
          path: "/query"
          inputParameters:
            - name: query
              in: query
          operations:
            - name: get-metrics
              method: GET

When Datadog detects Marketplace API availability issues, creates a Jira incident and notifies in Slack.

naftiko: "0.5"
info:
  label: "Datadog Marketplace API Availability Alert"
  description: "When Datadog detects Marketplace API availability issues, creates a Jira incident and notifies in Slack."
  tags:
    - platform
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: marketplace-ops
      port: 8080
      tools:
        - name: handle-marketplace-alert
          description: "Given a monitor ID, create incident and notify."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
          steps:
            - name: get-monitor
              type: call
              call: dd-market.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: jira-market.create-issue
              with:
                project_key: "MKTPL"
                issuetype: "Incident"
                summary: "Marketplace API: {{get-monitor.name}}"
            - name: notify
              type: call
              call: slack-market.post-message
              with:
                channel: "marketplace-ops"
                text: "MARKETPLACE ALERT: {{get-monitor.name}} | Jira: {{create-incident.key}}"
  consumes:
    - type: http
      namespace: dd-market
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-market
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-market
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks Messenger service health status from Datadog monitors.

naftiko: "0.5"
info:
  label: "Datadog Messenger Service Health Check"
  description: "Checks Messenger service health status from Datadog monitors."
  tags:
    - messaging
    - datadog
    - messenger
capability:
  exposes:
    - type: mcp
      namespace: messenger-ops
      port: 8080
      tools:
        - name: get-messenger-health
          description: "Given a service name, return Messenger service health from Datadog. Use for reliability dashboards."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "Messenger service name."
          call: "dd-msg.get-monitors"
          with:
            name: "{{service_name}}"
          outputParameters:
            - name: monitors
              type: array
              mapping: "$.monitors"
  consumes:
    - type: http
      namespace: dd-msg
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          inputParameters:
            - name: name
              in: query
          operations:
            - name: get-monitors
              method: GET

Checks the News Feed ranking service SLO status from Datadog.

naftiko: "0.5"
info:
  label: "Datadog News Feed Ranking SLO Check"
  description: "Checks the News Feed ranking service SLO status from Datadog."
  tags:
    - platform
    - datadog
    - news-feed
capability:
  exposes:
    - type: mcp
      namespace: feed-ops
      port: 8080
      tools:
        - name: get-feed-slo
          description: "Given a Datadog SLO ID, return News Feed ranking SLO status. Use for reliability tracking."
          inputParameters:
            - name: slo_id
              in: body
              type: string
              description: "Datadog SLO ID."
          call: "dd-feed.get-slo"
          with:
            slo_id: "{{slo_id}}"
          outputParameters:
            - name: slo
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: dd-feed
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: slos
          path: "/slo/{{slo_id}}"
          inputParameters:
            - name: slo_id
              in: path
          operations:
            - name: get-slo
              method: GET

Monitors Quest firmware rollout health via Datadog and reports to the VR team in Slack.

naftiko: "0.5"
info:
  label: "Datadog Oculus Firmware Rollout Monitor"
  description: "Monitors Quest firmware rollout health via Datadog and reports to the VR team in Slack."
  tags:
    - vr
    - datadog
    - slack
    - firmware
capability:
  exposes:
    - type: mcp
      namespace: quest-firmware
      port: 8080
      tools:
        - name: handle-firmware-rollout
          description: "Given a service tag and version, monitor rollout and report."
          inputParameters:
            - name: service_tag
              in: body
              type: string
              description: "Datadog service tag."
            - name: firmware_version
              in: body
              type: string
              description: "Firmware version."
          steps:
            - name: check-monitors
              type: call
              call: dd-quest.get-monitors
              with:
                tags: "{{service_tag}}"
            - name: post-status
              type: call
              call: slack-quest.post-message
              with:
                channel: "quest-firmware"
                text: "Quest FW Rollout: {{firmware_version}} | Monitors: {{check-monitors.total_count}} | Alerts: {{check-monitors.alert_count}}"
  consumes:
    - type: http
      namespace: dd-quest
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          inputParameters:
            - name: tags
              in: query
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: slack-quest
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects Reels video encoding pipeline issues, creates a Jira incident and notifies the video team in Slack.

naftiko: "0.5"
info:
  label: "Datadog Reels Video Encoding Alert"
  description: "When Datadog detects Reels video encoding pipeline issues, creates a Jira incident and notifies the video team in Slack."
  tags:
    - video
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: reels-ops
      port: 8080
      tools:
        - name: handle-encoding-alert
          description: "Given a Datadog monitor ID for Reels encoding, create a Jira incident and notify the video team."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
          steps:
            - name: get-monitor
              type: call
              call: dd-reels.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: jira-video.create-issue
              with:
                project_key: "VIDEO"
                issuetype: "Incident"
                summary: "Reels encoding: {{get-monitor.name}}"
                priority: "High"
            - name: notify-video
              type: call
              call: slack-video.post-message
              with:
                channel: "video-engineering"
                text: "REELS ENCODING ALERT: {{get-monitor.name}} | Jira: {{create-incident.key}}"
  consumes:
    - type: http
      namespace: dd-reels
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-video
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-video
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Datadog SLO drops below target for a production service, creates a Jira incident ticket and posts an urgent escalation to the reliability engineering Slack channel.

naftiko: "0.5"
info:
  label: "Datadog SLO Breach Escalation"
  description: "When a Datadog SLO drops below target for a production service, creates a Jira incident ticket and posts an urgent escalation to the reliability engineering Slack channel."
  tags:
    - observability
    - slo
    - datadog
    - jira
    - slack
    - reliability
capability:
  exposes:
    - type: mcp
      namespace: slo-escalation
      port: 8080
      tools:
        - name: escalate-slo-breach
          description: "Given a Datadog SLO ID that has breached its target, retrieve SLO details, open a Jira issue for the owning team, and post an urgent escalation to the reliability engineering Slack channel."
          inputParameters:
            - name: slo_id
              in: body
              type: string
              description: "The Datadog SLO ID that has breached its target."
            - name: current_value
              in: body
              type: number
              description: "The current SLO value as a percentage."
            - name: target_value
              in: body
              type: number
              description: "The target SLO value as a percentage."
          steps:
            - name: get-slo
              type: call
              call: "datadog.get-slo"
              with:
                slo_id: "{{slo_id}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project_key: "REL"
                issuetype: "Bug"
                summary: "SLO Breach: {{get-slo.name}} at {{current_value}}% (target {{target_value}}%)"
                description: "SLO {{get-slo.name}} has breached. Current: {{current_value}}% | Target: {{target_value}}%"
            - name: notify-reliability
              type: call
              call: "slack.post-message"
              with:
                channel: "reliability-engineering"
                text: "SLO BREACH: {{get-slo.name}} at {{current_value}}% against {{target_value}}% target. Jira: {{create-issue.key}}"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: slos
          path: "/slo/{{slo_id}}"
          inputParameters:
            - name: slo_id
              in: path
          operations:
            - name: get-slo
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects CDN performance issues for Stories, creates Jira incident and notifies in Slack.

naftiko: "0.5"
info:
  label: "Datadog Stories CDN Performance Alert"
  description: "When Datadog detects CDN performance issues for Stories, creates Jira incident and notifies in Slack."
  tags:
    - infrastructure
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: cdn-ops
      port: 8080
      tools:
        - name: handle-cdn-alert
          description: "Given a monitor ID, create Jira incident and notify CDN team."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
          steps:
            - name: get-monitor
              type: call
              call: dd-cdn.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: jira-cdn.create-issue
              with:
                project_key: "CDN"
                issuetype: "Incident"
                summary: "Stories CDN: {{get-monitor.name}}"
            - name: notify-cdn
              type: call
              call: slack-cdn.post-message
              with:
                channel: "cdn-engineering"
                text: "CDN ALERT: {{get-monitor.name}} | Jira: {{create-incident.key}}"
  consumes:
    - type: http
      namespace: dd-cdn
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-cdn
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-cdn
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects high error rates on Threads API, creates a Jira incident and notifies the Threads team in Slack.

naftiko: "0.5"
info:
  label: "Datadog Threads API Error Rate Handler"
  description: "When Datadog detects high error rates on Threads API, creates a Jira incident and notifies the Threads team in Slack."
  tags:
    - platform
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: threads-ops
      port: 8080
      tools:
        - name: handle-threads-error
          description: "Given a Datadog monitor ID for Threads API errors, create a Jira incident and notify the team."
          inputParameters:
            - name: monitor_id
              in: body
              type: integer
              description: "Datadog monitor ID."
          steps:
            - name: get-monitor
              type: call
              call: dd-threads.get-monitor
              with:
                monitor_id: "{{monitor_id}}"
            - name: create-incident
              type: call
              call: jira-threads.create-issue
              with:
                project_key: "THREADS"
                issuetype: "Incident"
                summary: "Threads API error: {{get-monitor.name}}"
                priority: "High"
            - name: notify-threads
              type: call
              call: slack-threads.post-message
              with:
                channel: "threads-engineering"
                text: "THREADS API ERROR: {{get-monitor.name}} | Jira: {{create-incident.key}}"
  consumes:
    - type: http
      namespace: dd-threads
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET
    - type: http
      namespace: jira-threads
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-threads
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks WhatsApp message delivery rate metrics from Datadog.

naftiko: "0.5"
info:
  label: "Datadog WhatsApp Delivery Rate Check"
  description: "Checks WhatsApp message delivery rate metrics from Datadog."
  tags:
    - messaging
    - datadog
    - whatsapp
capability:
  exposes:
    - type: mcp
      namespace: wa-delivery
      port: 8080
      tools:
        - name: get-delivery-rate
          description: "Given a region, return WhatsApp delivery rate metrics from Datadog."
          inputParameters:
            - name: region
              in: body
              type: string
              description: "Geographic region."
          call: "dd-wa.get-metrics"
          with:
            query: "avg:whatsapp.delivery_rate{region:{{region}}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - type: http
      namespace: dd-wa
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: metrics
          path: "/query"
          inputParameters:
            - name: query
              in: query
          operations:
            - name: get-metrics
              method: GET

Checks WhatsApp end-to-end encryption service health from Datadog and notifies security in Slack.

naftiko: "0.5"
info:
  label: "Datadog WhatsApp Encryption Health Check"
  description: "Checks WhatsApp end-to-end encryption service health from Datadog and notifies security in Slack."
  tags:
    - security
    - datadog
    - slack
    - whatsapp
capability:
  exposes:
    - type: mcp
      namespace: wa-security
      port: 8080
      tools:
        - name: handle-encryption-health
          description: "Given a service tag, check encryption health and notify."
          inputParameters:
            - name: service_tag
              in: body
              type: string
              description: "Datadog service tag."
          steps:
            - name: check-monitors
              type: call
              call: dd-wa-enc.get-monitors
              with:
                tags: "{{service_tag}}"
            - name: post-status
              type: call
              call: slack-wa-sec.post-message
              with:
                channel: "whatsapp-security"
                text: "WA Encryption Health: Monitors: {{check-monitors.total_count}} | Alerts: {{check-monitors.alert_count}}"
  consumes:
    - type: http
      namespace: dd-wa-enc
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          inputParameters:
            - name: tags
              in: query
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: slack-wa-sec
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an employee departure is confirmed in Workday, deactivates their Okta account, removes GitHub org membership, and creates a ServiceNow offboarding checklist.

naftiko: "0.5"
info:
  label: "Employee Offboarding and Access Revocation"
  description: "When an employee departure is confirmed in Workday, deactivates their Okta account, removes GitHub org membership, and creates a ServiceNow offboarding checklist."
  tags:
    - hr
    - offboarding
    - workday
    - okta
    - github
    - servicenow
capability:
  exposes:
    - type: mcp
      namespace: hr-offboarding
      port: 8080
      tools:
        - name: trigger-offboarding
          description: "Given a Workday employee ID and termination date, deactivate the Okta account, remove GitHub organization membership, and create a ServiceNow offboarding ticket."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID of the departing employee."
            - name: termination_date
              in: body
              type: string
              description: "The employee's last working day in ISO 8601 format (YYYY-MM-DD)."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: deactivate-okta
              type: call
              call: "okta.deactivate-user"
              with:
                user_email: "{{get-employee.work_email}}"
            - name: remove-github
              type: call
              call: "github.remove-org-member"
              with:
                org: "facebook"
                username: "{{get-employee.github_username}}"
            - name: create-offboarding-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Offboarding: {{get-employee.displayName}} - {{termination_date}}"
                category: "hr_offboarding"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: workers
          path: "/meta/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://meta.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: user-lifecycle
          path: "/users/{{user_id}}/lifecycle/deactivate"
          inputParameters:
            - name: user_id
              in: path
          operations:
            - name: deactivate-user
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/{{org}}/members/{{username}}"
          inputParameters:
            - name: org
              in: path
            - name: username
              in: path
          operations:
            - name: remove-org-member
              method: DELETE
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST

When a new hire is created in Workday, provisions a Okta identity, creates a GitHub organization membership, opens a ServiceNow onboarding ticket, and sends a Workplace welcome message.

naftiko: "0.5"
info:
  label: "Employee Onboarding Orchestrator"
  description: "When a new hire is created in Workday, provisions a Okta identity, creates a GitHub organization membership, opens a ServiceNow onboarding ticket, and sends a Workplace welcome message."
  tags:
    - hr
    - onboarding
    - workday
    - okta
    - github
    - servicenow
capability:
  exposes:
    - type: mcp
      namespace: hr-onboarding
      port: 8080
      tools:
        - name: trigger-onboarding
          description: "Given a Workday employee ID and start date, orchestrate full onboarding: create Okta identity, provision GitHub org membership, open a ServiceNow ticket, and send a Workplace by Meta welcome message."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID for the new hire."
            - name: start_date
              in: body
              type: string
              description: "The new hire's start date in ISO 8601 format (YYYY-MM-DD)."
            - name: team_name
              in: body
              type: string
              description: "The team the new hire is joining (e.g., Core Infra, Reality Labs)."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: create-okta-user
              type: call
              call: "okta.create-user"
              with:
                email: "{{get-employee.work_email}}"
                firstName: "{{get-employee.firstName}}"
                lastName: "{{get-employee.lastName}}"
            - name: add-github-member
              type: call
              call: "github.add-org-member"
              with:
                org: "facebook"
                username: "{{get-employee.github_username}}"
                role: "member"
            - name: open-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "New hire onboarding: {{get-employee.displayName}}"
                category: "hr_onboarding"
                assigned_to: "IT_Onboarding"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: workers
          path: "/meta/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://meta.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          operations:
            - name: create-user
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/{{org}}/memberships/{{username}}"
          inputParameters:
            - name: org
              in: path
            - name: username
              in: path
          operations:
            - name: add-org-member
              method: PUT
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST

Retrieves Facebook Page post engagement metrics for a given week from the Meta Graph API and posts a weekly summary to the social media Slack channel.

naftiko: "0.5"
info:
  label: "Facebook Page Engagement Digest"
  description: "Retrieves Facebook Page post engagement metrics for a given week from the Meta Graph API and posts a weekly summary to the social media Slack channel."
  tags:
    - marketing
    - social-media
    - meta-graph
    - facebook
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: social-reporting
      port: 8080
      tools:
        - name: digest-page-engagement
          description: "Given a Facebook Page ID and date range, retrieve post impressions, engagements, and reach from the Meta Graph API and post a weekly engagement digest to the social media Slack channel."
          inputParameters:
            - name: page_id
              in: body
              type: string
              description: "The Facebook Page ID to pull engagement metrics for."
            - name: date_start
              in: body
              type: string
              description: "Start date for the digest period (YYYY-MM-DD)."
            - name: date_stop
              in: body
              type: string
              description: "End date for the digest period (YYYY-MM-DD)."
          steps:
            - name: get-page-insights
              type: call
              call: "meta-graph.get-page-insights"
              with:
                page_id: "{{page_id}}"
                since: "{{date_start}}"
                until: "{{date_stop}}"
            - name: post-digest
              type: call
              call: "slack.post-message"
              with:
                channel: "social-media-team"
                text: "Facebook Page Weekly Report ({{date_start}} to {{date_stop}}): Reach: {{get-page-insights.reach}} | Impressions: {{get-page-insights.impressions}} | Engagements: {{get-page-insights.engagements}}"
  consumes:
    - type: http
      namespace: meta-graph
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.meta_graph_token"
      resources:
        - name: page-insights
          path: "/{{page_id}}/insights"
          inputParameters:
            - name: page_id
              in: path
          operations:
            - name: get-page-insights
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates Relay framework releases from GitHub and notifies the developer experience Slack channel.

naftiko: "0.5"
info:
  label: "GitHub GraphQL Relay Release"
  description: "Orchestrates Relay framework releases from GitHub and notifies the developer experience Slack channel."
  tags:
    - developer-tools
    - github
    - slack
    - graphql
capability:
  exposes:
    - type: mcp
      namespace: relay-release
      port: 8080
      tools:
        - name: handle-relay-release
          description: "Given a tag, check release and notify."
          inputParameters:
            - name: release_tag
              in: body
              type: string
              description: "Release tag."
          steps:
            - name: get-release
              type: call
              call: github-relay.get-release
              with:
                tag: "{{release_tag}}"
            - name: notify
              type: call
              call: slack-relay.post-message
              with:
                channel: "developer-experience"
                text: "Relay Release: {{release_tag}} | {{get-release.name}} | {{get-release.html_url}}"
  consumes:
    - type: http
      namespace: github-relay
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/facebook/relay/releases/tags/{{tag}}"
          inputParameters:
            - name: tag
              in: path
          operations:
            - name: get-release
              method: GET
    - type: http
      namespace: slack-relay
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks CI status for a branch in the HHVM/Hack repository.

naftiko: "0.5"
info:
  label: "GitHub Hack Language CI Status"
  description: "Checks CI status for a branch in the HHVM/Hack repository."
  tags:
    - engineering
    - github
    - hack
capability:
  exposes:
    - type: mcp
      namespace: hack-dev
      port: 8080
      tools:
        - name: get-hack-ci
          description: "Given a branch name, return CI status for the Hack language repository."
          inputParameters:
            - name: branch_name
              in: body
              type: string
              description: "Branch name."
          call: "github-hack.get-branch"
          with:
            branch_name: "{{branch_name}}"
          outputParameters:
            - name: branch
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-hack
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: branches
          path: "/repos/facebook/hhvm/branches/{{branch_name}}"
          inputParameters:
            - name: branch_name
              in: path
          operations:
            - name: get-branch
              method: GET

When a Terraform PR is opened, validates and posts summary to platform Slack.

naftiko: "0.5"
info:
  label: "GitHub Infra Terraform Review"
  description: "When a Terraform PR is opened, validates and posts summary to platform Slack."
  tags:
    - infrastructure
    - github
    - slack
    - terraform
capability:
  exposes:
    - type: mcp
      namespace: infra-review
      port: 8080
      tools:
        - name: handle-terraform-pr
          description: "Given a PR number, check status and post review to Slack."
          inputParameters:
            - name: pr_number
              in: body
              type: integer
              description: "PR number."
          steps:
            - name: get-pr
              type: call
              call: github-infra.get-pr
              with:
                pr_number: "{{pr_number}}"
            - name: notify-platform
              type: call
              call: slack-infra.post-message
              with:
                channel: "platform-engineering"
                text: "Terraform PR: #{{pr_number}} | {{get-pr.title}} | {{get-pr.html_url}}"
  consumes:
    - type: http
      namespace: github-infra
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pulls
          path: "/repos/facebook/infrastructure/pulls/{{pr_number}}"
          inputParameters:
            - name: pr_number
              in: path
          operations:
            - name: get-pr
              method: GET
    - type: http
      namespace: slack-infra
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates Jest framework releases from GitHub and notifies the developer experience Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Jest Testing Framework Release"
  description: "Orchestrates Jest framework releases from GitHub and notifies the developer experience Slack channel."
  tags:
    - developer-tools
    - github
    - slack
    - testing
capability:
  exposes:
    - type: mcp
      namespace: jest-release
      port: 8080
      tools:
        - name: handle-jest-release
          description: "Given a release tag, create release and notify."
          inputParameters:
            - name: release_tag
              in: body
              type: string
              description: "Release tag."
          steps:
            - name: get-release
              type: call
              call: github-jest.get-release
              with:
                tag: "{{release_tag}}"
            - name: notify
              type: call
              call: slack-dx.post-message
              with:
                channel: "developer-experience"
                text: "Jest Release: {{release_tag}} | {{get-release.name}} | {{get-release.html_url}}"
  consumes:
    - type: http
      namespace: github-jest
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/facebook/jest/releases/tags/{{tag}}"
          inputParameters:
            - name: tag
              in: path
          operations:
            - name: get-release
              method: GET
    - type: http
      namespace: slack-dx
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Validates Llama model benchmarks in Snowflake before approving a GitHub release, with Slack notification.

naftiko: "0.5"
info:
  label: "GitHub Llama Model Deployment Gate"
  description: "Validates Llama model benchmarks in Snowflake before approving a GitHub release, with Slack notification."
  tags:
    - ai
    - github
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: llama-deploy
      port: 8080
      tools:
        - name: handle-llama-deployment
          description: "Given a release tag and model ID, validate benchmarks and notify the AI team."
          inputParameters:
            - name: release_tag
              in: body
              type: string
              description: "GitHub release tag."
            - name: model_id
              in: body
              type: string
              description: "Llama model identifier."
          steps:
            - name: check-benchmarks
              type: call
              call: snowflake-llama.run-query
              with:
                model_id: "{{model_id}}"
            - name: get-release
              type: call
              call: github-llama.get-release
              with:
                tag: "{{release_tag}}"
            - name: notify-ai
              type: call
              call: slack-ai.post-message
              with:
                channel: "llama-deployments"
                text: "Llama Deploy Gate: {{release_tag}} | Model: {{model_id}} | Benchmark: {{check-benchmarks.score}} | Release: {{get-release.html_url}}"
  consumes:
    - type: http
      namespace: snowflake-llama
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: github-llama
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/meta-llama/llama/releases/tags/{{tag}}"
          inputParameters:
            - name: tag
              in: path
          operations:
            - name: get-release
              method: GET
    - type: http
      namespace: slack-ai
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the latest Llama model release information from GitHub.

naftiko: "0.5"
info:
  label: "GitHub Llama Model Release Lookup"
  description: "Retrieves the latest Llama model release information from GitHub."
  tags:
    - ai
    - github
    - llama
capability:
  exposes:
    - type: mcp
      namespace: llama-ops
      port: 8080
      tools:
        - name: get-llama-release
          description: "Return the latest Llama release from GitHub. Use for model deployment planning."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository name."
          call: "github-llama.get-release"
          with:
            repo_name: "{{repo_name}}"
          outputParameters:
            - name: release
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-llama
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/meta-llama/{{repo_name}}/releases/latest"
          inputParameters:
            - name: repo_name
              in: path
          operations:
            - name: get-release
              method: GET

Tracks open source contributions across Meta repos on GitHub and posts to the open source Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Open Source Contribution Tracker"
  description: "Tracks open source contributions across Meta repos on GitHub and posts to the open source Slack channel."
  tags:
    - open-source
    - github
    - slack
    - community
capability:
  exposes:
    - type: mcp
      namespace: oss-ops
      port: 8080
      tools:
        - name: handle-oss-tracking
          description: "Given a repo name, track contributions and post."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "Repository name."
          steps:
            - name: get-repo
              type: call
              call: github-oss.get-repo
              with:
                repo_name: "{{repo_name}}"
            - name: post-update
              type: call
              call: slack-oss.post-message
              with:
                channel: "open-source"
                text: "OSS: {{repo_name}} | Stars: {{get-repo.stargazers_count}} | Forks: {{get-repo.forks_count}} | Issues: {{get-repo.open_issues_count}}"
  consumes:
    - type: http
      namespace: github-oss
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: repos
          path: "/repos/facebook/{{repo_name}}"
          inputParameters:
            - name: repo_name
              in: path
          operations:
            - name: get-repo
              method: GET
    - type: http
      namespace: slack-oss
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Identifies GitHub pull requests that have been open without review for more than 48 hours and posts reminders to the team's Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Pull Request Review Reminder"
  description: "Identifies GitHub pull requests that have been open without review for more than 48 hours and posts reminders to the team's Slack channel."
  tags:
    - devops
    - github
    - slack
    - code-review
    - engineering
capability:
  exposes:
    - type: mcp
      namespace: code-review-ops
      port: 8080
      tools:
        - name: remind-stale-pull-requests
          description: "Given a GitHub organization and repository, find pull requests open for more than a specified number of hours without a review, and post reminder messages to the team Slack channel."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository to check (e.g., facebook/react)."
            - name: stale_hours
              in: body
              type: integer
              description: "Number of hours a PR must be open without review to be considered stale."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel ID to post reminders to."
          steps:
            - name: get-pull-requests
              type: call
              call: "github.list-pull-requests"
              with:
                repository: "{{repository}}"
                state: "open"
            - name: post-reminder
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "PR Review Reminder: {{get-pull-requests.stale_count}} pull requests in {{repository}} have been open for >{{stale_hours}} hours without review. Please review: {{get-pull-requests.stale_pr_links}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-requests
          path: "/repos/{{repository}}/pulls"
          inputParameters:
            - name: repository
              in: path
          operations:
            - name: list-pull-requests
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Runs PyTorch benchmark validation from GitHub CI, logs to Snowflake, and posts to the AI team Slack channel.

naftiko: "0.5"
info:
  label: "GitHub PyTorch Benchmark Pipeline"
  description: "Runs PyTorch benchmark validation from GitHub CI, logs to Snowflake, and posts to the AI team Slack channel."
  tags:
    - ai
    - github
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: pytorch-bench
      port: 8080
      tools:
        - name: handle-pytorch-benchmark
          description: "Given a run ID and model, check benchmark and post to Slack."
          inputParameters:
            - name: run_id
              in: body
              type: integer
              description: "GitHub Actions run ID."
            - name: model_name
              in: body
              type: string
              description: "Model name."
          steps:
            - name: get-run
              type: call
              call: github-pt.get-run
              with:
                run_id: "{{run_id}}"
            - name: log-results
              type: call
              call: snowflake-pt.run-query
              with:
                model: "{{model_name}}"
            - name: notify-ai
              type: call
              call: slack-pt.post-message
              with:
                channel: "pytorch-benchmarks"
                text: "PyTorch Benchmark: {{model_name}} | Run: {{run_id}} | Status: {{get-run.conclusion}}"
  consumes:
    - type: http
      namespace: github-pt
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: runs
          path: "/repos/pytorch/pytorch/actions/runs/{{run_id}}"
          inputParameters:
            - name: run_id
              in: path
          operations:
            - name: get-run
              method: GET
    - type: http
      namespace: snowflake-pt
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-pt
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the latest PyTorch release information from GitHub.

naftiko: "0.5"
info:
  label: "GitHub PyTorch Release Tag Lookup"
  description: "Retrieves the latest PyTorch release information from GitHub."
  tags:
    - ai
    - github
    - pytorch
capability:
  exposes:
    - type: mcp
      namespace: pytorch-ops
      port: 8080
      tools:
        - name: get-pytorch-release
          description: "Return the latest PyTorch release from GitHub. Use for framework version tracking."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "Repository name (e.g. pytorch)."
          call: "github-pt.get-release"
          with:
            repo_name: "{{repo_name}}"
          outputParameters:
            - name: release
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-pt
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/pytorch/{{repo_name}}/releases/latest"
          inputParameters:
            - name: repo_name
              in: path
          operations:
            - name: get-release
              method: GET

When CI fails in the React repository, creates a Jira bug and notifies the frontend team in Slack.

naftiko: "0.5"
info:
  label: "GitHub React CI Failure Handler"
  description: "When CI fails in the React repository, creates a Jira bug and notifies the frontend team in Slack."
  tags:
    - engineering
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: react-ci
      port: 8080
      tools:
        - name: handle-react-ci-failure
          description: "Given a GitHub run ID for a failed React CI, create a Jira bug and notify in Slack."
          inputParameters:
            - name: run_id
              in: body
              type: integer
              description: "GitHub Actions run ID."
          steps:
            - name: get-run
              type: call
              call: github-react.get-run
              with:
                run_id: "{{run_id}}"
            - name: create-bug
              type: call
              call: jira-react.create-issue
              with:
                project_key: "REACT"
                issuetype: "Bug"
                summary: "CI failure: {{get-run.name}}"
            - name: notify-frontend
              type: call
              call: slack-react.post-message
              with:
                channel: "react-engineering"
                text: "CI FAILURE: React | {{get-run.name}} | Jira: {{create-bug.key}}"
  consumes:
    - type: http
      namespace: github-react
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: runs
          path: "/repos/facebook/react/actions/runs/{{run_id}}"
          inputParameters:
            - name: run_id
              in: path
          operations:
            - name: get-run
              method: GET
    - type: http
      namespace: jira-react
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-react
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the review status of a pull request in the React Native repository.

naftiko: "0.5"
info:
  label: "GitHub React Native PR Status"
  description: "Retrieves the review status of a pull request in the React Native repository."
  tags:
    - engineering
    - github
    - react-native
capability:
  exposes:
    - type: mcp
      namespace: rn-dev
      port: 8080
      tools:
        - name: get-rn-pr
          description: "Given a PR number, return the React Native PR review status. Use for merge readiness checks."
          inputParameters:
            - name: pr_number
              in: body
              type: integer
              description: "Pull request number."
          call: "github-rn.get-pr"
          with:
            pr_number: "{{pr_number}}"
          outputParameters:
            - name: pr
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-rn
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pulls
          path: "/repos/facebook/react-native/pulls/{{pr_number}}"
          inputParameters:
            - name: pr_number
              in: path
          operations:
            - name: get-pr
              method: GET

Orchestrates React Native releases by validating tests, creating a GitHub release, and notifying in Slack.

naftiko: "0.5"
info:
  label: "GitHub React Native Release Pipeline"
  description: "Orchestrates React Native releases by validating tests, creating a GitHub release, and notifying in Slack."
  tags:
    - engineering
    - github
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: rn-release
      port: 8080
      tools:
        - name: handle-rn-release
          description: "Given a version, validate tests and create release."
          inputParameters:
            - name: version
              in: body
              type: string
              description: "Release version."
          steps:
            - name: validate
              type: call
              call: snowflake-rn.run-query
              with:
                version: "{{version}}"
            - name: create-release
              type: call
              call: github-rn.create-release
              with:
                tag_name: "{{version}}"
                name: "React Native {{version}}"
            - name: notify
              type: call
              call: slack-rn.post-message
              with:
                channel: "react-native-releases"
                text: "RN Release: {{version}} | Tests: {{validate.pass_rate}}% | {{create-release.html_url}}"
  consumes:
    - type: http
      namespace: snowflake-rn
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: github-rn
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/facebook/react-native/releases"
          operations:
            - name: create-release
              method: POST
    - type: http
      namespace: slack-rn
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Scans GitHub repositories for exposed secrets using secret scanning alerts, creates Jira security issues for each finding, and notifies the security team via Slack.

naftiko: "0.5"
info:
  label: "GitHub Repository Secrets Audit"
  description: "Scans GitHub repositories for exposed secrets using secret scanning alerts, creates Jira security issues for each finding, and notifies the security team via Slack."
  tags:
    - security
    - github
    - jira
    - slack
    - secrets-management
    - devops
capability:
  exposes:
    - type: mcp
      namespace: secrets-audit
      port: 8080
      tools:
        - name: audit-repository-secrets
          description: "Given a GitHub repository, retrieve all open secret scanning alerts, create Jira security issues for each, and post a summary to the security Slack channel."
          inputParameters:
            - name: repository
              in: body
              type: string
              description: "The GitHub repository to audit for exposed secrets (e.g., facebook/react)."
          steps:
            - name: get-secret-alerts
              type: call
              call: "github.list-secret-scanning-alerts"
              with:
                repository: "{{repository}}"
                state: "open"
            - name: create-security-issue
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "Secret scanning alerts in {{repository}}: {{get-secret-alerts.alert_count}} open"
                description: "{{get-secret-alerts.alert_summary}}"
            - name: notify-security
              type: call
              call: "slack.post-message"
              with:
                channel: "security-alerts"
                text: "Secret Scanning Alert: {{repository}} has {{get-secret-alerts.alert_count}} open secret exposures. Jira: {{create-security-issue.key}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: secret-scanning-alerts
          path: "/repos/{{repository}}/secret-scanning/alerts"
          inputParameters:
            - name: repository
              in: path
          operations:
            - name: list-secret-scanning-alerts
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Processes GitHub security findings, creates Jira tickets, and notifies the security team in Slack.

naftiko: "0.5"
info:
  label: "GitHub Security Scan to Jira Ticket"
  description: "Processes GitHub security findings, creates Jira tickets, and notifies the security team in Slack."
  tags:
    - security
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: appsec-ops
      port: 8080
      tools:
        - name: handle-security-finding
          description: "Given a GitHub repo and alert, create a Jira ticket and notify security."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository."
            - name: alert_number
              in: body
              type: integer
              description: "Security alert number."
          steps:
            - name: get-alert
              type: call
              call: github-sec.get-alert
              with:
                repo_name: "{{repo_name}}"
                alert_number: "{{alert_number}}"
            - name: create-ticket
              type: call
              call: jira-sec.create-issue
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "Security: {{get-alert.rule.description}} in {{repo_name}}"
                priority: "Critical"
            - name: notify-sec
              type: call
              call: slack-sec.post-message
              with:
                channel: "security-alerts"
                text: "SECURITY: {{repo_name}} | {{get-alert.rule.description}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: github-sec
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: alerts
          path: "/repos/facebook/{{repo_name}}/code-scanning/alerts/{{alert_number}}"
          inputParameters:
            - name: repo_name
              in: path
            - name: alert_number
              in: path
          operations:
            - name: get-alert
              method: GET
    - type: http
      namespace: jira-sec
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-sec
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When the Meta Graph API surfaces a flagged content report for an Instagram business account, creates a ServiceNow ticket and notifies the trust and safety team via Slack.

naftiko: "0.5"
info:
  label: "Instagram Content Moderation Alert"
  description: "When the Meta Graph API surfaces a flagged content report for an Instagram business account, creates a ServiceNow ticket and notifies the trust and safety team via Slack."
  tags:
    - trust-safety
    - instagram
    - meta-graph
    - servicenow
    - slack
    - content-moderation
capability:
  exposes:
    - type: mcp
      namespace: content-safety
      port: 8080
      tools:
        - name: handle-content-moderation-flag
          description: "Given a flagged content report ID and Instagram account ID, retrieve the flagged content details from the Meta Graph API, create a ServiceNow ticket, and alert the trust and safety Slack channel."
          inputParameters:
            - name: content_id
              in: body
              type: string
              description: "The Instagram content ID that has been flagged for review."
            - name: account_id
              in: body
              type: string
              description: "The Instagram business account ID associated with the content."
            - name: violation_type
              in: body
              type: string
              description: "The type of policy violation detected (e.g., hate_speech, spam, misinformation)."
          steps:
            - name: get-content
              type: call
              call: "meta-graph.get-media-object"
              with:
                content_id: "{{content_id}}"
            - name: create-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Content moderation flag: {{violation_type}} on account {{account_id}}"
                urgency: "2"
                category: "trust_safety"
            - name: notify-trust-safety
              type: call
              call: "slack.post-message"
              with:
                channel: "trust-safety-ops"
                text: "Content Flagged: {{violation_type}} | Account: {{account_id}} | Content: {{content_id}} | Ticket: {{create-ticket.number}}"
  consumes:
    - type: http
      namespace: meta-graph
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.meta_graph_token"
      resources:
        - name: media
          path: "/{{content_id}}"
          inputParameters:
            - name: content_id
              in: path
          operations:
            - name: get-media-object
              method: GET
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks AI ethics review requests in Jira and notifies the responsible AI team in Slack.

naftiko: "0.5"
info:
  label: "Jira AI Ethics Review Workflow"
  description: "Tracks AI ethics review requests in Jira and notifies the responsible AI team in Slack."
  tags:
    - ethics
    - jira
    - slack
    - ai
capability:
  exposes:
    - type: mcp
      namespace: ethics-ops
      port: 8080
      tools:
        - name: handle-ethics-review
          description: "Given a project key, track ethics reviews."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
          steps:
            - name: search-reviews
              type: call
              call: jira-ethics.search-issues
              with:
                jql: "project = {{project_key}} AND status = 'Pending Review'"
            - name: post-status
              type: call
              call: slack-ethics.post-message
              with:
                channel: "responsible-ai"
                text: "Ethics Queue: {{search-reviews.total}} pending reviews"
  consumes:
    - type: http
      namespace: jira-ethics
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-ethics
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks compliance audit items in Jira and posts updates to the compliance Slack channel.

naftiko: "0.5"
info:
  label: "Jira Compliance Audit Tracker"
  description: "Tracks compliance audit items in Jira and posts updates to the compliance Slack channel."
  tags:
    - compliance
    - jira
    - slack
    - audit
capability:
  exposes:
    - type: mcp
      namespace: compliance-ops
      port: 8080
      tools:
        - name: handle-audit-tracking
          description: "Given a project key, track audit items."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
          steps:
            - name: search-items
              type: call
              call: jira-comp.search-issues
              with:
                jql: "project = {{project_key}} AND status != Done"
            - name: post-status
              type: call
              call: slack-comp.post-message
              with:
                channel: "compliance"
                text: "Audit: {{project_key}} | Open: {{search-items.total}}"
  consumes:
    - type: http
      namespace: jira-comp
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-comp
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Escalates content policy violations from Jira, creates Salesforce cases for advertisers, and notifies the policy team in Slack.

naftiko: "0.5"
info:
  label: "Jira Content Policy Violation Escalation"
  description: "Escalates content policy violations from Jira, creates Salesforce cases for advertisers, and notifies the policy team in Slack."
  tags:
    - trust-safety
    - jira
    - salesforce
    - slack
capability:
  exposes:
    - type: mcp
      namespace: policy-ops
      port: 8080
      tools:
        - name: handle-policy-violation
          description: "Given a Jira issue key for a content policy violation, create a Salesforce case and notify the policy team."
          inputParameters:
            - name: issue_key
              in: body
              type: string
              description: "Jira issue key."
            - name: advertiser_id
              in: body
              type: string
              description: "Salesforce advertiser account ID."
          steps:
            - name: get-issue
              type: call
              call: jira-policy.get-issue
              with:
                issue_key: "{{issue_key}}"
            - name: create-case
              type: call
              call: sf-policy.create-case
              with:
                account_id: "{{advertiser_id}}"
                subject: "Policy violation: {{get-issue.fields.summary}}"
            - name: notify-policy
              type: call
              call: slack-policy.post-message
              with:
                channel: "content-policy"
                text: "POLICY VIOLATION: {{issue_key}} | {{get-issue.fields.summary}} | Advertiser: {{advertiser_id}} | Case: {{create-case.id}}"
  consumes:
    - type: http
      namespace: jira-policy
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue/{{issue_key}}"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: get-issue
              method: GET
    - type: http
      namespace: sf-policy
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: cases
          path: "/sobjects/Case"
          operations:
            - name: create-case
              method: POST
    - type: http
      namespace: slack-policy
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Identifies cross-team dependencies in Jira and posts a status report to program management Slack.

naftiko: "0.5"
info:
  label: "Jira Cross-Team Dependency Tracker"
  description: "Identifies cross-team dependencies in Jira and posts a status report to program management Slack."
  tags:
    - project-management
    - jira
    - slack
    - dependencies
capability:
  exposes:
    - type: mcp
      namespace: dep-ops
      port: 8080
      tools:
        - name: handle-dependency-report
          description: "Given a project key, identify blocked items and post a report."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
          steps:
            - name: search-blocked
              type: call
              call: jira-deps.search-issues
              with:
                jql: "project = {{project_key}} AND status = Blocked"
            - name: post-report
              type: call
              call: slack-pm.post-message
              with:
                channel: "program-management"
                text: "Dependencies: {{project_key}} | Blocked: {{search-blocked.total}}"
  consumes:
    - type: http
      namespace: jira-deps
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-pm
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates a sprint velocity report from Jira for an engineering team and posts the summary to their Slack channel.

naftiko: "0.5"
info:
  label: "Jira Engineering Sprint Digest"
  description: "Generates a sprint velocity report from Jira for an engineering team and posts the summary to their Slack channel."
  tags:
    - devops
    - agile
    - jira
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: agile-reporting
      port: 8080
      tools:
        - name: digest-sprint
          description: "Given a Jira board ID and sprint ID, fetch completed and open issues, compute velocity, and post a formatted sprint summary to the team Slack channel."
          inputParameters:
            - name: board_id
              in: body
              type: string
              description: "The Jira board ID for the team sprint."
            - name: sprint_id
              in: body
              type: string
              description: "The Jira sprint ID to summarize."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel ID to post the sprint digest to."
          steps:
            - name: get-issues
              type: call
              call: "jira.list-sprint-issues"
              with:
                board_id: "{{board_id}}"
                sprint_id: "{{sprint_id}}"
            - name: post-digest
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Sprint {{sprint_id}} Update: {{get-issues.done_count}} done, {{get-issues.inprogress_count}} in progress, {{get-issues.todo_count}} remaining. Velocity: {{get-issues.story_points_completed}} pts."
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: sprint-issues
          path: "/board/{{board_id}}/sprint/{{sprint_id}}/issue"
          inputParameters:
            - name: board_id
              in: path
            - name: sprint_id
              in: path
          operations:
            - name: list-sprint-issues
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Validates Instagram feature release readiness from Jira and Datadog, then posts to the Instagram Slack channel.

naftiko: "0.5"
info:
  label: "Jira Instagram Feature Release Checklist"
  description: "Validates Instagram feature release readiness from Jira and Datadog, then posts to the Instagram Slack channel."
  tags:
    - instagram
    - jira
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ig-release
      port: 8080
      tools:
        - name: handle-ig-release
          description: "Given a Jira fix version and Datadog service tag, validate readiness and post to Slack."
          inputParameters:
            - name: fix_version
              in: body
              type: string
              description: "Jira fix version."
            - name: service_tag
              in: body
              type: string
              description: "Datadog service tag."
          steps:
            - name: check-tickets
              type: call
              call: jira-ig.search-issues
              with:
                jql: "fixVersion = {{fix_version}} AND status != Done"
            - name: check-health
              type: call
              call: dd-ig.get-monitors
              with:
                tags: "{{service_tag}}"
            - name: post-readiness
              type: call
              call: slack-ig.post-message
              with:
                channel: "instagram-releases"
                text: "IG Release: {{fix_version}} | Open: {{check-tickets.total}} | Alerts: {{check-health.alert_count}}"
  consumes:
    - type: http
      namespace: jira-ig
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: dd-ig
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor"
          inputParameters:
            - name: tags
              in: query
          operations:
            - name: get-monitors
              method: GET
    - type: http
      namespace: slack-ig
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Triages Messenger bugs from Jira, creates Snowflake impact reports, and notifies the messaging team in Slack.

naftiko: "0.5"
info:
  label: "Jira Messenger Bug Triage"
  description: "Triages Messenger bugs from Jira, creates Snowflake impact reports, and notifies the messaging team in Slack."
  tags:
    - messaging
    - jira
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: msg-triage
      port: 8080
      tools:
        - name: handle-messenger-triage
          description: "Given a Jira issue key, assess impact and notify."
          inputParameters:
            - name: issue_key
              in: body
              type: string
              description: "Jira issue key."
          steps:
            - name: get-issue
              type: call
              call: jira-msg.get-issue
              with:
                issue_key: "{{issue_key}}"
            - name: check-impact
              type: call
              call: snowflake-msg.run-query
              with:
                bug_id: "{{issue_key}}"
            - name: notify
              type: call
              call: slack-msg.post-message
              with:
                channel: "messenger-engineering"
                text: "BUG TRIAGE: {{issue_key}} | {{get-issue.fields.summary}} | Affected: {{check-impact.affected_users}}"
  consumes:
    - type: http
      namespace: jira-msg
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue/{{issue_key}}"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: get-issue
              method: GET
    - type: http
      namespace: snowflake-msg
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-msg
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the count of open bugs in the Metaverse platform Jira project.

naftiko: "0.5"
info:
  label: "Jira Metaverse Platform Bug Count"
  description: "Returns the count of open bugs in the Metaverse platform Jira project."
  tags:
    - vr
    - jira
    - metaverse
capability:
  exposes:
    - type: mcp
      namespace: metaverse-eng
      port: 8080
      tools:
        - name: get-metaverse-bugs
          description: "Given a priority, return open Metaverse platform bugs from Jira. Use for quality dashboards."
          inputParameters:
            - name: priority
              in: body
              type: string
              description: "Bug priority filter."
          call: "jira-mv.search-issues"
          with:
            jql: "project = MV AND type = Bug AND status != Done AND priority = {{priority}}"
          outputParameters:
            - name: total
              type: number
              mapping: "$.total"
  consumes:
    - type: http
      namespace: jira-mv
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET

Compiles quarterly roadmap progress from Jira epics and posts to the executive Slack channel.

naftiko: "0.5"
info:
  label: "Jira Quarterly Roadmap Report"
  description: "Compiles quarterly roadmap progress from Jira epics and posts to the executive Slack channel."
  tags:
    - project-management
    - jira
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: roadmap-ops
      port: 8080
      tools:
        - name: handle-roadmap
          description: "Given a project key and quarter, compile roadmap progress."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
            - name: quarter
              in: body
              type: string
              description: "Quarter identifier."
          steps:
            - name: search-epics
              type: call
              call: jira-roadmap.search-issues
              with:
                jql: "project = {{project_key}} AND type = Epic"
            - name: post-summary
              type: call
              call: slack-exec.post-message
              with:
                channel: "executive-updates"
                text: "Roadmap ({{quarter}}): {{project_key}} | Epics: {{search-epics.total}}"
  consumes:
    - type: http
      namespace: jira-roadmap
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-exec
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current sprint status for the Reality Labs Jira board.

naftiko: "0.5"
info:
  label: "Jira Reality Labs Sprint Status"
  description: "Retrieves the current sprint status for the Reality Labs Jira board."
  tags:
    - vr
    - jira
    - reality-labs
capability:
  exposes:
    - type: mcp
      namespace: rl-pm
      port: 8080
      tools:
        - name: get-rl-sprint
          description: "Given a board ID, return the Reality Labs sprint status. Use for standup meetings."
          inputParameters:
            - name: board_id
              in: body
              type: integer
              description: "Jira board ID."
          call: "jira-rl.get-sprints"
          with:
            board_id: "{{board_id}}"
          outputParameters:
            - name: sprints
              type: array
              mapping: "$.values"
  consumes:
    - type: http
      namespace: jira-rl
      baseUri: "https://meta.atlassian.net/rest/agile/1.0"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: sprints
          path: "/board/{{board_id}}/sprint"
          inputParameters:
            - name: board_id
              in: path
          operations:
            - name: get-sprints
              method: GET

Compiles sprint metrics from Jira and posts a retrospective to Slack.

naftiko: "0.5"
info:
  label: "Jira Sprint Retro Summary"
  description: "Compiles sprint metrics from Jira and posts a retrospective to Slack."
  tags:
    - engineering
    - jira
    - slack
    - agile
capability:
  exposes:
    - type: mcp
      namespace: agile-ops
      port: 8080
      tools:
        - name: handle-sprint-retro
          description: "Given a sprint ID, compile metrics and post retro to Slack."
          inputParameters:
            - name: sprint_id
              in: body
              type: integer
              description: "Jira sprint ID."
          steps:
            - name: get-sprint
              type: call
              call: jira-agile.get-sprint
              with:
                sprint_id: "{{sprint_id}}"
            - name: get-issues
              type: call
              call: jira-agile.get-sprint-issues
              with:
                sprint_id: "{{sprint_id}}"
            - name: post-retro
              type: call
              call: slack-eng.post-message
              with:
                channel: "engineering"
                text: "Sprint Retro: {{get-sprint.name}} | Completed: {{get-issues.total}} | Goal: {{get-sprint.goal}}"
  consumes:
    - type: http
      namespace: jira-agile
      baseUri: "https://meta.atlassian.net/rest/agile/1.0"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: sprints
          path: "/sprint/{{sprint_id}}"
          inputParameters:
            - name: sprint_id
              in: path
          operations:
            - name: get-sprint
              method: GET
        - name: sprint-issues
          path: "/sprint/{{sprint_id}}/issue"
          inputParameters:
            - name: sprint_id
              in: path
          operations:
            - name: get-sprint-issues
              method: GET
    - type: http
      namespace: slack-eng
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the current count of open bugs in the WhatsApp Jira project.

naftiko: "0.5"
info:
  label: "Jira WhatsApp Bug Count"
  description: "Returns the current count of open bugs in the WhatsApp Jira project."
  tags:
    - engineering
    - jira
    - whatsapp
capability:
  exposes:
    - type: mcp
      namespace: wa-eng
      port: 8080
      tools:
        - name: get-wa-bugs
          description: "Given a priority, return the count of open WhatsApp bugs. Use for quality tracking."
          inputParameters:
            - name: priority
              in: body
              type: string
              description: "Bug priority filter."
          call: "jira-wa.search-issues"
          with:
            jql: "project = WA AND type = Bug AND status != Done AND priority = {{priority}}"
          outputParameters:
            - name: total
              type: number
              mapping: "$.total"
  consumes:
    - type: http
      namespace: jira-wa
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET

Retrieves LinkedIn Campaign Manager performance metrics for sponsored content and posts a weekly summary to the B2B marketing Slack channel.

naftiko: "0.5"
info:
  label: "LinkedIn Sponsored Content Performance"
  description: "Retrieves LinkedIn Campaign Manager performance metrics for sponsored content and posts a weekly summary to the B2B marketing Slack channel."
  tags:
    - marketing
    - linkedin
    - slack
    - reporting
    - social-media
capability:
  exposes:
    - type: mcp
      namespace: linkedin-marketing
      port: 8080
      tools:
        - name: digest-sponsored-content-performance
          description: "Given a LinkedIn Campaign Manager account ID and date range, retrieve sponsored content performance metrics and post a formatted digest to the B2B marketing Slack channel."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "The LinkedIn Campaign Manager account ID."
            - name: date_start
              in: body
              type: string
              description: "Start date for the performance period (YYYY-MM-DD)."
            - name: date_end
              in: body
              type: string
              description: "End date for the performance period (YYYY-MM-DD)."
          steps:
            - name: get-analytics
              type: call
              call: "linkedin.get-campaign-analytics"
              with:
                account_id: "{{account_id}}"
                start_date: "{{date_start}}"
                end_date: "{{date_end}}"
            - name: post-digest
              type: call
              call: "slack.post-message"
              with:
                channel: "b2b-marketing"
                text: "LinkedIn Campaign Report ({{date_start}} to {{date_end}}): Impressions: {{get-analytics.impressions}} | Clicks: {{get-analytics.clicks}} | CTR: {{get-analytics.ctr}}% | Spend: ${{get-analytics.costInLocalCurrency}}"
  consumes:
    - type: http
      namespace: linkedin
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: campaign-analytics
          path: "/adAnalyticsV2"
          operations:
            - name: get-campaign-analytics
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls demographic and interest audience insights from the Meta Graph API for an ad account and posts a weekly summary to the ads strategy Slack channel.

naftiko: "0.5"
info:
  label: "Meta Ads Audience Insights Report"
  description: "Pulls demographic and interest audience insights from the Meta Graph API for an ad account and posts a weekly summary to the ads strategy Slack channel."
  tags:
    - marketing
    - meta-ads
    - meta-graph
    - slack
    - audience
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: audience-insights
      port: 8080
      tools:
        - name: publish-audience-insights-report
          description: "Given a Meta Ads account ID and date range, retrieve audience demographic and interest breakdown data and post a weekly insights summary to the ads strategy Slack channel."
          inputParameters:
            - name: ad_account_id
              in: body
              type: string
              description: "The Meta Ads account ID (format: act_XXXXXXXXX)."
            - name: date_start
              in: body
              type: string
              description: "Start date for the insights period (YYYY-MM-DD)."
            - name: date_end
              in: body
              type: string
              description: "End date for the insights period (YYYY-MM-DD)."
          steps:
            - name: get-audience-insights
              type: call
              call: "meta-graph.get-audience-insights"
              with:
                ad_account_id: "{{ad_account_id}}"
                date_start: "{{date_start}}"
                date_end: "{{date_end}}"
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "ads-strategy"
                text: "Audience Insights ({{date_start}} to {{date_end}}): Top age group: {{get-audience-insights.top_age_group}} | Top country: {{get-audience-insights.top_country}} | Top interest: {{get-audience-insights.top_interest}}"
  consumes:
    - type: http
      namespace: meta-graph
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.meta_graph_token"
      resources:
        - name: audience-insights
          path: "/{{ad_account_id}}/insights"
          inputParameters:
            - name: ad_account_id
              in: path
          operations:
            - name: get-audience-insights
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches performance metrics for a Meta Ads campaign from the Meta Graph API and posts a formatted summary to the marketing Slack channel.

naftiko: "0.5"
info:
  label: "Meta Ads Campaign Performance Digest"
  description: "Fetches performance metrics for a Meta Ads campaign from the Meta Graph API and posts a formatted summary to the marketing Slack channel."
  tags:
    - marketing
    - meta-ads
    - ads
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: ads-reporting
      port: 8080
      tools:
        - name: digest-campaign-performance
          description: "Given a Meta Ads campaign ID and date range, retrieve impressions, clicks, spend, and ROAS from the Meta Graph API and post a formatted performance digest to the marketing Slack channel."
          inputParameters:
            - name: campaign_id
              in: body
              type: string
              description: "The Meta Ads campaign ID to report on."
            - name: date_start
              in: body
              type: string
              description: "Start date for the reporting period (YYYY-MM-DD)."
            - name: date_stop
              in: body
              type: string
              description: "End date for the reporting period (YYYY-MM-DD)."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel ID to post the digest to."
          steps:
            - name: get-insights
              type: call
              call: "meta-graph.get-campaign-insights"
              with:
                campaign_id: "{{campaign_id}}"
                date_start: "{{date_start}}"
                date_stop: "{{date_stop}}"
            - name: post-digest
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Campaign Report ({{date_start}} to {{date_stop}}): Impressions: {{get-insights.impressions}} | Clicks: {{get-insights.clicks}} | Spend: ${{get-insights.spend}} | ROAS: {{get-insights.roas}}"
  consumes:
    - type: http
      namespace: meta-graph
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.meta_graph_token"
      resources:
        - name: campaign-insights
          path: "/{{campaign_id}}/insights"
          inputParameters:
            - name: campaign_id
              in: path
          operations:
            - name: get-campaign-insights
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

On a Meta Quest app store launch, pulls performance data from the Meta Graph API and posts an executive launch report to the marketing Slack channel.

naftiko: "0.5"
info:
  label: "Meta Quest VR App Launch Marketing Digest"
  description: "On a Meta Quest app store launch, pulls performance data from the Meta Graph API and posts an executive launch report to the marketing Slack channel."
  tags:
    - marketing
    - meta-quest
    - vr
    - meta-graph
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: quest-marketing
      port: 8080
      tools:
        - name: publish-app-launch-digest
          description: "Given a Meta Quest app ID and launch date, retrieve first-week download counts, ratings, and revenue from the Meta Graph API and post a launch performance digest to the product Slack channel."
          inputParameters:
            - name: app_id
              in: body
              type: string
              description: "The Meta Quest app ID to report on."
            - name: launch_date
              in: body
              type: string
              description: "The app launch date in ISO 8601 format (YYYY-MM-DD)."
            - name: slack_channel
              in: body
              type: string
              description: "The Slack channel ID to post the report to."
          steps:
            - name: get-app-metrics
              type: call
              call: "meta-graph.get-app-insights"
              with:
                app_id: "{{app_id}}"
                since: "{{launch_date}}"
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "{{slack_channel}}"
                text: "Quest App Launch Report - {{app_id}}: Downloads: {{get-app-metrics.installs}} | Revenue: ${{get-app-metrics.revenue}} | Rating: {{get-app-metrics.avg_rating}}/5"
  consumes:
    - type: http
      namespace: meta-graph
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.meta_graph_token"
      resources:
        - name: app-insights
          path: "/{{app_id}}/app_insights"
          inputParameters:
            - name: app_id
              in: path
          operations:
            - name: get-app-insights
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Okta detects a suspicious login event, suspends the affected user account, creates a high-priority ServiceNow security incident, and alerts the security operations Slack channel.

naftiko: "0.5"
info:
  label: "Okta Suspicious Login Security Response"
  description: "When Okta detects a suspicious login event, suspends the affected user account, creates a high-priority ServiceNow security incident, and alerts the security operations Slack channel."
  tags:
    - security
    - identity
    - okta
    - servicenow
    - slack
    - siem
capability:
  exposes:
    - type: mcp
      namespace: security-response
      port: 8080
      tools:
        - name: respond-to-suspicious-login
          description: "Given an Okta suspicious login event with user email and IP address, suspend the user account, create a ServiceNow security incident, and alert the security operations Slack channel."
          inputParameters:
            - name: user_email
              in: body
              type: string
              description: "The email of the user who triggered the suspicious login."
            - name: event_id
              in: body
              type: string
              description: "The Okta system log event ID for the suspicious login."
            - name: ip_address
              in: body
              type: string
              description: "The IP address from which the suspicious login was attempted."
          steps:
            - name: get-user
              type: call
              call: "okta.get-user-by-email"
              with:
                email: "{{user_email}}"
            - name: suspend-user
              type: call
              call: "okta.suspend-user"
              with:
                user_id: "{{get-user.id}}"
            - name: create-security-incident
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Suspicious login: {{user_email}} from {{ip_address}}"
                urgency: "1"
                category: "security"
            - name: alert-soc
              type: call
              call: "slack.post-message"
              with:
                channel: "security-operations"
                text: "SECURITY RESPONSE: User {{user_email}} suspended after suspicious login from {{ip_address}}. SNOW: {{create-security-incident.number}}"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://meta.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users-by-email
          path: "/users"
          operations:
            - name: get-user-by-email
              method: GET
        - name: user-suspend
          path: "/users/{{user_id}}/lifecycle/suspend"
          inputParameters:
            - name: user_id
              in: path
          operations:
            - name: suspend-user
              method: POST
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Provisions Okta application access based on an employee's team and role, and logs the provisioning action in ServiceNow.

naftiko: "0.5"
info:
  label: "Okta User Access Provisioning"
  description: "Provisions Okta application access based on an employee's team and role, and logs the provisioning action in ServiceNow."
  tags:
    - identity
    - security
    - okta
    - servicenow
    - access-management
capability:
  exposes:
    - type: mcp
      namespace: identity-provisioning
      port: 8080
      tools:
        - name: provision-user-access
          description: "Given an employee email, team name, and list of application IDs, assign the user to the appropriate Okta groups and log the access provisioning event in ServiceNow."
          inputParameters:
            - name: user_email
              in: body
              type: string
              description: "The employee's work email address."
            - name: team_name
              in: body
              type: string
              description: "The team name for role-based group assignment."
            - name: application_ids
              in: body
              type: string
              description: "Comma-separated list of Okta application IDs to provision."
          steps:
            - name: get-user
              type: call
              call: "okta.get-user-by-email"
              with:
                email: "{{user_email}}"
            - name: assign-groups
              type: call
              call: "okta.add-user-to-group"
              with:
                user_id: "{{get-user.id}}"
                team: "{{team_name}}"
            - name: log-provisioning
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Access provisioned for {{user_email}} - Team: {{team_name}}"
                category: "access_management"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://meta.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          operations:
            - name: get-user-by-email
              method: GET
        - name: group-membership
          path: "/groups/{{group_id}}/users/{{user_id}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_id
              in: path
          operations:
            - name: add-user-to-group
              method: PUT
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST

Triggers a Power BI dataset refresh for the executive business intelligence dashboard and notifies the analytics team via Slack when complete.

naftiko: "0.5"
info:
  label: "Power BI Executive Dashboard Refresh"
  description: "Triggers a Power BI dataset refresh for the executive business intelligence dashboard and notifies the analytics team via Slack when complete."
  tags:
    - analytics
    - reporting
    - power-bi
    - slack
    - data
capability:
  exposes:
    - type: mcp
      namespace: bi-reporting
      port: 8080
      tools:
        - name: refresh-executive-dashboard
          description: "Given a Power BI workspace ID and dataset ID, trigger a dataset refresh for the executive BI dashboard and notify the analytics Slack channel upon initiation."
          inputParameters:
            - name: workspace_id
              in: body
              type: string
              description: "The Power BI workspace ID containing the executive dashboard dataset."
            - name: dataset_id
              in: body
              type: string
              description: "The Power BI dataset ID for the executive dashboard."
          steps:
            - name: trigger-refresh
              type: call
              call: "powerbi.refresh-dataset"
              with:
                workspace_id: "{{workspace_id}}"
                dataset_id: "{{dataset_id}}"
            - name: notify-analytics
              type: call
              call: "slack.post-message"
              with:
                channel: "analytics-team"
                text: "Executive dashboard refresh initiated for dataset {{dataset_id}}. Expected completion: 10-15 minutes."
  consumes:
    - type: http
      namespace: powerbi
      baseUri: "https://api.powerbi.com/v1.0/myorg"
      authentication:
        type: bearer
        token: "$secrets.powerbi_token"
      resources:
        - name: dataset-refreshes
          path: "/groups/{{workspace_id}}/datasets/{{dataset_id}}/refreshes"
          inputParameters:
            - name: workspace_id
              in: path
            - name: dataset_id
              in: path
          operations:
            - name: refresh-dataset
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Meta Quest hardware defect report crosses a volume threshold, creates a high-priority ServiceNow incident, opens a Jira engineering ticket, and alerts the Reality Labs product team via Slack.

naftiko: "0.5"
info:
  label: "Reality Labs Hardware Defect Escalation"
  description: "When a Meta Quest hardware defect report crosses a volume threshold, creates a high-priority ServiceNow incident, opens a Jira engineering ticket, and alerts the Reality Labs product team via Slack."
  tags:
    - manufacturing
    - quality
    - servicenow
    - jira
    - slack
    - reality-labs
capability:
  exposes:
    - type: mcp
      namespace: hardware-quality
      port: 8080
      tools:
        - name: escalate-hardware-defect
          description: "Given a Quest hardware defect type, device model, and defect count, create a high-priority ServiceNow incident, open a Jira engineering ticket, and alert the Reality Labs product Slack channel."
          inputParameters:
            - name: device_model
              in: body
              type: string
              description: "The Meta Quest device model affected (e.g., Quest 3, Quest Pro)."
            - name: defect_type
              in: body
              type: string
              description: "The type of hardware defect reported (e.g., display_failure, controller_drift)."
            - name: defect_count
              in: body
              type: integer
              description: "Number of units reported with this defect in the current period."
          steps:
            - name: create-incident
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Hardware defect escalation: {{device_model}} - {{defect_type}}"
                urgency: "1"
                category: "hardware_quality"
            - name: create-eng-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "RL"
                issuetype: "Bug"
                summary: "Hardware defect: {{device_model}} {{defect_type}} - {{defect_count}} units affected"
                description: "SNOW: {{create-incident.number}} | Device: {{device_model}} | Defect: {{defect_type}} | Count: {{defect_count}}"
            - name: notify-product-team
              type: call
              call: "slack.post-message"
              with:
                channel: "reality-labs-product"
                text: "HARDWARE ALERT: {{device_model}} reporting {{defect_count}} units with {{defect_type}}. SNOW: {{create-incident.number}} | Jira: {{create-eng-ticket.key}}"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incident
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates ad spend forecast from Salesforce opportunities, enriches with Snowflake data, and posts to the revenue Slack channel.

naftiko: "0.5"
info:
  label: "Salesforce Ad Spend Forecast Report"
  description: "Generates ad spend forecast from Salesforce opportunities, enriches with Snowflake data, and posts to the revenue Slack channel."
  tags:
    - finance
    - salesforce
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ad-finance
      port: 8080
      tools:
        - name: handle-ad-forecast
          description: "Given a quarter, compile ad spend forecast and post to revenue team."
          inputParameters:
            - name: quarter
              in: body
              type: string
              description: "Quarter (e.g. Q1-2026)."
          steps:
            - name: query-pipeline
              type: call
              call: sf-ad-rev.query-opportunities
              with:
                quarter: "{{quarter}}"
            - name: enrich
              type: call
              call: snowflake-rev.run-query
              with:
                quarter: "{{quarter}}"
            - name: post-forecast
              type: call
              call: slack-rev.post-message
              with:
                channel: "revenue-operations"
                text: "Ad Spend Forecast ({{quarter}}): Pipeline: ${{query-pipeline.totalAmount}} | Weighted: ${{enrich.weighted}} | Growth: {{enrich.yoy_growth}}%"
  consumes:
    - type: http
      namespace: sf-ad-rev
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: query
          path: "/query"
          inputParameters:
            - name: quarter
              in: query
          operations:
            - name: query-opportunities
              method: GET
    - type: http
      namespace: snowflake-rev
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-rev
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Looks up advertiser account details in Salesforce for ad sales operations.

naftiko: "0.5"
info:
  label: "Salesforce Advertiser Account Lookup"
  description: "Looks up advertiser account details in Salesforce for ad sales operations."
  tags:
    - sales
    - salesforce
    - advertising
capability:
  exposes:
    - type: mcp
      namespace: ad-sales
      port: 8080
      tools:
        - name: get-advertiser
          description: "Given an account ID, return advertiser details from Salesforce. Use for ad sales qualification."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "Salesforce account ID."
          call: "sf-ads.get-account"
          with:
            account_id: "{{account_id}}"
          outputParameters:
            - name: account
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: sf-ads
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET

Queries Snowflake for advertiser churn signals, creates Salesforce tasks, and notifies customer success in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Advertiser Churn Risk Alert"
  description: "Queries Snowflake for advertiser churn signals, creates Salesforce tasks, and notifies customer success in Slack."
  tags:
    - customer-success
    - salesforce
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: churn-ops
      port: 8080
      tools:
        - name: handle-churn-risk
          description: "Given a risk threshold, identify at-risk advertisers and create follow-up tasks."
          inputParameters:
            - name: risk_threshold
              in: body
              type: number
              description: "Churn risk score threshold."
          steps:
            - name: query-risk
              type: call
              call: snowflake-churn.run-query
              with:
                threshold: "{{risk_threshold}}"
            - name: create-task
              type: call
              call: sf-churn.create-task
              with:
                subject: "At-risk advertisers above {{risk_threshold}}"
            - name: notify-cs
              type: call
              call: slack-cs.post-message
              with:
                channel: "ad-customer-success"
                text: "CHURN RISK: {{query-risk.at_risk_count}} advertisers above {{risk_threshold}} | Task: {{create-task.id}}"
  consumes:
    - type: http
      namespace: snowflake-churn
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: sf-churn
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: tasks
          path: "/sobjects/Task"
          operations:
            - name: create-task
              method: POST
    - type: http
      namespace: slack-cs
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Compiles agency partner revenue from Salesforce, enriches with Snowflake data, and posts to partnerships Slack.

naftiko: "0.5"
info:
  label: "Salesforce Agency Partner Revenue Report"
  description: "Compiles agency partner revenue from Salesforce, enriches with Snowflake data, and posts to partnerships Slack."
  tags:
    - partnerships
    - salesforce
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: agency-ops
      port: 8080
      tools:
        - name: handle-agency-revenue
          description: "Given a partner ID and period, compile revenue and post."
          inputParameters:
            - name: partner_id
              in: body
              type: string
              description: "Partner account ID."
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: get-account
              type: call
              call: sf-agency.get-account
              with:
                account_id: "{{partner_id}}"
            - name: get-usage
              type: call
              call: snowflake-agency.run-query
              with:
                partner_id: "{{partner_id}}"
            - name: post-report
              type: call
              call: slack-agency.post-message
              with:
                channel: "agency-partnerships"
                text: "Agency Revenue ({{period}}): {{get-account.Name}} | Revenue: ${{get-account.AnnualRevenue}} | Ad spend: ${{get-usage.total_spend}}"
  consumes:
    - type: http
      namespace: sf-agency
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET
    - type: http
      namespace: snowflake-agency
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-agency
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Escalates support cases from Salesforce to Jira engineering and notifies in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Customer Support Case Escalation"
  description: "Escalates support cases from Salesforce to Jira engineering and notifies in Slack."
  tags:
    - support
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: support-ops
      port: 8080
      tools:
        - name: handle-case-escalation
          description: "Given a SF case ID, create Jira ticket and notify."
          inputParameters:
            - name: case_id
              in: body
              type: string
              description: "Salesforce case ID."
          steps:
            - name: get-case
              type: call
              call: sf-support.get-case
              with:
                case_id: "{{case_id}}"
            - name: create-ticket
              type: call
              call: jira-support.create-issue
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "Escalation: {{get-case.Subject}}"
            - name: notify
              type: call
              call: slack-support.post-message
              with:
                channel: "support-escalations"
                text: "ESCALATION: {{get-case.Subject}} | Case: {{case_id}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: sf-support
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: cases
          path: "/sobjects/Case/{{case_id}}"
          inputParameters:
            - name: case_id
              in: path
          operations:
            - name: get-case
              method: GET
    - type: http
      namespace: jira-support
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-support
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Looks up enterprise messaging deal details in Salesforce for WhatsApp Business sales.

naftiko: "0.5"
info:
  label: "Salesforce Enterprise Messaging Deal Lookup"
  description: "Looks up enterprise messaging deal details in Salesforce for WhatsApp Business sales."
  tags:
    - sales
    - salesforce
    - messaging
capability:
  exposes:
    - type: mcp
      namespace: msg-sales
      port: 8080
      tools:
        - name: get-messaging-deal
          description: "Given an opportunity ID, return enterprise messaging deal details. Use for deal tracking."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "Salesforce opportunity ID."
          call: "sf-msg.get-opportunity"
          with:
            opportunity_id: "{{opportunity_id}}"
          outputParameters:
            - name: opportunity
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: sf-msg
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET

When a high-value ad deal is created in Salesforce, creates Jira delivery epic and alerts sales leadership in Slack.

naftiko: "0.5"
info:
  label: "Salesforce High-Value Advertiser Alert"
  description: "When a high-value ad deal is created in Salesforce, creates Jira delivery epic and alerts sales leadership in Slack."
  tags:
    - sales
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ad-deals
      port: 8080
      tools:
        - name: handle-high-value-deal
          description: "Given a Salesforce opportunity ID, create a delivery epic and notify leadership."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "Salesforce opportunity ID."
          steps:
            - name: get-opp
              type: call
              call: sf-deals.get-opportunity
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: create-epic
              type: call
              call: jira-deals.create-issue
              with:
                project_key: "ADS"
                issuetype: "Epic"
                summary: "Ad delivery: {{get-opp.Name}} — ${{get-opp.Amount}}"
            - name: notify-leadership
              type: call
              call: slack-sales.post-message
              with:
                channel: "sales-leadership"
                text: "HIGH-VALUE AD DEAL: {{get-opp.Name}} | ${{get-opp.Amount}} | Jira: {{create-epic.key}}"
  consumes:
    - type: http
      namespace: sf-deals
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
    - type: http
      namespace: jira-deals
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-sales
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates developer partner onboarding in Salesforce and notifies the partnerships team in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Partner Developer Onboarding"
  description: "Orchestrates developer partner onboarding in Salesforce and notifies the partnerships team in Slack."
  tags:
    - partnerships
    - salesforce
    - slack
    - developer
capability:
  exposes:
    - type: mcp
      namespace: dev-partner
      port: 8080
      tools:
        - name: handle-dev-onboarding
          description: "Given partner details, create SF account and notify partnerships."
          inputParameters:
            - name: partner_name
              in: body
              type: string
              description: "Partner name."
            - name: partner_type
              in: body
              type: string
              description: "Partner type."
          steps:
            - name: create-account
              type: call
              call: sf-partner.create-account
              with:
                name: "{{partner_name}}"
                type: "{{partner_type}}"
            - name: notify-team
              type: call
              call: slack-partner.post-message
              with:
                channel: "developer-partnerships"
                text: "NEW DEV PARTNER: {{partner_name}} | Type: {{partner_type}} | SF: {{create-account.id}}"
  consumes:
    - type: http
      namespace: sf-partner
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account"
          operations:
            - name: create-account
              method: POST
    - type: http
      namespace: slack-partner
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Compiles SMB advertiser health scores from Salesforce and posts to the SMB team Slack channel.

naftiko: "0.5"
info:
  label: "Salesforce SMB Advertiser Health Digest"
  description: "Compiles SMB advertiser health scores from Salesforce and posts to the SMB team Slack channel."
  tags:
    - customer-success
    - salesforce
    - slack
    - smb
capability:
  exposes:
    - type: mcp
      namespace: smb-ops
      port: 8080
      tools:
        - name: handle-smb-health
          description: "Given a segment, compile health scores and post."
          inputParameters:
            - name: segment
              in: body
              type: string
              description: "Customer segment."
          steps:
            - name: query-health
              type: call
              call: sf-smb.query-accounts
              with:
                segment: "{{segment}}"
            - name: post-digest
              type: call
              call: slack-smb.post-message
              with:
                channel: "smb-success"
                text: "SMB Health ({{segment}}): Accounts: {{query-health.totalSize}} | At-risk: {{query-health.at_risk}} | Healthy: {{query-health.healthy}}"
  consumes:
    - type: http
      namespace: sf-smb
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/query"
          inputParameters:
            - name: segment
              in: query
          operations:
            - name: query-accounts
              method: GET
    - type: http
      namespace: slack-smb
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates WhatsApp Business customer onboarding in Salesforce and notifies the messaging team in Slack.

naftiko: "0.5"
info:
  label: "Salesforce WhatsApp Business Onboarding"
  description: "Orchestrates WhatsApp Business customer onboarding in Salesforce and notifies the messaging team in Slack."
  tags:
    - messaging
    - salesforce
    - slack
    - onboarding
capability:
  exposes:
    - type: mcp
      namespace: wa-onboard
      port: 8080
      tools:
        - name: handle-wa-onboarding
          description: "Given customer details, create a Salesforce account and notify the messaging team."
          inputParameters:
            - name: company_name
              in: body
              type: string
              description: "Company name."
            - name: tier
              in: body
              type: string
              description: "WhatsApp Business tier."
          steps:
            - name: create-account
              type: call
              call: sf-wa.create-account
              with:
                name: "{{company_name}}"
                type: "WhatsApp Business — {{tier}}"
            - name: notify-messaging
              type: call
              call: slack-wa.post-message
              with:
                channel: "whatsapp-business"
                text: "WA ONBOARDING: {{company_name}} | Tier: {{tier}} | SF: {{create-account.id}}"
  consumes:
    - type: http
      namespace: sf-wa
      baseUri: "https://meta.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account"
          operations:
            - name: create-account
              method: POST
    - type: http
      namespace: slack-wa
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves a ServiceNow change request, notifies the Change Advisory Board via Slack, and updates the change record with the approval decision.

naftiko: "0.5"
info:
  label: "ServiceNow Change Request Approval Flow"
  description: "Retrieves a ServiceNow change request, notifies the Change Advisory Board via Slack, and updates the change record with the approval decision."
  tags:
    - itsm
    - change-management
    - servicenow
    - slack
    - approval
capability:
  exposes:
    - type: mcp
      namespace: change-management
      port: 8080
      tools:
        - name: process-change-approval
          description: "Given a ServiceNow change request number and approval decision, retrieve the change details, update the ServiceNow record with the approval status, and notify the CAB via Slack."
          inputParameters:
            - name: change_number
              in: body
              type: string
              description: "The ServiceNow change request number (e.g., CHG0012345)."
            - name: approval_decision
              in: body
              type: string
              description: "The approval decision: approved or rejected."
            - name: approver_comments
              in: body
              type: string
              description: "Comments from the approver explaining the decision."
          steps:
            - name: get-change
              type: call
              call: "servicenow-lookup.get-change"
              with:
                number: "{{change_number}}"
            - name: update-change
              type: call
              call: "servicenow-update.update-change-status"
              with:
                sys_id: "{{get-change.sys_id}}"
                state: "{{approval_decision}}"
                comments: "{{approver_comments}}"
            - name: notify-cab
              type: call
              call: "slack.post-message"
              with:
                channel: "change-advisory-board"
                text: "Change {{change_number}} - {{get-change.short_description}}: {{approval_decision}}. Comments: {{approver_comments}}"
  consumes:
    - type: http
      namespace: servicenow-lookup
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-request
          path: "/table/change_request"
          operations:
            - name: get-change
              method: GET
    - type: http
      namespace: servicenow-update
      baseUri: "https://meta.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: change-record
          path: "/table/change_request/{{sys_id}}"
          inputParameters:
            - name: sys_id
              in: path
          operations:
            - name: update-change-status
              method: PATCH
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for advertising fraud detection metrics and posts to the trust and safety Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Ad Fraud Detection Report"
  description: "Queries Snowflake for advertising fraud detection metrics and posts to the trust and safety Slack channel."
  tags:
    - trust-safety
    - snowflake
    - slack
    - advertising
capability:
  exposes:
    - type: mcp
      namespace: fraud-ops
      port: 8080
      tools:
        - name: handle-fraud-report
          description: "Given a period, query ad fraud metrics and post to trust and safety."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-fraud
              type: call
              call: snowflake-fraud.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-trust.post-message
              with:
                channel: "trust-safety"
                text: "Ad Fraud Report ({{period}}): Flagged: {{query-fraud.flagged_count}} | Blocked: {{query-fraud.blocked_count}} | Rate: {{query-fraud.fraud_rate}}%"
  consumes:
    - type: http
      namespace: snowflake-fraud
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-trust
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for advertising revenue analytics by platform and region.

naftiko: "0.5"
info:
  label: "Snowflake Ad Revenue Analytics Query"
  description: "Queries Snowflake for advertising revenue analytics by platform and region."
  tags:
    - analytics
    - snowflake
    - advertising
capability:
  exposes:
    - type: mcp
      namespace: ad-analytics
      port: 8080
      tools:
        - name: get-ad-revenue
          description: "Given a platform and region, return ad revenue analytics from Snowflake. Use for business intelligence dashboards."
          inputParameters:
            - name: platform
              in: body
              type: string
              description: "Platform (e.g. Facebook, Instagram, WhatsApp)."
            - name: region
              in: body
              type: string
              description: "Geographic region."
          call: "snowflake-ads.run-query"
          with:
            platform: "{{platform}}"
            region: "{{region}}"
          outputParameters:
            - name: revenue
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-ads
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Generates AI training cost analytics from Snowflake and posts to the finance Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake AI Model Training Cost Report"
  description: "Generates AI training cost analytics from Snowflake and posts to the finance Slack channel."
  tags:
    - finance
    - snowflake
    - slack
    - ai
capability:
  exposes:
    - type: mcp
      namespace: ai-finance
      port: 8080
      tools:
        - name: handle-training-costs
          description: "Given a period, generate training cost report."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-costs
              type: call
              call: snowflake-ai-cost.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-fin.post-message
              with:
                channel: "finance-ops"
                text: "AI Training Costs ({{period}}): Total: ${{query-costs.total}} | GPU-hours: {{query-costs.gpu_hours}} | Cost/hour: ${{query-costs.cost_per_hour}}"
  consumes:
    - type: http
      namespace: snowflake-ai-cost
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-fin
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries business messaging KPIs from Snowflake and posts to the business messaging Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Business Messaging KPI Report"
  description: "Queries business messaging KPIs from Snowflake and posts to the business messaging Slack channel."
  tags:
    - messaging
    - snowflake
    - slack
    - kpi
capability:
  exposes:
    - type: mcp
      namespace: biz-msg-ops
      port: 8080
      tools:
        - name: handle-messaging-kpi
          description: "Given a period, query messaging KPIs and post."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-kpis
              type: call
              call: snowflake-bizmsg.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-bizmsg.post-message
              with:
                channel: "business-messaging"
                text: "Messaging KPIs ({{period}}): Businesses: {{query-kpis.active_businesses}} | Messages: {{query-kpis.total_messages}} | Revenue: ${{query-kpis.revenue}}"
  consumes:
    - type: http
      namespace: snowflake-bizmsg
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-bizmsg
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for content moderation effectiveness metrics across platforms.

naftiko: "0.5"
info:
  label: "Snowflake Content Moderation Metrics Query"
  description: "Queries Snowflake for content moderation effectiveness metrics across platforms."
  tags:
    - trust-safety
    - snowflake
    - moderation
capability:
  exposes:
    - type: mcp
      namespace: moderation-analytics
      port: 8080
      tools:
        - name: get-moderation-metrics
          description: "Given a platform and period, return content moderation metrics from Snowflake."
          inputParameters:
            - name: platform
              in: body
              type: string
              description: "Platform name."
            - name: period
              in: body
              type: string
              description: "Reporting period."
          call: "snowflake-mod.run-query"
          with:
            platform: "{{platform}}"
            period: "{{period}}"
          outputParameters:
            - name: metrics
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-mod
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries Snowflake for data quality rule violations in production data pipelines, creates Jira issues for critical failures, and posts alerts to the data engineering Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Data Quality Alert"
  description: "Queries Snowflake for data quality rule violations in production data pipelines, creates Jira issues for critical failures, and posts alerts to the data engineering Slack channel."
  tags:
    - data
    - analytics
    - snowflake
    - jira
    - slack
    - monitoring
capability:
  exposes:
    - type: mcp
      namespace: data-quality-ops
      port: 8080
      tools:
        - name: check-data-quality
          description: "Execute data quality checks in Snowflake for a specified database, create Jira issues for any violations, and post a summary to the data engineering Slack channel."
          inputParameters:
            - name: database_name
              in: body
              type: string
              description: "The Snowflake database to run quality checks against."
            - name: quality_schema
              in: body
              type: string
              description: "The schema containing data quality check results."
          steps:
            - name: run-quality-checks
              type: call
              call: "snowflake.query-quality-violations"
              with:
                database_name: "{{database_name}}"
                schema: "{{quality_schema}}"
            - name: create-issue
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Data quality violations in {{database_name}}: {{run-quality-checks.violation_count}} issues"
                description: "{{run-quality-checks.violation_summary}}"
            - name: notify-data-team
              type: call
              call: "slack.post-message"
              with:
                channel: "data-engineering"
                text: "Data Quality Alert in {{database_name}}: {{run-quality-checks.violation_count}} violations. Jira: {{create-issue.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: query-quality-violations
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries data center power consumption from Snowflake and posts to the sustainability Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Data Center Power Report"
  description: "Queries data center power consumption from Snowflake and posts to the sustainability Slack channel."
  tags:
    - sustainability
    - snowflake
    - slack
    - datacenter
capability:
  exposes:
    - type: mcp
      namespace: power-ops
      port: 8080
      tools:
        - name: handle-power-report
          description: "Given a DC ID and period, query power data and post."
          inputParameters:
            - name: datacenter_id
              in: body
              type: string
              description: "Data center ID."
            - name: period
              in: body
              type: string
              description: "Period."
          steps:
            - name: query-power
              type: call
              call: snowflake-power.run-query
              with:
                dc: "{{datacenter_id}}"
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-green.post-message
              with:
                channel: "sustainability"
                text: "Power ({{datacenter_id}}, {{period}}): Total: {{query-power.total_kwh}} kWh | PUE: {{query-power.pue}}"
  consumes:
    - type: http
      namespace: snowflake-power
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-green
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries developer platform growth metrics from Snowflake and posts to developer relations Slack.

naftiko: "0.5"
info:
  label: "Snowflake Developer Platform Growth Report"
  description: "Queries developer platform growth metrics from Snowflake and posts to developer relations Slack."
  tags:
    - devrel
    - snowflake
    - slack
    - growth
capability:
  exposes:
    - type: mcp
      namespace: devrel-ops
      port: 8080
      tools:
        - name: handle-devrel-growth
          description: "Given a period, query developer growth and post."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Period."
          steps:
            - name: query-growth
              type: call
              call: snowflake-devrel.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-devrel.post-message
              with:
                channel: "developer-relations"
                text: "DevRel ({{period}}): New devs: {{query-growth.new_devs}} | Active apps: {{query-growth.active_apps}} | API calls: {{query-growth.api_calls}}"
  consumes:
    - type: http
      namespace: snowflake-devrel
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-devrel
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for Meta app marketplace analytics and posts to the platform Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Marketplace App Analytics"
  description: "Queries Snowflake for Meta app marketplace analytics and posts to the platform Slack channel."
  tags:
    - platform
    - snowflake
    - slack
    - marketplace
capability:
  exposes:
    - type: mcp
      namespace: marketplace-analytics
      port: 8080
      tools:
        - name: handle-marketplace-report
          description: "Given a period, query marketplace analytics and post to Slack."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-apps
              type: call
              call: snowflake-market.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-market.post-message
              with:
                channel: "platform-analytics"
                text: "Marketplace ({{period}}): New apps: {{query-apps.new_apps}} | DAU: {{query-apps.total_dau}} | Revenue: ${{query-apps.total_revenue}}"
  consumes:
    - type: http
      namespace: snowflake-market
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-market
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for privacy compliance metrics and posts to the privacy team Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Privacy Compliance Report"
  description: "Queries Snowflake for privacy compliance metrics and posts to the privacy team Slack channel."
  tags:
    - privacy
    - snowflake
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: privacy-ops
      port: 8080
      tools:
        - name: handle-privacy-report
          description: "Given a period, query privacy compliance metrics and post to Slack."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-compliance
              type: call
              call: snowflake-privacy.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-privacy.post-message
              with:
                channel: "privacy-compliance"
                text: "Privacy Report ({{period}}): Data requests: {{query-compliance.total_requests}} | Processed: {{query-compliance.processed}} | SLA met: {{query-compliance.sla_met}}%"
  consumes:
    - type: http
      namespace: snowflake-privacy
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-privacy
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Quest headset telemetry from Snowflake and posts a digest to the Reality Labs Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Quest Headset Telemetry Digest"
  description: "Queries Quest headset telemetry from Snowflake and posts a digest to the Reality Labs Slack channel."
  tags:
    - vr
    - snowflake
    - slack
    - reality-labs
capability:
  exposes:
    - type: mcp
      namespace: quest-analytics
      port: 8080
      tools:
        - name: handle-quest-telemetry
          description: "Given a period, query Quest telemetry and post to Reality Labs."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-telemetry
              type: call
              call: snowflake-quest.run-query
              with:
                period: "{{period}}"
            - name: post-digest
              type: call
              call: slack-rl.post-message
              with:
                channel: "reality-labs"
                text: "Quest Telemetry ({{period}}): Active devices: {{query-telemetry.active_devices}} | Avg session: {{query-telemetry.avg_session_min}}min | Crash rate: {{query-telemetry.crash_rate}}%"
  consumes:
    - type: http
      namespace: snowflake-quest
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-rl
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Reels engagement analytics from Snowflake and posts to the product Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake Reels Engagement Analytics"
  description: "Queries Reels engagement analytics from Snowflake and posts to the product Slack channel."
  tags:
    - product
    - snowflake
    - slack
    - reels
capability:
  exposes:
    - type: mcp
      namespace: reels-analytics
      port: 8080
      tools:
        - name: handle-reels-analytics
          description: "Given a period, query Reels engagement and post to Slack."
          inputParameters:
            - name: period
              in: body
              type: string
              description: "Reporting period."
          steps:
            - name: query-engagement
              type: call
              call: snowflake-reels.run-query
              with:
                period: "{{period}}"
            - name: post-report
              type: call
              call: slack-reels.post-message
              with:
                channel: "reels-product"
                text: "Reels ({{period}}): Views: {{query-engagement.total_views}} | Shares: {{query-engagement.shares}} | Completion: {{query-engagement.completion_rate}}%"
  consumes:
    - type: http
      namespace: snowflake-reels
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: slack-reels
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for user growth metrics across Meta platforms.

naftiko: "0.5"
info:
  label: "Snowflake User Growth Metrics Query"
  description: "Queries Snowflake for user growth metrics across Meta platforms."
  tags:
    - analytics
    - snowflake
    - growth
capability:
  exposes:
    - type: mcp
      namespace: growth-analytics
      port: 8080
      tools:
        - name: get-user-growth
          description: "Given a platform and period, return user growth metrics from Snowflake. Use for product analytics."
          inputParameters:
            - name: platform
              in: body
              type: string
              description: "Platform name (Facebook, Instagram, Threads)."
            - name: period
              in: body
              type: string
              description: "Reporting period."
          call: "snowflake-growth.run-query"
          with:
            platform: "{{platform}}"
            period: "{{period}}"
          outputParameters:
            - name: growth
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-growth
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries Snowflake for WhatsApp Business API message volume analytics.

naftiko: "0.5"
info:
  label: "Snowflake WhatsApp Message Volume Query"
  description: "Queries Snowflake for WhatsApp Business API message volume analytics."
  tags:
    - analytics
    - snowflake
    - whatsapp
capability:
  exposes:
    - type: mcp
      namespace: wa-analytics
      port: 8080
      tools:
        - name: get-message-volume
          description: "Given a date range, return WhatsApp message volume stats from Snowflake. Use for capacity planning."
          inputParameters:
            - name: date_from
              in: body
              type: string
              description: "Start date (YYYY-MM-DD)."
          call: "snowflake-wa.run-query"
          with:
            date_from: "{{date_from}}"
          outputParameters:
            - name: volume
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-wa
      baseUri: "https://meta.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Creates a new Terraform Cloud workspace for an engineering team, links it to GitHub, and notifies the platform engineering team via Slack.

naftiko: "0.5"
info:
  label: "Terraform Cloud Infrastructure Workspace Provisioning"
  description: "Creates a new Terraform Cloud workspace for an engineering team, links it to GitHub, and notifies the platform engineering team via Slack."
  tags:
    - cloud
    - infrastructure
    - terraform
    - github
    - slack
    - provisioning
capability:
  exposes:
    - type: mcp
      namespace: infra-provisioning
      port: 8080
      tools:
        - name: provision-team-workspace
          description: "Given a team name, GitHub repository, and target environment, create a Terraform Cloud workspace, link the VCS repository, and notify the platform engineering Slack channel."
          inputParameters:
            - name: team_name
              in: body
              type: string
              description: "The engineering team name for workspace naming."
            - name: repository
              in: body
              type: string
              description: "The GitHub repository to link (e.g., facebook/infrastructure)."
            - name: environment
              in: body
              type: string
              description: "Target environment: dev, staging, or production."
          steps:
            - name: create-workspace
              type: call
              call: "terraform.create-workspace"
              with:
                name: "{{team_name}}-{{environment}}"
                vcs_repo: "{{repository}}"
            - name: notify-platform
              type: call
              call: "slack.post-message"
              with:
                channel: "platform-engineering"
                text: "Workspace created: {{team_name}}-{{environment}} linked to {{repository}}. ID: {{create-workspace.workspace_id}}"
  consumes:
    - type: http
      namespace: terraform
      baseUri: "https://app.terraform.io/api/v2"
      authentication:
        type: bearer
        token: "$secrets.terraform_token"
      resources:
        - name: workspaces
          path: "/organizations/meta/workspaces"
          operations:
            - name: create-workspace
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves message delivery and read rate metrics from the Meta Graph API for WhatsApp Business accounts and posts a daily performance report to Slack.

naftiko: "0.5"
info:
  label: "WhatsApp Business API Delivery Report"
  description: "Retrieves message delivery and read rate metrics from the Meta Graph API for WhatsApp Business accounts and posts a daily performance report to Slack."
  tags:
    - marketing
    - whatsapp
    - meta-graph
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: whatsapp-reporting
      port: 8080
      tools:
        - name: publish-whatsapp-delivery-report
          description: "Given a WhatsApp Business Account ID and date, retrieve message delivery and read rate analytics from the Meta Graph API and post a daily report to the messaging Slack channel."
          inputParameters:
            - name: waba_id
              in: body
              type: string
              description: "The WhatsApp Business Account ID to report on."
            - name: report_date
              in: body
              type: string
              description: "The date to retrieve metrics for (YYYY-MM-DD)."
          steps:
            - name: get-analytics
              type: call
              call: "meta-graph.get-whatsapp-analytics"
              with:
                waba_id: "{{waba_id}}"
                start: "{{report_date}}"
                end: "{{report_date}}"
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "whatsapp-ops"
                text: "WhatsApp Report ({{report_date}}): Sent: {{get-analytics.sent}} | Delivered: {{get-analytics.delivered}} | Read: {{get-analytics.read}} | Delivery Rate: {{get-analytics.delivery_rate}}%"
  consumes:
    - type: http
      namespace: meta-graph
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.meta_graph_token"
      resources:
        - name: whatsapp-analytics
          path: "/{{waba_id}}/analytics"
          inputParameters:
            - name: waba_id
              in: path
          operations:
            - name: get-whatsapp-analytics
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Initiates annual performance reviews in Workday, creates tracking tasks, and notifies HR in Slack.

naftiko: "0.5"
info:
  label: "Workday Annual Review Cycle Launcher"
  description: "Initiates annual performance reviews in Workday, creates tracking tasks, and notifies HR in Slack."
  tags:
    - hr
    - workday
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: review-ops
      port: 8080
      tools:
        - name: handle-review-launch
          description: "Given a cycle name and date, create tracking and notify HR."
          inputParameters:
            - name: cycle_name
              in: body
              type: string
              description: "Review cycle name."
            - name: target_date
              in: body
              type: string
              description: "Target completion date."
          steps:
            - name: create-tracking
              type: call
              call: jira-hr.create-issue
              with:
                project_key: "HR"
                issuetype: "Epic"
                summary: "Review: {{cycle_name}} — Due {{target_date}}"
            - name: notify-hr
              type: call
              call: slack-hr.post-message
              with:
                channel: "hr-business-partners"
                text: "REVIEW CYCLE: {{cycle_name}} | Due: {{target_date}} | {{create-tracking.key}}"
  consumes:
    - type: http
      namespace: jira-hr
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-hr
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks employee benefits enrollment status in Workday.

naftiko: "0.5"
info:
  label: "Workday Benefits Enrollment Check"
  description: "Checks employee benefits enrollment status in Workday."
  tags:
    - hr
    - workday
    - benefits
capability:
  exposes:
    - type: mcp
      namespace: benefits-ops
      port: 8080
      tools:
        - name: get-enrollment
          description: "Given an employee ID, return benefits enrollment status from Workday."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
          call: "workday-benefits.get-enrollment"
          with:
            employee_id: "{{employee_id}}"
          outputParameters:
            - name: enrollment
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: workday-benefits
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: enrollments
          path: "/benefitEnrollments/{{employee_id}}"
          inputParameters:
            - name: employee_id
              in: path
          operations:
            - name: get-enrollment
              method: GET

Retrieves compensation band details from Workday and posts to the HR ops Slack channel.

naftiko: "0.5"
info:
  label: "Workday Compensation Band Lookup"
  description: "Retrieves compensation band details from Workday and posts to the HR ops Slack channel."
  tags:
    - hr
    - workday
    - slack
    - compensation
capability:
  exposes:
    - type: mcp
      namespace: comp-ops
      port: 8080
      tools:
        - name: handle-comp-lookup
          description: "Given a job profile, retrieve comp band and notify HR."
          inputParameters:
            - name: job_profile_id
              in: body
              type: string
              description: "Workday job profile ID."
          steps:
            - name: get-band
              type: call
              call: workday-comp.get-band
              with:
                job_profile_id: "{{job_profile_id}}"
            - name: notify-hr
              type: call
              call: slack-comp.post-message
              with:
                channel: "hr-operations"
                text: "Comp Band: {{job_profile_id}} | Min: ${{get-band.min}} | Mid: ${{get-band.mid}} | Max: ${{get-band.max}}"
  consumes:
    - type: http
      namespace: workday-comp
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: bands
          path: "/compensationBands/{{job_profile_id}}"
          inputParameters:
            - name: job_profile_id
              in: path
          operations:
            - name: get-band
              method: GET
    - type: http
      namespace: slack-comp
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates contractor onboarding from Workday and notifies the hiring manager in Slack.

naftiko: "0.5"
info:
  label: "Workday Contractor Onboarding"
  description: "Orchestrates contractor onboarding from Workday and notifies the hiring manager in Slack."
  tags:
    - hr
    - workday
    - slack
    - contractors
capability:
  exposes:
    - type: mcp
      namespace: contractor-ops
      port: 8080
      tools:
        - name: handle-contractor-start
          description: "Given a worker ID, retrieve details and notify hiring manager."
          inputParameters:
            - name: worker_id
              in: body
              type: string
              description: "Workday worker ID."
          steps:
            - name: get-worker
              type: call
              call: workday-contr.get-worker
              with:
                worker_id: "{{worker_id}}"
            - name: notify-manager
              type: call
              call: slack-contr.post-message
              with:
                channel: "contractor-onboarding"
                text: "CONTRACTOR: {{get-worker.fullName}} | Role: {{get-worker.jobTitle}} | Provision access."
  consumes:
    - type: http
      namespace: workday-contr
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: slack-contr
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls diversity metrics from Workday and posts to the HR leadership Slack channel.

naftiko: "0.5"
info:
  label: "Workday Diversity Metrics Report"
  description: "Pulls diversity metrics from Workday and posts to the HR leadership Slack channel."
  tags:
    - hr
    - workday
    - slack
    - dei
capability:
  exposes:
    - type: mcp
      namespace: dei-ops
      port: 8080
      tools:
        - name: handle-dei-report
          description: "Given a quarter, pull diversity metrics and post to HR leadership."
          inputParameters:
            - name: quarter
              in: body
              type: string
              description: "Quarter identifier."
          steps:
            - name: get-metrics
              type: call
              call: workday-dei.get-report
              with:
                quarter: "{{quarter}}"
            - name: post-report
              type: call
              call: slack-dei.post-message
              with:
                channel: "hr-leadership"
                text: "DEI ({{quarter}}): Headcount: {{get-metrics.total}} | Gender: {{get-metrics.gender_ratio}}"
  consumes:
    - type: http
      namespace: workday-dei
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: reports
          path: "/diversityMetrics"
          inputParameters:
            - name: quarter
              in: query
          operations:
            - name: get-report
              method: GET
    - type: http
      namespace: slack-dei
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves current engineering team headcount from Workday by department.

naftiko: "0.5"
info:
  label: "Workday Engineering Headcount Snapshot"
  description: "Retrieves current engineering team headcount from Workday by department."
  tags:
    - hr
    - workday
    - engineering
capability:
  exposes:
    - type: mcp
      namespace: hr-analytics
      port: 8080
      tools:
        - name: get-eng-headcount
          description: "Given a department, return current engineering headcount from Workday. Use for workforce planning."
          inputParameters:
            - name: department
              in: body
              type: string
              description: "Department name."
          call: "workday-eng.get-headcount"
          with:
            department: "{{department}}"
          outputParameters:
            - name: headcount
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: workday-eng
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: headcount
          path: "/headcountReport"
          inputParameters:
            - name: department
              in: query
          operations:
            - name: get-headcount
              method: GET

Retrieves current headcount grouped by team and cost center from Workday for workforce planning and finance reporting.

naftiko: "0.5"
info:
  label: "Workday Headcount Snapshot"
  description: "Retrieves current headcount grouped by team and cost center from Workday for workforce planning and finance reporting."
  tags:
    - hr
    - reporting
    - workday
    - headcount
    - finance
capability:
  exposes:
    - type: mcp
      namespace: hr-reporting
      port: 8080
      tools:
        - name: get-headcount-snapshot
          description: "Returns current headcount grouped by team and cost center from Workday. Use for workforce planning, budget reviews, and executive reporting."
          call: "workday.list-workers"
          outputParameters:
            - name: workers
              type: array
              mapping: "$.Report_Entry"
              items:
                - name: employee_id
                  type: string
                  mapping: "$.Employee_ID"
                - name: full_name
                  type: string
                  mapping: "$.Employee_Name"
                - name: team
                  type: string
                  mapping: "$.Department"
                - name: cost_center
                  type: string
                  mapping: "$.Cost_Center"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: workers
          path: "/meta/workers"
          operations:
            - name: list-workers
              method: GET

Tracks intern program metrics from Workday and posts to the talent Slack channel.

naftiko: "0.5"
info:
  label: "Workday Intern Program Tracker"
  description: "Tracks intern program metrics from Workday and posts to the talent Slack channel."
  tags:
    - hr
    - workday
    - slack
    - internship
capability:
  exposes:
    - type: mcp
      namespace: intern-ops
      port: 8080
      tools:
        - name: handle-intern-tracking
          description: "Given a program year, track metrics and post."
          inputParameters:
            - name: program_year
              in: body
              type: string
              description: "Program year."
          steps:
            - name: get-metrics
              type: call
              call: workday-intern.get-report
              with:
                year: "{{program_year}}"
            - name: post-update
              type: call
              call: slack-talent.post-message
              with:
                channel: "talent-programs"
                text: "Intern Program ({{program_year}}): Active: {{get-metrics.active}} | Offers: {{get-metrics.offers}} | Conversion: {{get-metrics.conversion}}%"
  consumes:
    - type: http
      namespace: workday-intern
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: reports
          path: "/internProgram"
          inputParameters:
            - name: year
              in: query
          operations:
            - name: get-report
              method: GET
    - type: http
      namespace: slack-talent
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new engineering position is approved in Workday, creates a GitHub team for the role and opens a Jira recruiting task for the talent acquisition team.

naftiko: "0.5"
info:
  label: "Workday Job Requisition to GitHub Team"
  description: "When a new engineering position is approved in Workday, creates a GitHub team for the role and opens a Jira recruiting task for the talent acquisition team."
  tags:
    - hr
    - recruiting
    - workday
    - github
    - jira
capability:
  exposes:
    - type: mcp
      namespace: talent-acquisition
      port: 8080
      tools:
        - name: create-engineering-requisition
          description: "Given a Workday job requisition ID for an engineering role, retrieve requisition details, create a GitHub team for the role, and create a Jira recruiting task."
          inputParameters:
            - name: requisition_id
              in: body
              type: string
              description: "The Workday position requisition ID for the engineering role."
          steps:
            - name: get-requisition
              type: call
              call: "workday.get-job-requisition"
              with:
                requisition_id: "{{requisition_id}}"
            - name: create-github-team
              type: call
              call: "github.create-team"
              with:
                org: "facebook"
                name: "candidate-{{requisition_id}}"
                description: "Interview team for {{get-requisition.job_title}}"
            - name: create-jira-task
              type: call
              call: "jira.create-issue"
              with:
                project_key: "TA"
                issuetype: "Task"
                summary: "Recruit: {{get-requisition.job_title}} - {{get-requisition.department}}"
                description: "Workday Req: {{requisition_id}} | Team: {{get-requisition.department}} | Level: {{get-requisition.job_level}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: job-requisitions
          path: "/meta/jobRequisitions/{{requisition_id}}"
          inputParameters:
            - name: requisition_id
              in: path
          operations:
            - name: get-job-requisition
              method: GET
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: teams
          path: "/orgs/{{org}}/teams"
          inputParameters:
            - name: org
              in: path
          operations:
            - name: create-team
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://meta.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

When a leave request is submitted in Workday, notifies the manager in Slack.

naftiko: "0.5"
info:
  label: "Workday Leave Request Notification"
  description: "When a leave request is submitted in Workday, notifies the manager in Slack."
  tags:
    - hr
    - workday
    - slack
    - leave-management
capability:
  exposes:
    - type: mcp
      namespace: leave-ops
      port: 8080
      tools:
        - name: handle-leave-request
          description: "Given employee ID and dates, notify manager."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
            - name: leave_dates
              in: body
              type: string
              description: "Leave dates."
          steps:
            - name: get-worker
              type: call
              call: workday-leave.get-worker
              with:
                employee_id: "{{employee_id}}"
            - name: notify
              type: call
              call: slack-leave.post-message
              with:
                channel: "manager-approvals"
                text: "LEAVE: {{get-worker.fullName}} | {{leave_dates}} | Review in Workday."
  consumes:
    - type: http
      namespace: workday-leave
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{employee_id}}"
          inputParameters:
            - name: employee_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: slack-leave
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new hire starts in Workday, provisions access and notifies the team in Slack.

naftiko: "0.5"
info:
  label: "Workday New Hire Onboarding Notification"
  description: "When a new hire starts in Workday, provisions access and notifies the team in Slack."
  tags:
    - hr
    - workday
    - slack
    - onboarding
capability:
  exposes:
    - type: mcp
      namespace: onboarding-ops
      port: 8080
      tools:
        - name: handle-new-hire
          description: "Given a Workday employee ID, retrieve details and notify the team."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
          steps:
            - name: get-worker
              type: call
              call: workday-onboard.get-worker
              with:
                employee_id: "{{employee_id}}"
            - name: notify-team
              type: call
              call: slack-onboard.post-message
              with:
                channel: "new-hires"
                text: "NEW HIRE: {{get-worker.fullName}} | Role: {{get-worker.jobTitle}} | Please complete onboarding checklist."
  consumes:
    - type: http
      namespace: workday-onboard
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{employee_id}}"
          inputParameters:
            - name: employee_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: slack-onboard
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the count of open job requisitions in Workday for hiring pipeline tracking.

naftiko: "0.5"
info:
  label: "Workday Open Requisitions Count"
  description: "Returns the count of open job requisitions in Workday for hiring pipeline tracking."
  tags:
    - hr
    - workday
    - recruiting
capability:
  exposes:
    - type: mcp
      namespace: talent-ops
      port: 8080
      tools:
        - name: get-open-reqs
          description: "Given a team name, return open requisitions from Workday. Use for hiring dashboards."
          inputParameters:
            - name: team
              in: body
              type: string
              description: "Team name."
          call: "workday-recruit.get-requisitions"
          with:
            team: "{{team}}"
          outputParameters:
            - name: requisitions
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: workday-recruit
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: requisitions
          path: "/jobRequisitions"
          inputParameters:
            - name: team
              in: query
          operations:
            - name: get-requisitions
              method: GET

When an employee termination is processed in Workday, notifies IT security for access revocation in Slack.

naftiko: "0.5"
info:
  label: "Workday Termination Access Revocation"
  description: "When an employee termination is processed in Workday, notifies IT security for access revocation in Slack."
  tags:
    - hr
    - workday
    - slack
    - security
capability:
  exposes:
    - type: mcp
      namespace: offboard-ops
      port: 8080
      tools:
        - name: handle-termination
          description: "Given a Workday employee ID, notify IT for access revocation."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
          steps:
            - name: get-worker
              type: call
              call: workday-term.get-worker
              with:
                employee_id: "{{employee_id}}"
            - name: notify-security
              type: call
              call: slack-sec.post-message
              with:
                channel: "it-security"
                text: "ACCESS REVOCATION: {{get-worker.fullName}} ({{employee_id}}) | Revoke all access immediately."
  consumes:
    - type: http
      namespace: workday-term
      baseUri: "https://wd5-impl-services1.workday.com/ccx/api/v1/meta"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{employee_id}}"
          inputParameters:
            - name: employee_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: slack-sec
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST