github_code_security_delete_configuration

Instructions

Implementation Reference

• src/tools/code-security.ts:188-190 (handler)

  The handler function for the github_code_security_delete_configuration tool. It makes a DELETE request to /orgs/{org}/code-security/configurations/{configuration_id} to delete a code security configuration for an organization.

  handler: async (args: Record<string, any>) => {
    return githubRequest("DELETE", `/orgs/${args.org}/code-security/configurations/${args.configuration_id}`, undefined, undefined);
  },

• src/tools/code-security.ts:184-187 (schema)

  The input schema for the github_code_security_delete_configuration tool, requiring 'org' (string) and 'configuration_id' (string) parameters.

  inputSchema: z.object({
    org: z.string().describe("org"),
    configuration_id: z.string().describe("configuration_id")
  }),

• src/tools/code-security.ts:182-182 (registration)

  The tool is defined as part of the codeSecurityTools array with name 'github_code_security_delete_configuration' and description 'Delete a code security configuration'.

  name: "github_code_security_delete_configuration",

• src/index.ts:110-130 (registration)

  The tool is registered with the MCP server via server.tool() using its name, description, inputSchema shape, and handler function from the codeSecurityTools array.

  for (const tool of allTools) {
    server.tool(
      tool.name,
      tool.description,
      tool.inputSchema.shape as any,
      async (args: any) => {
        try {
          const result = await tool.handler(args as any);
          return {
            content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
          };
        } catch (err) {
          const message = err instanceof Error ? err.message : String(err);
          return {
            content: [{ type: "text" as const, text: `Error: ${message}` }],
            isError: true,
          };
        }
      }
    );
  }

• src/client.ts:9-59 (helper)

  The githubRequest helper function that performs the actual HTTP request to the GitHub API. It constructs the URL, sets auth headers, sends the request, and handles error responses.

  export async function githubRequest<T>(
    method: string,
    path: string,
    body?: Record<string, unknown>,
    params?: Record<string, string | number | boolean | string[] | undefined>
  ): Promise<T> {
    const url = new URL(`${BASE_URL}${path}`);
  
    if (params) {
      for (const [key, value] of Object.entries(params)) {
        if (value === undefined || value === null || value === "") continue;
        if (Array.isArray(value)) {
          url.searchParams.set(key, value.join(","));
        } else {
          url.searchParams.set(key, String(value));
        }
      }
    }
  
    const headers: Record<string, string> = {
      Authorization: `Bearer ${getToken()}`,
      Accept: "application/vnd.github+json",
      "X-GitHub-Api-Version": "2022-11-28",
      "User-Agent": "github-mcp/1.0.0",
    };
  
    if (body) {
      headers["Content-Type"] = "application/json";
    }
  
    const res = await fetch(url.toString(), {
      method,
      headers,
      body: body ? JSON.stringify(body) : undefined,
    });
  
    if (!res.ok) {
      const text = await res.text().catch(() => "");
      let detail = text;
      try {
        const json = JSON.parse(text);
        detail = json.message || text;
        if (json.errors) detail += ` -- ${JSON.stringify(json.errors)}`;
      } catch {}
      throw new Error(`GitHub API error ${res.status}: ${detail}`);
    }
  
    if (res.status === 204) return {} as T;
  
    return res.json() as Promise<T>;
  }