Web Proxy MCP Server

Instructions

Implementation Reference

• src/tools/tool-definitions.js:8-40 (schema)

  Input schema definition for the proxy_add_target tool including domain (required), description, enabled, captureHeaders, and captureBody parameters.

  proxy_add_target: {
    name: "proxy_add_target",
    description: "Add a new target domain for proxy monitoring",
    inputSchema: {
      type: "object",
      properties: {
        domain: {
          type: "string",
          description: "Domain to monitor (e.g., example.com)"
        },
        description: {
          type: "string",
          description: "Optional description of the target"
        },
        enabled: {
          type: "boolean",
          description: "Whether the target is active",
          default: true
        },
        captureHeaders: {
          type: "boolean",
          description: "Capture request/response headers",
          default: true
        },
        captureBody: {
          type: "boolean",
          description: "Capture request/response body",
          default: false
        }
      },
      required: ["domain"]
    }
  },

• src/tools/tool-handlers.js:158-173 (handler)

  Tool handler case statement that validates arguments, calls targetManager.addTarget, and formats success response with target stats.

  case 'proxy_add_target':
    const added = this.targetManager.addTarget(
      args.domain,
      args.description,
      {
        enabled: args.enabled,
        captureHeaders: args.captureHeaders,
        captureBody: args.captureBody
      }
    );
    return {
      content: [{
        type: "text",
        text: `Target added: ${args.domain}\nStatus: ${added ? 'success' : 'already exists'}\nMonitored domains: ${this.targetManager.getStats().enabled}`
      }]
    };

• src/proxy/target-manager.js:19-47 (helper)

  Core addTarget method in TargetManager: normalizes domain, applies defaults for config options, stores in Map, updates PAC file, logs, returns true.

  addTarget(domain, config = {}) {
    // Pre-conditions
    if (!domain || typeof domain !== 'string') {
      throw new Error('Domain is required and must be a string');
    }
  
    const targetConfig = {
      domain: domain.toLowerCase(),
      enabled: config.enabled !== false,
      includeSubdomains: config.includeSubdomains !== false,
      description: config.description || '',
      captureHeaders: config.captureHeaders !== false,  // Default to true
      captureBody: config.captureBody !== false,        // Default to true
      addedAt: new Date(),
      ...config
    };
  
    // Post-conditions: validate critical fields
    console.assert(typeof targetConfig.captureHeaders === 'boolean', 'captureHeaders must be boolean');
    console.assert(typeof targetConfig.captureBody === 'boolean', 'captureBody must be boolean');
    console.assert(typeof targetConfig.enabled === 'boolean', 'enabled must be boolean');
    
    this.targets.set(domain.toLowerCase(), targetConfig);
    this._updatePacFile();
    
    console.log(`✅ Target added: ${domain} (captureHeaders=${targetConfig.captureHeaders}, captureBody=${targetConfig.captureBody})`);
    
    return true;
  }

• index.js:66-74 (registration)

  MCP ListToolsRequestHandler registration that dynamically exposes proxy_add_target schema from TOOLS object.

  this.server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: Object.entries(TOOLS).map(([name, tool]) => ({
        name,
        description: tool.description,
        inputSchema: tool.inputSchema
      }))
    };
  });

• index.js:77-99 (registration)

  MCP CallToolRequestHandler registration that routes tool calls by name to ToolHandlers.handleTool, enabling proxy_add_target execution.

  this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
  
    try {
      const result = await this.toolHandlers.handleTool(name, args || {});
  
      if (result.isError) {
        throw new McpError(
          ErrorCode.InternalError,
          result.error
        );
      }
  
      return result;
  
    } catch (error) {
      console.error(`Tool error [${name}]:`, error.message);
      throw new McpError(
        ErrorCode.InternalError,
        `Tool execution failed: ${error.message}`
      );
    }
  });