Infracost MCP Server

Instructions

Implementation Reference

• src/tools.ts:692-768 (handler)

  Main handler function that validates input, prepares the API request by transforming scope and notification settings, calls the Cloud API client to update the guardrail, and returns the result.

  async handleUpdateGuardrail(args: z.infer<typeof UpdateGuardrailSchema>) {
    if (!this.cloudApiClient) {
      throw new Error('INFRACOST_SERVICE_TOKEN is not configured for Infracost Cloud API operations');
    }
  
    const orgSlug = args.orgSlug || this.config.orgSlug;
    if (!orgSlug) {
      throw new Error('Organization slug is required. Provide it via orgSlug parameter or set INFRACOST_ORG environment variable');
    }
  
    const {
      orgSlug: _,
      guardrailId,
      scope,
      blockPullRequest,
      commentOnPullRequest,
      emailRecipientOrgMemberIds,
      mailingListEmails,
      msTeamsEmails,
      ...rest
    } = args;
  
    const apiRequest: any = {
      ...rest,
    };
  
    if (scope) {
      if (scope.type === 'ALL_PROJECTS' || scope.type === 'REPO') {
        apiRequest.scope = 'REPO';
      } else {
        apiRequest.scope = 'PROJECT';
      }
      const filters: any = {};
  
      if (scope.repositories && scope.repositories.length > 0) {
        filters.repos = { include: scope.repositories };
      }
      if (scope.projects && scope.projects.length > 0) {
        filters.projects = { include: scope.projects };
      }
  
      if (Object.keys(filters).length > 0) {
        apiRequest.filters = filters;
      }
    }
  
    if (commentOnPullRequest !== undefined) {
      apiRequest.prComment = commentOnPullRequest;
    }
    if (blockPullRequest !== undefined) {
      apiRequest.blockPr = blockPullRequest;
    }
    if (emailRecipientOrgMemberIds !== undefined) {
      apiRequest.emailRecipientOrgMemberIds = emailRecipientOrgMemberIds;
    }
    if (mailingListEmails !== undefined) {
      apiRequest.mailingListEmails = mailingListEmails;
    }
    if (msTeamsEmails !== undefined) {
      apiRequest.msTeamsEmails = msTeamsEmails;
    }
  
    const result = await this.cloudApiClient.updateGuardrail(orgSlug, guardrailId, apiRequest);
  
    if (!result.success) {
      throw new Error(result.error || 'Update guardrail request failed');
    }
  
    return {
      content: [
        {
          type: 'text',
          text: result.output || 'Guardrail updated successfully',
        },
      ],
    };
  }

• src/tools.ts:223-268 (schema)

  Zod schema defining the input parameters for the tool, including guardrail ID, thresholds, scope, notifications, etc.

  export const UpdateGuardrailSchema = z.object({
    orgSlug: z.string().optional().describe('Organization slug from Infracost Cloud (defaults to INFRACOST_ORG env var)'),
    guardrailId: z.string().describe('Guardrail ID'),
    name: z.string().optional().describe('Name for the guardrail'),
    scope: z
      .object({
        type: z
          .enum(['ALL_PROJECTS', 'REPO', 'PROJECT'])
          .describe('Scope type for the guardrail'),
        repositories: z.array(z.string()).optional().describe('Repository names (for REPO scope)'),
        projects: z.array(z.string()).optional().describe('Project names (for PROJECT scope)'),
      })
      .optional()
      .describe('Scope configuration'),
    increaseThreshold: z
      .number()
      .optional()
      .describe('Threshold for cost increases (monthly dollar amount)'),
    increasePercentThreshold: z
      .number()
      .optional()
      .describe('Threshold for cost increases (percentage)'),
    totalThreshold: z
      .number()
      .optional()
      .describe('Threshold for total cost (monthly dollar amount)'),
    message: z.string().optional().describe('Custom message to display when threshold is exceeded'),
    webhookUrl: z.string().default('').describe('Webhook URL to notify when threshold is exceeded (defaults to empty string if not needed)'),
    blockPullRequest: z.boolean().optional().describe('Whether to block PR when threshold is exceeded'),
    commentOnPullRequest: z
      .boolean()
      .optional()
      .describe('Whether to comment on PR when threshold is exceeded'),
    emailRecipientOrgMemberIds: z
      .array(z.string())
      .optional()
      .describe('Array of organization member IDs to email'),
    mailingListEmails: z
      .array(z.string())
      .optional()
      .describe('Array of email addresses to notify'),
    msTeamsEmails: z
      .array(z.string())
      .optional()
      .describe('Array of MS Teams email addresses to notify'),
  });

• src/index.ts:769-772 (registration)

  Switch case in CallToolRequestSchema handler that parses arguments with UpdateGuardrailSchema and delegates to InfracostTools.handleUpdateGuardrail.

  case 'infracost_cloud_update_guardrail': {
    const validatedArgs = UpdateGuardrailSchema.parse(args);
    return await tools.handleUpdateGuardrail(validatedArgs);
  }

• src/index.ts:590-656 (registration)

  Tool registration in ListToolsRequestSchema response, including name, description, and input schema.

  {
    name: 'infracost_cloud_update_guardrail',
    description:
      'Update an existing guardrail in Infracost Cloud. Requires INFRACOST_SERVICE_TOKEN environment variable.',
    inputSchema: {
      type: 'object',
      properties: {
        orgSlug: {
          type: 'string',
          description: 'Organization slug from Infracost Cloud (defaults to INFRACOST_ORG env var)',
        },
        guardrailId: {
          type: 'string',
          description: 'Guardrail ID',
        },
        name: {
          type: 'string',
          description: 'Name for the guardrail',
        },
        filters: {
          type: 'array',
          description: 'Filters to limit scope of the guardrail',
          items: {
            type: 'object',
            properties: {
              type: {
                type: 'string',
                enum: ['project', 'repository'],
                description: 'Filter type',
              },
              value: { type: 'string', description: 'Filter value' },
            },
            required: ['type', 'value'],
          },
        },
        increaseThreshold: {
          type: 'number',
          description: 'Threshold for cost increases (monthly dollar amount)',
        },
        increasePercentThreshold: {
          type: 'number',
          description: 'Threshold for cost increases (percentage)',
        },
        totalThreshold: {
          type: 'number',
          description: 'Threshold for total cost (monthly dollar amount)',
        },
        message: {
          type: 'string',
          description: 'Custom message to display when threshold is exceeded',
        },
        webhookUrl: {
          type: 'string',
          description: 'Webhook URL to notify when threshold is exceeded',
        },
        blockPullRequest: {
          type: 'boolean',
          description: 'Whether to block PR when threshold is exceeded',
        },
        commentOnPullRequest: {
          type: 'boolean',
          description: 'Whether to comment on PR when threshold is exceeded',
        },
      },
      required: ['guardrailId'],
    },
  },

• src/api.ts:314-353 (helper)

  API client method that performs the PATCH request to the Infracost Cloud API endpoint to update the guardrail.

  async updateGuardrail(
    orgSlug: string,
    guardrailId: string,
    request: UpdateGuardrailRequest
  ): Promise<CommandResult> {
    try {
      const response = await fetch(
        `${INFRACOST_CLOUD_API_BASE}/orgs/${orgSlug}/guardrails/${guardrailId}`,
        {
          method: 'PATCH',
          headers: {
            'Content-Type': 'application/json',
            Authorization: `Bearer ${this.serviceToken}`,
          },
          body: JSON.stringify({ data: { type: 'guardrails', attributes: request } }),
        }
      );
  
      if (!response.ok) {
        const errorText = await response.text();
        return {
          success: false,
          error: `API request failed with status ${response.status}: ${errorText}`,
        };
      }
  
      const data = await response.json();
  
      return {
        success: true,
        output: JSON.stringify(data, null, 2),
        data,
      };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error occurred',
      };
    }
  }