feat: add interception collector, list_intercepted_requests tool, bump 0.3.2

- InterceptionCollector captures Network.requestIntercepted events
- New list_intercepted_requests tool shows pending intercepted requests
- set_request_interception now uses collector for proper event handling
- intercept_continue/intercept_with_response clean up pending list

Author: nnemirovsky

.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "iwdp-mcp",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "iOS Safari debugging via ios-webkit-debug-proxy — MCP server with full WebKit Inspector Protocol support",
   "owner": {
     "name": "nnemirovsky"

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "iwdp-mcp",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "iOS Safari debugging via ios-webkit-debug-proxy — MCP server with full WebKit Inspector Protocol support",
   "mcpServers": {
     "iwdp-mcp": {

cmd/iwdp-mcp/main.go

@@ -20,11 +20,12 @@ import (
 
 // session holds the active WebKit client and collectors.
 type session struct {
-	mu                sync.Mutex
-	client            *webkit.Client
-	networkMonitor    *tools.NetworkMonitor
-	consoleCollector  *tools.ConsoleCollector
-	timelineCollector *tools.TimelineCollector
+	mu                     sync.Mutex
+	client                 *webkit.Client
+	networkMonitor         *tools.NetworkMonitor
+	consoleCollector       *tools.ConsoleCollector
+	timelineCollector      *tools.TimelineCollector
+	interceptionCollector  *tools.InterceptionCollector
 }
 
 var sess session
@@ -41,7 +42,7 @@ func getClient(ctx context.Context) (*webkit.Client, error) {
 func main() {
 	server := mcp.NewServer(&mcp.Implementation{
 		Name:    "iwdp-mcp",
-		Version: "0.3.1",
+		Version: "0.3.2",
 	}, nil)
 
 	registerTools(server)
@@ -557,6 +558,7 @@ func registerTools(server *mcp.Server) {
 		sess.networkMonitor = nil
 		sess.consoleCollector = nil
 		sess.timelineCollector = nil
+		sess.interceptionCollector = nil
 		sess.mu.Unlock()
 
 		if oldClient != nil {
@@ -973,33 +975,76 @@ func registerTools(server *mcp.Server) {
 	})
 
 	mcp.AddTool(server, &mcp.Tool{
-		Name: "set_request_interception", Description: "Enable or disable request interception",
+		Name: "set_request_interception", Description: "Enable or disable request interception. When enabled, intercepted requests appear in list_intercepted_requests and must be continued or responded to.",
 	}, func(ctx context.Context, req *mcp.CallToolRequest, input SetRequestInterceptionInput) (*mcp.CallToolResult, any, error) {
 		c, err := getClient(ctx)
 		if err != nil {
 			return nil, OKOutput{}, err
 		}
-		return nil, ok(), tools.SetRequestInterception(ctx, c, input.Enabled)
+		if input.Enabled {
+			sess.mu.Lock()
+			if sess.interceptionCollector == nil {
+				sess.interceptionCollector = tools.NewInterceptionCollector()
+			}
+			ic := sess.interceptionCollector
+			sess.mu.Unlock()
+			return nil, ok(), ic.Start(ctx, c)
+		}
+		sess.mu.Lock()
+		ic := sess.interceptionCollector
+		sess.mu.Unlock()
+		if ic != nil {
+			return nil, ok(), ic.Stop(ctx, c)
+		}
+		return nil, ok(), nil
+	})
+
+	mcp.AddTool(server, &mcp.Tool{
+		Name: "list_intercepted_requests", Description: "List pending intercepted requests. Each has a request_id to use with intercept_continue or intercept_with_response.",
+	}, func(ctx context.Context, req *mcp.CallToolRequest, _ EmptyInput) (*mcp.CallToolResult, any, error) {
+		sess.mu.Lock()
+		ic := sess.interceptionCollector
+		sess.mu.Unlock()
+		if ic == nil {
+			return nil, RawOutput{Result: []any{}}, nil
+		}
+		return nil, RawOutput{Result: ic.GetPending()}, nil
 	})
 
 	mcp.AddTool(server, &mcp.Tool{
-		Name: "intercept_continue", Description: "Continue an intercepted request",
+		Name: "intercept_continue", Description: "Continue an intercepted request without modification",
 	}, func(ctx context.Context, req *mcp.CallToolRequest, input InterceptContinueInput) (*mcp.CallToolResult, any, error) {
 		c, err := getClient(ctx)
 		if err != nil {
 			return nil, OKOutput{}, err
 		}
-		return nil, ok(), tools.InterceptContinue(ctx, c, input.RequestID)
+		err = tools.InterceptContinue(ctx, c, input.RequestID)
+		if err == nil {
+			sess.mu.Lock()
+			if sess.interceptionCollector != nil {
+				sess.interceptionCollector.RemovePending(input.RequestID)
+			}
+			sess.mu.Unlock()
+		}
+		return nil, ok(), err
 	})
 
 	mcp.AddTool(server, &mcp.Tool{
-		Name: "intercept_with_response", Description: "Respond to an intercepted request with custom response",
+		Name: "intercept_with_response", Description: "Respond to an intercepted request with a custom response",
 	}, func(ctx context.Context, req *mcp.CallToolRequest, input InterceptWithResponseInput) (*mcp.CallToolResult, any, error) {
 		c, err := getClient(ctx)
 		if err != nil {
 			return nil, OKOutput{}, err
 		}
-		return nil, ok(), tools.InterceptWithResponse(ctx, c, input.RequestID, input.StatusCode, input.Headers, input.Body)
+		err = tools.InterceptWithResponse(ctx, c, input.RequestID, input.StatusCode, input.Headers, input.Body)
+		if err == nil {
+			sess.mu.Lock()
+			if sess.interceptionCollector != nil {
+				sess.interceptionCollector.RemovePending(input.RequestID)
+			}
+			sess.mu.Unlock()
+		}
+		return nil, ok(), err
 	})
 
 	mcp.AddTool(server, &mcp.Tool{

internal/tools/network.go

@@ -161,7 +161,97 @@ func SetExtraHeaders(ctx context.Context, client *webkit.Client, headers map[str
 	return err
 }
 
-// SetRequestInterception enables or disables request interception.
+// InterceptedRequest holds an intercepted request waiting for a continue/response decision.
+type InterceptedRequest struct {
+	RequestID string               `json:"request_id"`
+	Request   webkit.NetworkRequest `json:"request"`
+}
+
+// InterceptionCollector collects Network.requestIntercepted events.
+type InterceptionCollector struct {
+	mu       sync.Mutex
+	pending  map[string]*InterceptedRequest
+	started  bool
+}
+
+// NewInterceptionCollector creates a new InterceptionCollector.
+func NewInterceptionCollector() *InterceptionCollector {
+	return &InterceptionCollector{
+		pending: make(map[string]*InterceptedRequest),
+	}
+}
+
+// Start enables request interception and registers the event handler.
+func (ic *InterceptionCollector) Start(ctx context.Context, client *webkit.Client) error {
+	ic.mu.Lock()
+	if ic.started {
+		ic.mu.Unlock()
+		return nil
+	}
+	ic.started = true
+	ic.mu.Unlock()
+
+	_, err := client.Send(ctx, "Network.setInterceptionEnabled", map[string]interface{}{
+		"enabled": true,
+	})
+	if err != nil {
+		ic.mu.Lock()
+		ic.started = false
+		ic.mu.Unlock()
+		return err
+	}
+
+	client.OnEvent("Network.requestIntercepted", func(method string, params json.RawMessage) {
+		var evt struct {
+			RequestID string               `json:"requestId"`
+			Request   webkit.NetworkRequest `json:"request"`
+		}
+		if err := json.Unmarshal(params, &evt); err != nil {
+			return
+		}
+		ic.mu.Lock()
+		ic.pending[evt.RequestID] = &InterceptedRequest{
+			RequestID: evt.RequestID,
+			Request:   evt.Request,
+		}
+		ic.mu.Unlock()
+	})
+
+	return nil
+}
+
+// Stop disables request interception.
+func (ic *InterceptionCollector) Stop(ctx context.Context, client *webkit.Client) error {
+	ic.mu.Lock()
+	ic.started = false
+	ic.pending = make(map[string]*InterceptedRequest)
+	ic.mu.Unlock()
+	_, err := client.Send(ctx, "Network.setInterceptionEnabled", map[string]interface{}{
+		"enabled": false,
+	})
+	return err
+}
+
+// GetPending returns all pending intercepted requests.
+func (ic *InterceptionCollector) GetPending() []InterceptedRequest {
+	ic.mu.Lock()
+	defer ic.mu.Unlock()
+	result := make([]InterceptedRequest, 0, len(ic.pending))
+	for _, req := range ic.pending {
+		result = append(result, *req)
+	}
+	return result
+}
+
+// RemovePending removes a request from the pending list (after continue/response).
+func (ic *InterceptionCollector) RemovePending(requestID string) {
+	ic.mu.Lock()
+	delete(ic.pending, requestID)
+	ic.mu.Unlock()
+}
+
+// SetRequestInterception enables or disables request interception directly.
+// Prefer using InterceptionCollector for the full interception workflow.
 func SetRequestInterception(ctx context.Context, client *webkit.Client, enabled bool) error {
 	_, err := client.Send(ctx, "Network.setInterceptionEnabled", map[string]interface{}{
 		"enabled": enabled,