QIT MCP Server

Instructions

Implementation Reference

• src/tools/config.ts:36-96 (handler)

  The main handler function for the 'manage_config' tool. It parses the action and arguments, constructs the corresponding QIT CLI command, and executes it using buildArgs and executeAndFormat.

  handler: async (args: {
    action: (typeof configActions)[number];
    name?: string;
    url?: string;
    tunnel_method?: string;
  }) => {
    let command: string;
    let positional: string[] = [];
    const flags: Record<string, string | boolean | undefined> = {};
  
    switch (args.action) {
      case "add_backend":
        command = "backend:add";
        if (args.name) positional.push(args.name);
        if (args.url) flags.url = args.url;
        break;
  
      case "remove_backend":
        command = "backend:remove";
        if (args.name) positional.push(args.name);
        break;
  
      case "switch_backend":
        command = "backend:switch";
        if (args.name) positional.push(args.name);
        break;
  
      case "current_backend":
        command = "backend:current";
        break;
  
      case "add_partner":
        command = "partner:add";
        if (args.name) positional.push(args.name);
        break;
  
      case "remove_partner":
        command = "partner:remove";
        if (args.name) positional.push(args.name);
        break;
  
      case "setup_tunnel":
        command = "tunnel:setup";
        if (args.tunnel_method) positional.push(args.tunnel_method);
        break;
  
      case "set_default_tunnel":
        command = "tunnel:set-default";
        if (args.tunnel_method) positional.push(args.tunnel_method);
        break;
  
      default:
        return {
          content: `Unknown action: ${args.action}`,
          isError: true,
        };
    }
  
    const cmdArgs = buildArgs(command, positional, flags);
    return executeAndFormat(cmdArgs);
  },

• src/tools/config.ts:16-35 (schema)

  Definition of the 'manage_config' tool including name, description, and input schema using Zod for validation.

  manage_config: {
    name: "manage_config",
    description: `Manage QIT configuration (backends, partners, tunneling). Actions: ${configActions.join(", ")}`,
    inputSchema: z.object({
      action: z
        .enum(configActions)
        .describe("The configuration action to perform"),
      name: z
        .string()
        .optional()
        .describe("Backend or partner name (required for add/remove/switch)"),
      url: z
        .string()
        .optional()
        .describe("Backend URL (for add_backend)"),
      tunnel_method: z
        .string()
        .optional()
        .describe("Tunnel method (for tunnel actions: ngrok, cloudflare, etc.)"),
    }),

• src/server.ts:25-38 (registration)

  Registers 'manage_config' (via allTools) for listing available tools in the MCP server.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    // Check if QIT CLI is available
    const cliInfo = detectQitCli();
  
    const tools = Object.entries(allTools).map(([_, tool]) => ({
      name: tool.name,
      description: cliInfo
        ? tool.description
        : `${tool.description}\n\n⚠️ QIT CLI not detected. ${getQitCliNotFoundError()}`,
      inputSchema: zodToJsonSchema(tool.inputSchema),
    }));
  
    return { tools };
  });

• src/server.ts:44-65 (registration)

  Handles tool calls by looking up the handler from allTools (which includes manage_config) and executing it.

  const tool = allTools[name as ToolName];
  
  if (!tool) {
    return {
      content: [
        {
          type: "text",
          text: `Unknown tool: ${name}`,
        },
      ],
      isError: true,
    };
  }
  
  try {
    // Validate input
    const validatedArgs = tool.inputSchema.parse(args);
  
    // Execute tool
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const result = await (tool.handler as (args: any) => Promise<{ content: string; isError: boolean }>)(validatedArgs);

• src/tools/index.ts:10-19 (registration)

  Aggregates and exports all tools, spreading configTools (containing manage_config) into allTools used by the server.

  export const allTools = {
    ...authTools,
    ...testExecutionTools,
    ...testResultsTools,
    ...groupsTools,
    ...environmentTools,
    ...packagesTools,
    ...configTools,
    ...utilitiesTools,
  };