Tailscale MCP Server

Instructions

Implementation Reference

• src/tools/acl-tools.ts:193-306 (handler)

  The main handler function for the 'manage_dns' tool that handles DNS operations such as getting/setting nameservers, preferences, and search paths using Tailscale API.

  async function manageDNS(
    args: z.infer<typeof DNSSchema>,
    context: ToolContext,
  ): Promise<CallToolResult> {
    try {
      logger.debug("Managing DNS configuration:", args);
  
      switch (args.operation) {
        case "get_nameservers": {
          const result = await context.api.getDNSNameservers();
          if (!result.success) {
            return returnToolError(result.error);
          }
  
          const nameservers = result.data?.dns || [];
          return returnToolSuccess(
            `DNS Nameservers:\n${
              nameservers.length > 0
                ? nameservers.map((ns) => `  - ${ns}`).join("\n")
                : "  No custom nameservers configured"
            }`,
          );
        }
  
        case "set_nameservers": {
          if (!args.nameservers) {
            return returnToolError(
              "Nameservers array is required for set_nameservers operation",
            );
          }
  
          const result = await context.api.setDNSNameservers(args.nameservers);
          if (!result.success) {
            return returnToolError(result.error);
          }
  
          return returnToolSuccess(
            `DNS nameservers updated to: ${args.nameservers.join(", ")}`,
          );
        }
  
        case "get_preferences": {
          const result = await context.api.getDNSPreferences();
          if (!result.success) {
            return returnToolError(result.error);
          }
  
          return returnToolSuccess(
            `DNS Preferences:\n  MagicDNS: ${
              result.data?.magicDNS ? "Enabled" : "Disabled"
            }`,
          );
        }
  
        case "set_preferences": {
          if (args.magicDNS === undefined) {
            return returnToolError(
              "magicDNS boolean is required for set_preferences operation",
            );
          }
  
          const result = await context.api.setDNSPreferences(args.magicDNS);
          if (!result.success) {
            return returnToolError(result.error);
          }
  
          return returnToolSuccess(
            `MagicDNS ${args.magicDNS ? "enabled" : "disabled"}`,
          );
        }
  
        case "get_searchpaths": {
          const result = await context.api.getDNSSearchPaths();
          if (!result.success) {
            return returnToolError(result.error);
          }
  
          const searchPaths = result.data?.searchPaths || [];
          return returnToolSuccess(
            `DNS Search Paths:\n${
              searchPaths.length > 0
                ? searchPaths.map((path) => `  - ${path}`).join("\n")
                : "  No search paths configured"
            }`,
          );
        }
  
        case "set_searchpaths": {
          if (!args.searchPaths) {
            return returnToolError(
              "searchPaths array is required for set_searchpaths operation",
            );
          }
  
          const result = await context.api.setDNSSearchPaths(args.searchPaths);
          if (!result.success) {
            return returnToolError(result.error);
          }
  
          return returnToolSuccess(
            `DNS search paths updated to: ${args.searchPaths.join(", ")}`,
          );
        }
  
        default:
          return returnToolError(
            "Invalid DNS operation. Use: get_nameservers, set_nameservers, get_preferences, set_preferences, get_searchpaths, set_searchpaths",
          );
      }
    } catch (error: unknown) {
      logger.error("Error managing DNS:", error);
      return returnToolError(error);
    }
  }

• src/tools/acl-tools.ts:37-60 (schema)

  Zod input schema for the manage_dns tool defining the operation and optional parameters for nameservers, magicDNS, and search paths.

  const DNSSchema = z.object({
    operation: z
      .enum([
        "get_nameservers",
        "set_nameservers",
        "get_preferences",
        "set_preferences",
        "get_searchpaths",
        "set_searchpaths",
      ])
      .describe("DNS operation to perform"),
    nameservers: z
      .array(z.string())
      .optional()
      .describe("DNS nameservers (for set_nameservers operation)"),
    magicDNS: z
      .boolean()
      .optional()
      .describe("Enable/disable MagicDNS (for set_preferences operation)"),
    searchPaths: z
      .array(z.string())
      .optional()
      .describe("DNS search paths (for set_searchpaths operation)"),
  });

• src/tools/acl-tools.ts:524-529 (registration)

  Registration of the manage_dns tool within the aclTools module, specifying name, description, input schema, and handler function.

  {
    name: "manage_dns",
    description: "Manage Tailscale DNS configuration",
    inputSchema: DNSSchema,
    handler: manageDNS,
  },