feat: fix network interception — addInterception, stage routing, bulk ops

- Call Network.addInterception after setInterceptionEnabled (required by WebKit)
- Call Network.enable before interception (required for events to dispatch)
- Handle "already enabled" errors gracefully on reconnection
- Add stage param to interceptContinue/interceptWithResponse
- Use interceptRequestWithResponse for request-stage (not interceptWithResponse)
- Use correct WebKit param names (status/statusText/mimeType/content)
- Add intercept_continue_all and intercept_block_all bulk tools
- Also handle Network.responseIntercepted events
- Add version bump instructions to CLAUDE.md
- Bump version to 0.3.3

Author: nnemirovsky

.claude-plugin/marketplace.json

@@ -1,6 +1,6 @@
 {
   "name": "iwdp-mcp",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "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.2",
+  "version": "0.3.3",
   "description": "iOS Safari debugging via ios-webkit-debug-proxy — MCP server with full WebKit Inspector Protocol support",
   "mcpServers": {
     "iwdp-mcp": {

CLAUDE.md

@@ -122,6 +122,24 @@ fix/concurrent-write
 refactor/proxy-port-parsing
 ```
 
+## Version Bumps
+
+When bumping the version, update all three files:
+
+1. `cmd/iwdp-mcp/main.go` — `Version: "X.Y.Z"` in `mcp.Implementation`
+2. `.claude-plugin/plugin.json` — `"version": "X.Y.Z"`
+3. `.claude-plugin/marketplace.json` — `"version": "X.Y.Z"`
+
+Then commit, push, and create a git tag:
+
+```bash
+git add cmd/iwdp-mcp/main.go .claude-plugin/plugin.json .claude-plugin/marketplace.json
+git commit -m "chore: bump version to X.Y.Z"
+git push
+git tag vX.Y.Z
+git push origin vX.Y.Z
+```
+
 ## Key Dependencies
 
 - `github.com/modelcontextprotocol/go-sdk` v1.4.0 — official MCP Go SDK

cmd/iwdp-mcp/main.go

@@ -39,10 +39,26 @@ func getClient(ctx context.Context) (*webkit.Client, error) {
 	return nil, fmt.Errorf("no page selected — use select_page first")
 }
 
+// lookupInterceptStage finds the stage for an intercepted request from the collector.
+func lookupInterceptStage(requestID string) string {
+	sess.mu.Lock()
+	ic := sess.interceptionCollector
+	sess.mu.Unlock()
+	if ic == nil {
+		return "request"
+	}
+	for _, req := range ic.GetPending() {
+		if req.RequestID == requestID {
+			return req.Stage
+		}
+	}
+	return "request"
+}
+
 func main() {
 	server := mcp.NewServer(&mcp.Implementation{
 		Name:    "iwdp-mcp",
-		Version: "0.3.2",
+		Version: "0.3.3",
 	}, nil)
 
 	registerTools(server)
@@ -201,18 +217,22 @@ type SetExtraHeadersInput struct {
 }
 
 type SetRequestInterceptionInput struct {
-	Enabled bool `json:"enabled" jsonschema:"enable or disable request interception"`
+	Enabled    bool   `json:"enabled" jsonschema:"enable or disable request interception"`
+	URLPattern string `json:"url_pattern,omitempty" jsonschema:"URL pattern to intercept (empty = all requests)"`
+	Stage      string `json:"stage,omitempty" jsonschema:"interception stage: request or response (default: request)"`
+	IsRegex    bool   `json:"is_regex,omitempty" jsonschema:"treat url_pattern as regex"`
 }
 
 type InterceptContinueInput struct {
 	RequestID string `json:"request_id" jsonschema:"intercepted request ID"`
 }
 
 type InterceptWithResponseInput struct {
-	RequestID  string            `json:"request_id" jsonschema:"intercepted request ID"`
-	StatusCode int               `json:"status_code" jsonschema:"HTTP status code"`
-	Headers    map[string]string `json:"headers,omitempty" jsonschema:"response headers"`
-	Body       string            `json:"body,omitempty" jsonschema:"response body"`
+	RequestID     string            `json:"request_id" jsonschema:"intercepted request ID"`
+	StatusCode    int               `json:"status_code" jsonschema:"HTTP status code"`
+	Headers       map[string]string `json:"headers,omitempty" jsonschema:"response headers"`
+	Content       string            `json:"content,omitempty" jsonschema:"response body content"`
+	Base64Encoded bool              `json:"base64_encoded,omitempty" jsonschema:"whether content is base64-encoded"`
 }
 
 type SetEmulatedConditionsInput struct {
@@ -988,7 +1008,7 @@ func registerTools(server *mcp.Server) {
 			}
 			ic := sess.interceptionCollector
 			sess.mu.Unlock()
-			return nil, ok(), ic.Start(ctx, c)
+			return nil, ok(), ic.Start(ctx, c, input.URLPattern, input.Stage, input.IsRegex)
 		}
 		sess.mu.Lock()
 		ic := sess.interceptionCollector
@@ -1018,7 +1038,8 @@ func registerTools(server *mcp.Server) {
 		if err != nil {
 			return nil, OKOutput{}, err
 		}
-		err = tools.InterceptContinue(ctx, c, input.RequestID)
+		stage := lookupInterceptStage(input.RequestID)
+		err = tools.InterceptContinue(ctx, c, input.RequestID, stage)
 		if err == nil {
 			sess.mu.Lock()
 			if sess.interceptionCollector != nil {
@@ -1036,7 +1057,8 @@ func registerTools(server *mcp.Server) {
 		if err != nil {
 			return nil, OKOutput{}, err
 		}
-		err = tools.InterceptWithResponse(ctx, c, input.RequestID, input.StatusCode, input.Headers, input.Body)
+		stage := lookupInterceptStage(input.RequestID)
+		err = tools.InterceptWithResponse(ctx, c, input.RequestID, stage, input.StatusCode, input.Headers, input.Content, input.Base64Encoded)
 		if err == nil {
 			sess.mu.Lock()
 			if sess.interceptionCollector != nil {
@@ -1047,6 +1069,54 @@ func registerTools(server *mcp.Server) {
 		return nil, ok(), err
 	})
 
+	mcp.AddTool(server, &mcp.Tool{
+		Name: "intercept_continue_all", Description: "Continue all pending intercepted requests without modification",
+	}, func(ctx context.Context, req *mcp.CallToolRequest, _ EmptyInput) (*mcp.CallToolResult, any, error) {
+		c, err := getClient(ctx)
+		if err != nil {
+			return nil, OKOutput{}, err
+		}
+		sess.mu.Lock()
+		ic := sess.interceptionCollector
+		sess.mu.Unlock()
+		if ic == nil {
+			return nil, RawOutput{Result: map[string]int{"continued": 0}}, nil
+		}
+		pending := ic.GetPending()
+		continued := 0
+		for _, r := range pending {
+			if err := tools.InterceptContinue(ctx, c, r.RequestID, r.Stage); err == nil {
+				ic.RemovePending(r.RequestID)
+				continued++
+			}
+		}
+		return nil, RawOutput{Result: map[string]int{"continued": continued}}, nil
+	})
+
+	mcp.AddTool(server, &mcp.Tool{
+		Name: "intercept_block_all", Description: "Block all pending intercepted requests with 403 Forbidden",
+	}, func(ctx context.Context, req *mcp.CallToolRequest, _ EmptyInput) (*mcp.CallToolResult, any, error) {
+		c, err := getClient(ctx)
+		if err != nil {
+			return nil, OKOutput{}, err
+		}
+		sess.mu.Lock()
+		ic := sess.interceptionCollector
+		sess.mu.Unlock()
+		if ic == nil {
+			return nil, RawOutput{Result: map[string]int{"blocked": 0}}, nil
+		}
+		pending := ic.GetPending()
+		blocked := 0
+		for _, r := range pending {
+			if err := tools.InterceptWithResponse(ctx, c, r.RequestID, r.Stage, 403, map[string]string{"Content-Type": "text/plain"}, "Blocked", false); err == nil {
+				ic.RemovePending(r.RequestID)
+				blocked++
+			}
+		}
+		return nil, RawOutput{Result: map[string]int{"blocked": blocked}}, nil
+	})
+
 	mcp.AddTool(server, &mcp.Tool{
 		Name: "set_emulated_conditions", Description: "Throttle network speed",
 	}, func(ctx context.Context, req *mcp.CallToolRequest, input SetEmulatedConditionsInput) (*mcp.CallToolResult, any, error) {

internal/tools/network.go

@@ -4,11 +4,43 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"net/http"
+	"strings"
 	"sync"
 
 	"github.com/nnemirovsky/iwdp-mcp/internal/webkit"
 )
 
+// httpStatusText returns the standard status text for an HTTP status code.
+func httpStatusText(code int) string {
+	text := http.StatusText(code)
+	if text == "" {
+		return "Unknown"
+	}
+	return text
+}
+
+// mimeTypeFromHeaders extracts the MIME type from a Content-Type header, defaulting to text/plain.
+func mimeTypeFromHeaders(headers map[string]string) string {
+	for k, v := range headers {
+		if strings.EqualFold(k, "content-type") {
+			// Strip charset etc: "text/html; charset=utf-8" → "text/html"
+			if idx := strings.IndexByte(v, ';'); idx >= 0 {
+				return strings.TrimSpace(v[:idx])
+			}
+			return v
+		}
+	}
+	return "text/plain"
+}
+
+// isAlreadyEnabledErr checks if the error is "Interception already enabled/disabled",
+// which happens when a previous session left state on WebKit's side.
+func isAlreadyEnabledErr(err error) bool {
+	return err != nil && (strings.Contains(err.Error(), "already enabled") ||
+		strings.Contains(err.Error(), "already disabled"))
+}
+
 // NetworkMonitor collects network requests and responses.
 type NetworkMonitor struct {
 	mu       sync.Mutex
@@ -164,6 +196,7 @@ func SetExtraHeaders(ctx context.Context, client *webkit.Client, headers map[str
 // InterceptedRequest holds an intercepted request waiting for a continue/response decision.
 type InterceptedRequest struct {
 	RequestID string                `json:"request_id"`
+	Stage     string                `json:"stage"`
 	Request   webkit.NetworkRequest `json:"request"`
 }
 
@@ -181,8 +214,11 @@ func NewInterceptionCollector() *InterceptionCollector {
 	}
 }
 
-// Start enables request interception and registers the event handler.
-func (ic *InterceptionCollector) Start(ctx context.Context, client *webkit.Client) error {
+// Start enables request interception, adds an interception rule, and registers the event handler.
+// urlPattern is a URL pattern to intercept (empty string = all requests).
+// stage is "request" or "response" (empty defaults to "request").
+// isRegex controls whether urlPattern is treated as a regex.
+func (ic *InterceptionCollector) Start(ctx context.Context, client *webkit.Client, urlPattern, stage string, isRegex bool) error {
 	ic.mu.Lock()
 	if ic.started {
 		ic.mu.Unlock()
@@ -191,14 +227,42 @@ func (ic *InterceptionCollector) Start(ctx context.Context, client *webkit.Clien
 	ic.started = true
 	ic.mu.Unlock()
 
+	// Network domain must be enabled for interception events to be dispatched.
+	_, _ = client.Send(ctx, "Network.enable", nil)
+
 	_, err := client.Send(ctx, "Network.setInterceptionEnabled", map[string]interface{}{
 		"enabled": true,
 	})
 	if err != nil {
+		// "Interception already enabled" is non-fatal — a previous session may have
+		// left it on. We still need to add rules and register the event handler.
+		if !isAlreadyEnabledErr(err) {
+			ic.mu.Lock()
+			ic.started = false
+			ic.mu.Unlock()
+			return err
+		}
+	}
+
+	if stage == "" {
+		stage = "request"
+	}
+
+	// Register an interception rule — without this, no requestIntercepted events fire.
+	_, err = client.Send(ctx, "Network.addInterception", map[string]interface{}{
+		"url":     urlPattern,
+		"stage":   stage,
+		"isRegex": isRegex,
+	})
+	if err != nil {
+		// Roll back — disable interception if we can't add a rule.
+		_, _ = client.Send(ctx, "Network.setInterceptionEnabled", map[string]interface{}{
+			"enabled": false,
+		})
 		ic.mu.Lock()
 		ic.started = false
 		ic.mu.Unlock()
-		return err
+		return fmt.Errorf("adding interception rule: %w", err)
 	}
 
 	client.OnEvent("Network.requestIntercepted", func(method string, params json.RawMessage) {
@@ -212,6 +276,24 @@ func (ic *InterceptionCollector) Start(ctx context.Context, client *webkit.Clien
 		ic.mu.Lock()
 		ic.pending[evt.RequestID] = &InterceptedRequest{
 			RequestID: evt.RequestID,
+			Stage:     "request",
+			Request:   evt.Request,
+		}
+		ic.mu.Unlock()
+	})
+
+	client.OnEvent("Network.responseIntercepted", 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,
+			Stage:     "response",
 			Request:   evt.Request,
 		}
 		ic.mu.Unlock()
@@ -220,12 +302,17 @@ func (ic *InterceptionCollector) Start(ctx context.Context, client *webkit.Clien
 	return nil
 }
 
-// Stop disables request interception.
+// Stop disables request interception and removes all interception rules.
 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()
+	// removeInterception is best-effort — the disable call below will clear everything anyway.
+	_, _ = client.Send(ctx, "Network.removeInterception", map[string]interface{}{
+		"url":   "",
+		"stage": "request",
+	})
 	_, err := client.Send(ctx, "Network.setInterceptionEnabled", map[string]interface{}{
 		"enabled": false,
 	})
@@ -260,20 +347,50 @@ func SetRequestInterception(ctx context.Context, client *webkit.Client, enabled
 }
 
 // InterceptContinue continues an intercepted request without modification.
-func InterceptContinue(ctx context.Context, client *webkit.Client, requestID string) error {
+func InterceptContinue(ctx context.Context, client *webkit.Client, requestID, stage string) error {
+	if stage == "" {
+		stage = "request"
+	}
 	_, err := client.Send(ctx, "Network.interceptContinue", map[string]string{
 		"requestId": requestID,
+		"stage":     stage,
 	})
 	return err
 }
 
 // InterceptWithResponse provides a custom response for an intercepted request.
-func InterceptWithResponse(ctx context.Context, client *webkit.Client, requestID string, statusCode int, headers map[string]string, body string) error {
+// For request-stage interceptions, uses Network.interceptRequestWithResponse (synthetic response).
+// For response-stage interceptions, uses Network.interceptWithResponse (modify received response).
+func InterceptWithResponse(ctx context.Context, client *webkit.Client, requestID string, stage string, statusCode int, headers map[string]string, content string, base64Encoded bool) error {
+	if stage == "" {
+		stage = "request"
+	}
+	if headers == nil {
+		headers = map[string]string{}
+	}
+
+	if stage == "request" {
+		// interceptRequestWithResponse: synthetic response at request stage (skip network).
+		_, err := client.Send(ctx, "Network.interceptRequestWithResponse", map[string]interface{}{
+			"requestId":     requestID,
+			"status":        statusCode,
+			"statusText":    httpStatusText(statusCode),
+			"mimeType":      mimeTypeFromHeaders(headers),
+			"content":       content,
+			"base64Encoded": base64Encoded,
+			"headers":       headers,
+		})
+		return err
+	}
+
+	// interceptWithResponse: modify response at response stage.
 	_, err := client.Send(ctx, "Network.interceptWithResponse", map[string]interface{}{
-		"requestId":  requestID,
-		"statusCode": statusCode,
-		"headers":    headers,
-		"body":       body,
+		"requestId":     requestID,
+		"stage":         stage,
+		"statusCode":    statusCode,
+		"headers":       headers,
+		"content":       content,
+		"base64Encoded": base64Encoded,
 	})
 	return err
 }