+ + if (!hasHttpRequestHandlers && !hasHttpResponseHandlers) { + return undefined; + } + + return (model: Model): typeof globalThis.fetch => { + return async (input: string | URL | Request, init?: RequestInit): Promise => { + const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url; + const method = + init?.method || (typeof input !== "string" && !(input instanceof URL) ? input.method : undefined) || "GET"; + + const normalizeHeaderValue = (value: unknown): string => { + if (Array.isArray(value)) { + return value.map((v) => String(v)).join(", "); + } + if (value === undefined || value === null) return ""; + return String(value); + }; + + // Build headers record from input Request + init + let headers: Record = {}; + + if (typeof input !== "string" && !(input instanceof URL)) { + headers = headersToRecord(input.headers); + } + + if (init?.headers) { + if (init.headers instanceof Headers) { + headers = { ...headers, ...headersToRecord(init.headers) }; + } else if (Array.isArray(init.headers)) { + for (const [key, value] of init.headers) { + headers[key] = normalizeHeaderValue(value); + } + } else { + for (const [key, value] of Object.entries(init.headers)) { + headers[key] = normalizeHeaderValue(value); + } + } + } + + // Emit http_request event with redacted headers + let extraHeaders: Record | undefined; + if (hasHttpRequestHandlers) { + const result = await runner.emitHttpRequest({ + provider: model.provider, + modelId: model.id, + url, + method, + headers: redactHeaders(headers), + body: typeof init?.body === "string" ? init.body : undefined, + }); + + if (result?.cancel) { + throw new Error("HTTP request cancelled by extension"); + } + extraHeaders = result?.headers; + } + + const finalInit: RequestInit = { ...init }; + if (extraHeaders) { + finalInit.headers = { ...headers, ...extraHeaders }; + } + + const startTime = Date.now(); + const response = await globalThis.fetch(input, finalInit); + const durationMs = Date.now() - startTime; + + if (hasHttpResponseHandlers) { + await runner.emitHttpResponse({ + provider: model.provider, + modelId: model.id, + status: response.status, + headers: headersToRecord(response.headers), + durationMs, + }); + } + + return response; + }; + }; +} diff --git a/packages/coding-agent/src/core/extensions/index.ts b/packages/coding-agent/src/core/extensions/index.ts index 4b7c901b8..aa25ca0f5 100644 --- a/packages/coding-agent/src/core/extensions/index.ts +++ b/packages/coding-agent/src/core/extensions/index.ts @@ -40,6 +40,9 @@ export type { GetActiveToolsHandler, GetAllToolsHandler, GrepToolResultEvent, + HttpRequestEvent, + HttpRequestEventResult, + HttpResponseEvent, LoadExtensionsResult, // Loaded Extension LoadedExtension, diff --git a/packages/coding-agent/src/core/extensions/runner.ts b/packages/coding-agent/src/core/extensions/runner.ts index 41ad7883d..80536ec3f 100644 --- a/packages/coding-agent/src/core/extensions/runner.ts +++ b/packages/coding-agent/src/core/extensions/runner.ts @@ -23,6 +23,9 @@ import type { ExtensionUIContext, GetActiveToolsHandler, GetAllToolsHandler, + HttpRequestEvent, + HttpRequestEventResult, + HttpResponseEvent, LoadedExtension, MessageRenderer, RegisteredCommand, @@ -465,4 +468,76 @@ export class ExtensionRunner { return undefined; } + + /** + * Emit http_request event to all extensions. + * Returns the merged result from all handlers (headers merged, cancel if any). + */ + async emitHttpRequest(event: Omit): Promise { + const ctx = this.createContext(); + let mergedHeaders: Record | undefined; + let cancel = false; + + const fullEvent: HttpRequestEvent = { type: "http_request", ...event }; + + for (const ext of this.extensions) { + const handlers = ext.handlers.get("http_request"); + if (!handlers || handlers.length === 0) continue; + + for (const handler of handlers) { + try { + const handlerResult = await handler(fullEvent, ctx); + if (handlerResult) { + const result = handlerResult as HttpRequestEventResult; + if (result.cancel) cancel = true; + if (result.headers) { + mergedHeaders = { ...mergedHeaders, ...result.headers }; + } + } + } catch (err) { + const message = err instanceof Error ? err.message : String(err); + const stack = err instanceof Error ? err.stack : undefined; + this.emitError({ + extensionPath: ext.path, + event: "http_request", + error: message, + stack, + }); + } + } + } + + if (cancel || mergedHeaders) { + return { cancel, headers: mergedHeaders }; + } + return undefined; + } + + /** + * Emit http_response event to all extensions. + */ + async emitHttpResponse(event: Omit): Promise { + const ctx = this.createContext(); + const fullEvent: HttpResponseEvent = { type: "http_response", ...event }; + + for (const ext of this.extensions) { + const handlers = ext.handlers.get("http_response"); + if (!handlers || handlers.length === 0) continue; + + for (const handler of handlers) { + try { + await handler(fullEvent, ctx); + } catch (err) { + const message = err instanceof Error ? err.message : String(err); + const stack = err instanceof Error ? err.stack : undefined; + this.emitError({ + extensionPath: ext.path, + event: "http_response", + error: message, + stack, + }); + } + } + } + } } diff --git a/packages/coding-agent/src/core/extensions/types.ts b/packages/coding-agent/src/core/extensions/types.ts index 44bd7b6f4..f2d56e5be 100644 --- a/packages/coding-agent/src/core/extensions/types.ts +++ b/packages/coding-agent/src/core/extensions/types.ts @@ -413,6 +413,39 @@ export function isLsToolResult(e: ToolResultEvent): e is LsToolResultEvent { return e.toolName === "ls"; } +// ============================================================================ +// HTTP Events +// ============================================================================ + +/** + * Fired before an HTTP request is made to an LLM provider. + * Extensions can add headers or cancel the request. + */ +export interface HttpRequestEvent { + type: "http_request"; + provider: string; + modelId: string; + url: string; + method: string; + /** Request headers with sensitive values redacted */ + headers: Record; + /** Request body (if present and a string) */ + body?: string; +} + +/** + * Fired after an HTTP response is received from an LLM provider. + * Useful for logging and monitoring. + */ +export interface HttpResponseEvent { + type: "http_response"; + provider: string; + modelId: string; + status: number; + headers: Record; + durationMs: number; +} + /** Union of all event types */ export type ExtensionEvent = | SessionEvent @@ -423,7 +456,9 @@ export type ExtensionEvent = | TurnStartEvent | TurnEndEvent | ToolCallEvent - | ToolResultEvent; + | ToolResultEvent + | HttpRequestEvent + | HttpResponseEvent; // ============================================================================ // Event Results @@ -471,6 +506,13 @@ export interface SessionBeforeTreeResult { }; } +export interface HttpRequestEventResult { + /** Additional headers to merge into the request */ + headers?: Record; + /** If true, cancel the request (throws an error) */ + cancel?: boolean; +} + // ============================================================================ // Message Rendering // ============================================================================ @@ -538,6 +580,8 @@ export interface ExtensionAPI { on(event: "turn_end", handler: ExtensionHandler): void; on(event: "tool_call", handler: ExtensionHandler): void; on(event: "tool_result", handler: ExtensionHandler): void; + on(event: "http_request", handler: ExtensionHandler): void; + on(event: "http_response", handler: ExtensionHandler): void; // ========================================================================= // Tool Registration diff --git a/packages/coding-agent/src/core/sdk.ts b/packages/coding-agent/src/core/sdk.ts index e15926e81..41b9318f1 100644 --- a/packages/coding-agent/src/core/sdk.ts +++ b/packages/coding-agent/src/core/sdk.ts @@ -27,6 +27,7 @@ import { getAgentDir } from "../config.js"; import { AgentSession } from "./agent-session.js"; import { AuthStorage } from "./auth-storage.js"; import { createEventBus, type EventBus } from "./event-bus.js"; +import { createExtensionFetchFactory } from "./extensions/http.js"; import { discoverAndLoadExtensions, type ExtensionFactory, @@ -303,7 +304,6 @@ export function loadSettings(cwd?: string, agentDir?: string): Settings { images: { autoResize: manager.getImageAutoResize(), blockImages: manager.getBlockImages() }, }; } - // Factory /** @@ -672,6 +672,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {} } return key; }, + createFetch: createExtensionFetchFactory(extensionRunner), }); time("createAgent"); diff --git a/packages/coding-agent/test/hooks/http-hooks-integration.test.ts b/packages/coding-agent/test/hooks/http-hooks-integration.test.ts new file mode 100644 index 000000000..a53b31b4a --- /dev/null +++ b/packages/coding-agent/test/hooks/http-hooks-integration.test.ts @@ -0,0 +1,852 @@ +/** + * Integration tests for HTTP extensions with the fetch wrapper. + * + * Tests the full flow from extension registration through the fetch wrapper + * that integrates with pi-ai. + */ + +import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http"; +import type { Api, Model } from "@mariozechner/pi-ai"; +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { createExtensionFetchFactory, headersToRecord, redactHeaders } from "../../src/core/extensions/http.js"; +import { ExtensionRunner } from "../../src/core/extensions/runner.js"; +import type { HttpRequestEvent, HttpResponseEvent, LoadedExtension } from "../../src/core/extensions/types.js"; +import type { ModelRegistry } from "../../src/core/model-registry.js"; +import type { SessionManager } from "../../src/core/session-manager.js"; + +// Mock SessionManager +function createMockSessionManager(): SessionManager { + return { + getCwd: () => "/test", + getSessionDir: () => "/test/.pi/sessions", + getSessionId: () => "test-session", + getSessionFile: () => "/test/.pi/sessions/test.jsonl", + getLeafUuid: () => "test-uuid", + getLeafEntry: () => undefined, + getEntry: () => undefined, + getLabel: () => undefined, + getPath: () => [], + getHeader: () => undefined, + getEntries: () => [], + getTree: () => ({ roots: [], currentPath: [] }), + } as unknown as SessionManager; +} + +// Mock ModelRegistry +function createMockModelRegistry(): ModelRegistry { + return { + getApiKey: async () => "test-key", + find: () => undefined, + getAll: () => [], + } as unknown as ModelRegistry; +} + +// Mock Model +function createMockModel(): Model { + return { + id: "claude-sonnet-4-5", + name: "Claude Sonnet 4.5", + api: "anthropic-messages", + provider: "anthropic", + baseUrl: "https://api.anthropic.com", + reasoning: true, + input: ["text", "image"], + cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, + contextWindow: 200000, + maxTokens: 8192, + } as Model; +} + +// Create a LoadedExtension +function createExtension( + onHttpRequest?: (event: HttpRequestEvent) => { headers?: Record; cancel?: boolean } | undefined, + onHttpResponse?: (event: HttpResponseEvent) => undefined, +): LoadedExtension { + const handlers = new Map Promise)[]>(); + + if (onHttpRequest) { + handlers.set("http_request", [async (event: unknown) => onHttpRequest(event as HttpRequestEvent)]); + } + + if (onHttpResponse) { + handlers.set("http_response", [async (event: unknown) => onHttpResponse(event as HttpResponseEvent)]); + } + + return { + path: "test-extension", + resolvedPath: "/test/test-extension.ts", + handlers, + tools: new Map(), + messageRenderers: new Map(), + commands: new Map(), + flags: new Map(), + flagValues: new Map(), + shortcuts: new Map(), + setSendMessageHandler: () => {}, + setSendUserMessageHandler: () => {}, + setAppendEntryHandler: () => {}, + setGetActiveToolsHandler: () => {}, + setGetAllToolsHandler: () => {}, + setSetActiveToolsHandler: () => {}, + setFlagValue: () => {}, + }; +} + +/** + * Helper to create the wrapped fetch using the real createExtensionFetchFactory. + */ +function createFetchWithExtensions(extensionRunner: ExtensionRunner, model: Model): typeof globalThis.fetch { + const factory = createExtensionFetchFactory(extensionRunner); + if (!factory) { + throw new Error("Expected createExtensionFetchFactory to return a factory when extensions are registered"); + } + return factory(model); +} + +describe("HTTP extensions integration", () => { + let server: Server; + let serverPort: number; + let serverUrl: string; + let receivedHeaders: Record; + let _receivedBody: string; + + beforeEach(async () => { + receivedHeaders = {}; + _receivedBody = ""; + + // Create a simple test server + server = createServer((req: IncomingMessage, res: ServerResponse) => { + // Capture received headers + receivedHeaders = { ...req.headers }; + + // Capture body + const chunks: Buffer[] = []; + req.on("data", (chunk: Buffer) => chunks.push(chunk)); + req.on("end", () => { + _receivedBody = Buffer.concat(chunks).toString(); + res.writeHead(200, { "content-type": "application/json", "x-server-id": "test-server" }); + res.end(JSON.stringify({ success: true })); + }); + }); + + // Listen on a random available port + await new Promise((resolve) => { + server.listen(0, "127.0.0.1", () => { + const addr = server.address(); + if (addr && typeof addr === "object") { + serverPort = addr.port; + serverUrl = `http://127.0.0.1:${serverPort}`; + } + resolve(); + }); + }); + }); + + afterEach(async () => { + vi.restoreAllMocks(); + await new Promise((resolve) => { + server.close(() => resolve()); + }); + }); + + it("should emit http_request and http_response events through fetch wrapper", async () => { + const capturedRequestEvents: HttpRequestEvent[] = []; + const capturedResponseEvents: HttpResponseEvent[] = []; + + const ext = createExtension( + (event) => { + capturedRequestEvents.push(event); + return undefined; + }, + (event) => { + capturedResponseEvents.push(event); + return undefined; + }, + ); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + const response = await wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/json" }, + body: JSON.stringify({ test: true }), + }); + + expect(response.status).toBe(200); + + // Verify request event + expect(capturedRequestEvents).toHaveLength(1); + expect(capturedRequestEvents[0].provider).toBe("anthropic"); + expect(capturedRequestEvents[0].modelId).toBe("claude-sonnet-4-5"); + expect(capturedRequestEvents[0].url).toBe(serverUrl); + expect(capturedRequestEvents[0].method).toBe("POST"); + + // Verify response event + expect(capturedResponseEvents).toHaveLength(1); + expect(capturedResponseEvents[0].provider).toBe("anthropic"); + expect(capturedResponseEvents[0].modelId).toBe("claude-sonnet-4-5"); + expect(capturedResponseEvents[0].status).toBe(200); + expect(capturedResponseEvents[0].durationMs).toBeGreaterThanOrEqual(0); + expect(capturedResponseEvents[0].headers["content-type"]).toBe("application/json"); + expect(capturedResponseEvents[0].headers["x-server-id"]).toBe("test-server"); + }); + + it("should allow extensions to inject custom headers", async () => { + const ext = createExtension(() => ({ + headers: { + "x-custom-header": "injected-value", + "x-request-trace": "trace-123", + }, + })); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + await wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/json" }, + body: "{}", + }); + + // Server should receive the injected headers + expect(receivedHeaders["x-custom-header"]).toBe("injected-value"); + expect(receivedHeaders["x-request-trace"]).toBe("trace-123"); + }); + + it("should allow extensions to overwrite existing headers", async () => { + const ext = createExtension(() => ({ + headers: { + "x-existing-header": "hook-overwritten-value", + }, + })); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + await wrappedFetch(serverUrl, { + method: "POST", + headers: { + "content-type": "application/json", + "x-existing-header": "original-value", + }, + body: "{}", + }); + + // Server should receive the hook-overwritten value, not the original + expect(receivedHeaders["x-existing-header"]).toBe("hook-overwritten-value"); + }); + + it("should throw error when extension cancels request", async () => { + const ext = createExtension(() => ({ + cancel: true, + })); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + await expect( + wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/json" }, + body: "{}", + }), + ).rejects.toThrow("HTTP request cancelled by extension"); + }); + + it("should redact authorization header in http_request event", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + await wrappedFetch(serverUrl, { + method: "POST", + headers: { + "content-type": "application/json", + authorization: "Bearer sk-secret-key-12345", + }, + body: "{}", + }); + + expect(capturedEvent).toBeDefined(); + expect(capturedEvent!.headers.authorization).toBe("[REDACTED]"); + + // But actual request should have the real header + expect(receivedHeaders.authorization).toBe("Bearer sk-secret-key-12345"); + }); + + it("should redact x-api-key header in http_request event", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + await wrappedFetch(serverUrl, { + method: "POST", + headers: { + "content-type": "application/json", + "x-api-key": "anthropic-key-abc123", + }, + body: "{}", + }); + + expect(capturedEvent).toBeDefined(); + expect(capturedEvent!.headers["x-api-key"]).toBe("[REDACTED]"); + + // But actual request should have the real header + expect(receivedHeaders["x-api-key"]).toBe("anthropic-key-abc123"); + }); + + it("should redact headers matching heuristic patterns", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + await wrappedFetch(serverUrl, { + method: "POST", + headers: { + "content-type": "application/json", + "x-auth-token": "token-value", + "custom-secret-header": "secret-value", + "api-key-custom": "key-value", + "session-cookie": "cookie-value", + }, + body: "{}", + }); + + expect(capturedEvent).toBeDefined(); + // All should be redacted due to pattern matching + expect(capturedEvent!.headers["x-auth-token"]).toBe("[REDACTED]"); + expect(capturedEvent!.headers["custom-secret-header"]).toBe("[REDACTED]"); + expect(capturedEvent!.headers["api-key-custom"]).toBe("[REDACTED]"); + expect(capturedEvent!.headers["session-cookie"]).toBe("[REDACTED]"); + + // But actual request should have real values + expect(receivedHeaders["x-auth-token"]).toBe("token-value"); + expect(receivedHeaders["custom-secret-header"]).toBe("secret-value"); + expect(receivedHeaders["api-key-custom"]).toBe("key-value"); + expect(receivedHeaders["session-cookie"]).toBe("cookie-value"); + }); + + it("should not redact non-sensitive headers", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + await wrappedFetch(serverUrl, { + method: "POST", + headers: { + "content-type": "application/json", + accept: "application/json", + "user-agent": "test-agent/1.0", + "x-request-id": "12345", + }, + body: "{}", + }); + + expect(capturedEvent).toBeDefined(); + expect(capturedEvent!.headers["content-type"]).toBe("application/json"); + expect(capturedEvent!.headers.accept).toBe("application/json"); + expect(capturedEvent!.headers["user-agent"]).toBe("test-agent/1.0"); + expect(capturedEvent!.headers["x-request-id"]).toBe("12345"); + }); + + it("should normalize array header values to comma-separated string", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + // Use Headers object which supports append for multiple values + const headers = new Headers(); + headers.append("accept", "application/json"); + headers.append("accept", "text/plain"); + + await wrappedFetch(serverUrl, { + method: "POST", + headers, + body: "{}", + }); + + expect(capturedEvent).toBeDefined(); + // Headers class joins multiple values with ", " + expect(capturedEvent!.headers.accept).toBe("application/json, text/plain"); + }); + + it("should handle string array header values via type assertion", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + // Pass a string array value directly through init.headers using type assertion + const headersWithArray = { + "content-type": "application/json", + "x-multi-value": ["value1", "value2", "value3"], + } as unknown as RequestInit["headers"]; + + await wrappedFetch(serverUrl, { + method: "POST", + headers: headersWithArray, + body: "{}", + }); + + expect(capturedEvent).toBeDefined(); + // Array values should be joined into a comma-separated string (with spaces, like Headers class) + expect(capturedEvent!.headers["x-multi-value"]).toBe("value1, value2, value3"); + }); + + it("should convert non-string header values to strings", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + // Use type assertion to force a non-string value (number) through to test normalization + // In practice, some libraries might pass numbers which should be converted to strings + const headersWithNumber = { + "content-type": "application/json", + "x-count": 42 as unknown as string, // Force a number through type assertion + }; + + await wrappedFetch(serverUrl, { + method: "POST", + headers: headersWithNumber, + body: "{}", + }); + + expect(capturedEvent).toBeDefined(); + expect(typeof capturedEvent!.headers["x-count"]).toBe("string"); + expect(capturedEvent!.headers["x-count"]).toBe("42"); + + // Verify the server also received the header with the string value + expect(receivedHeaders["x-count"]).toBe("42"); + }); + + it("should measure response duration accurately", async () => { + let capturedDurationMs = 0; + + const ext = createExtension(undefined, (event) => { + capturedDurationMs = event.durationMs; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + const startTime = Date.now(); + await wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/json" }, + body: "{}", + }); + const totalTime = Date.now() - startTime; + + // Duration should be captured and reasonably close to actual time + expect(capturedDurationMs).toBeGreaterThanOrEqual(0); + expect(capturedDurationMs).toBeLessThanOrEqual(totalTime + 100); // Allow some margin + }); + + it("should handle Request object input and capture its headers", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + // Create a Request object with headers + const request = new Request(serverUrl, { + method: "POST", + headers: { + "content-type": "application/json", + "x-custom-from-request": "request-value", + }, + body: "{}", + }); + + const response = await wrappedFetch(request); + + expect(response.status).toBe(200); + expect(capturedEvent).toBeDefined(); + // Verify method and url are correctly extracted from the Request object + expect(capturedEvent!.method).toBe("POST"); + // Request object may normalize the URL (e.g., adding trailing slash) + expect(capturedEvent!.url).toContain(serverUrl); + expect(capturedEvent!.headers["content-type"]).toBe("application/json"); + expect(capturedEvent!.headers["x-custom-from-request"]).toBe("request-value"); + + // Verify server received the headers + expect(receivedHeaders["x-custom-from-request"]).toBe("request-value"); + }); + + it("should have undefined body for non-string bodies but request still succeeds", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + return undefined; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + // Use Uint8Array as body + const binaryBody = new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f]); // "hello" in bytes + + const response = await wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/octet-stream" }, + body: binaryBody, + }); + + expect(response.status).toBe(200); + expect(capturedEvent).toBeDefined(); + // Body should be undefined since it's not a string + expect(capturedEvent!.body).toBeUndefined(); + + // Server should still receive the body + expect(_receivedBody).toBe("hello"); + }); + + it("should fire http_request but not http_response on network errors, and propagate the error", async () => { + const capturedRequestEvents: HttpRequestEvent[] = []; + const capturedResponseEvents: HttpResponseEvent[] = []; + + const ext = createExtension( + (event) => { + capturedRequestEvents.push(event); + return undefined; + }, + (event) => { + capturedResponseEvents.push(event); + return undefined; + }, + ); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + // Mock globalThis.fetch to reject - vitest will restore in afterEach + const networkError = new Error("Network error: connection refused"); + vi.spyOn(globalThis, "fetch").mockRejectedValueOnce(networkError); + + await expect( + wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/json" }, + body: "{}", + }), + ).rejects.toThrow("Network error: connection refused"); + + // http_request should have been emitted before the fetch call + expect(capturedRequestEvents).toHaveLength(1); + expect(capturedRequestEvents[0].url).toBe(serverUrl); + + // http_response should NOT have been emitted due to the error + expect(capturedResponseEvents).toHaveLength(0); + }); + + it("should not call globalThis.fetch and not emit http_response when hook cancels", async () => { + const capturedRequestEvents: HttpRequestEvent[] = []; + const capturedResponseEvents: HttpResponseEvent[] = []; + + const ext = createExtension( + (event) => { + capturedRequestEvents.push(event); + return { cancel: true }; + }, + (event) => { + capturedResponseEvents.push(event); + return undefined; + }, + ); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + // Mock globalThis.fetch to track if it's called - vitest will restore in afterEach + const fetchSpy = vi.spyOn(globalThis, "fetch"); + + await expect( + wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/json" }, + body: "{}", + }), + ).rejects.toThrow("HTTP request cancelled by extension"); + + // http_request was emitted + expect(capturedRequestEvents).toHaveLength(1); + + // globalThis.fetch was NEVER called + expect(fetchSpy).not.toHaveBeenCalled(); + + // http_response was NEVER emitted + expect(capturedResponseEvents).toHaveLength(0); + }); + + it("should handle hook returning empty object (no headers, no cancel)", async () => { + let capturedEvent: HttpRequestEvent | undefined; + + const ext = createExtension((event) => { + capturedEvent = event; + // Return empty object - should be treated as no modifications + return {}; + }); + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const model = createMockModel(); + const wrappedFetch = createFetchWithExtensions(extensionRunner, model); + + const response = await wrappedFetch(serverUrl, { + method: "POST", + headers: { "content-type": "application/json" }, + body: "{}", + }); + + // Request should succeed + expect(response.status).toBe(200); + expect(capturedEvent).toBeDefined(); + }); +}); + +describe("exported helper functions", () => { + describe("redactHeaders", () => { + it("should redact sensitive headers", () => { + const headers = { + "content-type": "application/json", + authorization: "Bearer secret123", + "x-api-key": "key123", + }; + + const result = redactHeaders(headers); + + expect(result["content-type"]).toBe("application/json"); + expect(result.authorization).toBe("[REDACTED]"); + expect(result["x-api-key"]).toBe("[REDACTED]"); + }); + + it("should redact headers matching patterns", () => { + const headers = { + "x-auth-token": "token-value", + "custom-secret-value": "secret", + }; + + const result = redactHeaders(headers); + + expect(result["x-auth-token"]).toBe("[REDACTED]"); + expect(result["custom-secret-value"]).toBe("[REDACTED]"); + }); + }); + + describe("headersToRecord", () => { + it("should convert Headers to Record", () => { + const headers = new Headers(); + headers.set("content-type", "application/json"); + headers.set("x-custom", "value"); + + const result = headersToRecord(headers); + + expect(result["content-type"]).toBe("application/json"); + expect(result["x-custom"]).toBe("value"); + }); + }); + + describe("createExtensionFetchFactory", () => { + it("should return undefined when runner is undefined", () => { + const result = createExtensionFetchFactory(undefined); + expect(result).toBeUndefined(); + }); + + it("should return undefined when no HTTP handlers are registered", () => { + const ext: LoadedExtension = { + path: "test-extension", + resolvedPath: "/test/test-extension.ts", + handlers: new Map(), // No handlers + tools: new Map(), + messageRenderers: new Map(), + commands: new Map(), + flags: new Map(), + flagValues: new Map(), + shortcuts: new Map(), + setSendMessageHandler: () => {}, + setSendUserMessageHandler: () => {}, + setAppendEntryHandler: () => {}, + setGetActiveToolsHandler: () => {}, + setGetAllToolsHandler: () => {}, + setSetActiveToolsHandler: () => {}, + setFlagValue: () => {}, + }; + + const extensionRunner = new ExtensionRunner( + [ext], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + const result = createExtensionFetchFactory(extensionRunner); + + expect(result).toBeUndefined(); + }); + }); +}); diff --git a/packages/coding-agent/test/hooks/http-hooks.test.ts b/packages/coding-agent/test/hooks/http-hooks.test.ts new file mode 100644 index 000000000..990b92399 --- /dev/null +++ b/packages/coding-agent/test/hooks/http-hooks.test.ts @@ -0,0 +1,490 @@ +/** + * Tests for HTTP extension events (http_request / http_response). + * + * These tests verify the extension infrastructure for HTTP events without making real API calls. + */ + +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { ExtensionRunner } from "../../src/core/extensions/runner.js"; +import type { + HttpRequestEvent, + HttpRequestEventResult, + HttpResponseEvent, + LoadedExtension, +} from "../../src/core/extensions/types.js"; +import type { ModelRegistry } from "../../src/core/model-registry.js"; +import type { SessionManager } from "../../src/core/session-manager.js"; + +// Mock SessionManager (minimal interface for ExtensionRunner) +function createMockSessionManager(): SessionManager { + return { + getCwd: () => "/test", + getSessionDir: () => "/test/.pi/sessions", + getSessionId: () => "test-session", + getSessionFile: () => "/test/.pi/sessions/test.jsonl", + getLeafUuid: () => "test-uuid", + getLeafEntry: () => undefined, + getEntry: () => undefined, + getLabel: () => undefined, + getPath: () => [], + getHeader: () => undefined, + getEntries: () => [], + getTree: () => ({ roots: [], currentPath: [] }), + } as unknown as SessionManager; +} + +// Mock ModelRegistry +function createMockModelRegistry(): ModelRegistry { + return { + getApiKey: async () => "test-key", + find: () => undefined, + getAll: () => [], + } as unknown as ModelRegistry; +} + +// Create a LoadedExtension with HTTP handlers +function createExtension( + onHttpRequest?: ( + event: HttpRequestEvent, + ) => HttpRequestEventResult | undefined | Promise, + onHttpResponse?: (event: HttpResponseEvent) => undefined | Promise, +): LoadedExtension { + const handlers = new Map Promise)[]>(); + + if (onHttpRequest) { + handlers.set("http_request", [async (event: unknown) => onHttpRequest(event as HttpRequestEvent)]); + } + + if (onHttpResponse) { + handlers.set("http_response", [async (event: unknown) => onHttpResponse(event as HttpResponseEvent)]); + } + + return { + path: "test-extension", + resolvedPath: "/test/test-extension.ts", + handlers, + tools: new Map(), + messageRenderers: new Map(), + commands: new Map(), + flags: new Map(), + flagValues: new Map(), + shortcuts: new Map(), + setSendMessageHandler: () => {}, + setSendUserMessageHandler: () => {}, + setAppendEntryHandler: () => {}, + setGetActiveToolsHandler: () => {}, + setGetAllToolsHandler: () => {}, + setSetActiveToolsHandler: () => {}, + setFlagValue: () => {}, + }; +} + +describe("HTTP extensions", () => { + let extensionRunner: ExtensionRunner; + let capturedRequestEvents: HttpRequestEvent[]; + let capturedResponseEvents: HttpResponseEvent[]; + + beforeEach(() => { + capturedRequestEvents = []; + capturedResponseEvents = []; + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe("http_request event", () => { + it("should emit http_request event with correct fields", async () => { + const ext = createExtension((event) => { + capturedRequestEvents.push(event); + return undefined; + }); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + await extensionRunner.emitHttpRequest({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + url: "https://api.anthropic.com/v1/messages", + method: "POST", + headers: { + "content-type": "application/json", + authorization: "[REDACTED]", + }, + body: '{"model":"claude-sonnet-4-5"}', + }); + + expect(capturedRequestEvents).toHaveLength(1); + const event = capturedRequestEvents[0]; + expect(event.type).toBe("http_request"); + expect(event.provider).toBe("anthropic"); + expect(event.modelId).toBe("claude-sonnet-4-5"); + expect(event.url).toBe("https://api.anthropic.com/v1/messages"); + expect(event.method).toBe("POST"); + expect(event.headers["content-type"]).toBe("application/json"); + expect(event.headers.authorization).toBe("[REDACTED]"); + expect(event.body).toBe('{"model":"claude-sonnet-4-5"}'); + }); + + it("should allow extensions to add headers via result.headers", async () => { + const ext = createExtension(() => { + return { + headers: { + "x-custom-header": "custom-value", + "x-request-id": "12345", + }, + }; + }); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + const result = await extensionRunner.emitHttpRequest({ + provider: "openai", + modelId: "gpt-4o", + url: "https://api.openai.com/v1/chat/completions", + method: "POST", + headers: { "content-type": "application/json" }, + }); + + expect(result).toBeDefined(); + expect(result!.headers).toBeDefined(); + expect(result!.headers!["x-custom-header"]).toBe("custom-value"); + expect(result!.headers!["x-request-id"]).toBe("12345"); + expect(result!.cancel).toBe(false); + }); + + it("should allow extensions to cancel requests via result.cancel", async () => { + const ext = createExtension(() => { + return { cancel: true }; + }); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + const result = await extensionRunner.emitHttpRequest({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + url: "https://api.anthropic.com/v1/messages", + method: "POST", + headers: {}, + }); + + expect(result).toBeDefined(); + expect(result!.cancel).toBe(true); + }); + + it("should merge headers from multiple extensions", async () => { + const ext1 = createExtension(() => ({ + headers: { "x-hook1": "value1" }, + })); + const ext2 = createExtension(() => ({ + headers: { "x-hook2": "value2" }, + })); + + extensionRunner = new ExtensionRunner( + [ext1, ext2], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const result = await extensionRunner.emitHttpRequest({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + url: "https://api.anthropic.com/v1/messages", + method: "POST", + headers: {}, + }); + + expect(result).toBeDefined(); + expect(result!.headers!["x-hook1"]).toBe("value1"); + expect(result!.headers!["x-hook2"]).toBe("value2"); + }); + + it("should return cancel=true if any extension cancels", async () => { + const ext1 = createExtension(() => ({ + headers: { "x-hook1": "value1" }, + })); + const ext2 = createExtension(() => ({ + cancel: true, + })); + const ext3 = createExtension(() => ({ + headers: { "x-hook3": "value3" }, + })); + + extensionRunner = new ExtensionRunner( + [ext1, ext2, ext3], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const result = await extensionRunner.emitHttpRequest({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + url: "https://api.anthropic.com/v1/messages", + method: "POST", + headers: {}, + }); + + expect(result).toBeDefined(); + expect(result!.cancel).toBe(true); + // Headers from all hooks should still be merged + expect(result!.headers!["x-hook1"]).toBe("value1"); + expect(result!.headers!["x-hook3"]).toBe("value3"); + }); + + it("should return undefined if no extensions are registered", async () => { + extensionRunner = new ExtensionRunner([], "/test", createMockSessionManager(), createMockModelRegistry()); + + const result = await extensionRunner.emitHttpRequest({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + url: "https://api.anthropic.com/v1/messages", + method: "POST", + headers: {}, + }); + + expect(result).toBeUndefined(); + }); + + it("should handle extension errors gracefully", async () => { + const errorExt = createExtension(() => { + throw new Error("Extension error"); + }); + + extensionRunner = new ExtensionRunner( + [errorExt], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const errors: { extensionPath: string; event: string; error: string }[] = []; + extensionRunner.onError((err) => errors.push(err)); + + const result = await extensionRunner.emitHttpRequest({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + url: "https://api.anthropic.com/v1/messages", + method: "POST", + headers: {}, + }); + + expect(result).toBeUndefined(); + expect(errors).toHaveLength(1); + expect(errors[0].extensionPath).toBe("test-extension"); + expect(errors[0].event).toBe("http_request"); + expect(errors[0].error).toContain("Extension error"); + }); + + it("should handle async extension handlers", async () => { + const ext = createExtension(async (event) => { + await new Promise((resolve) => setTimeout(resolve, 10)); + capturedRequestEvents.push(event); + return { headers: { "x-async": "true" } }; + }); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + const result = await extensionRunner.emitHttpRequest({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + url: "https://api.anthropic.com/v1/messages", + method: "POST", + headers: {}, + }); + + expect(capturedRequestEvents).toHaveLength(1); + expect(result!.headers!["x-async"]).toBe("true"); + }); + }); + + describe("http_response event", () => { + it("should emit http_response event with correct fields", async () => { + const ext = createExtension(undefined, (event) => { + capturedResponseEvents.push(event); + return undefined; + }); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + await extensionRunner.emitHttpResponse({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + status: 200, + headers: { + "content-type": "application/json", + "x-request-id": "req-12345", + }, + durationMs: 1500, + }); + + expect(capturedResponseEvents).toHaveLength(1); + const event = capturedResponseEvents[0]; + expect(event.type).toBe("http_response"); + expect(event.provider).toBe("anthropic"); + expect(event.modelId).toBe("claude-sonnet-4-5"); + expect(event.status).toBe(200); + expect(event.headers["content-type"]).toBe("application/json"); + expect(event.headers["x-request-id"]).toBe("req-12345"); + expect(event.durationMs).toBe(1500); + }); + + it("should call multiple response handlers in order", async () => { + const callOrder: string[] = []; + + const ext1: LoadedExtension = { + path: "ext1", + resolvedPath: "/test/ext1.ts", + handlers: new Map([ + [ + "http_response", + [ + async () => { + callOrder.push("hook1"); + return undefined; + }, + ], + ], + ]), + tools: new Map(), + messageRenderers: new Map(), + commands: new Map(), + flags: new Map(), + flagValues: new Map(), + shortcuts: new Map(), + setSendMessageHandler: () => {}, + setSendUserMessageHandler: () => {}, + setAppendEntryHandler: () => {}, + setGetActiveToolsHandler: () => {}, + setGetAllToolsHandler: () => {}, + setSetActiveToolsHandler: () => {}, + setFlagValue: () => {}, + }; + + const ext2: LoadedExtension = { + path: "ext2", + resolvedPath: "/test/ext2.ts", + handlers: new Map([ + [ + "http_response", + [ + async () => { + callOrder.push("hook2"); + return undefined; + }, + ], + ], + ]), + tools: new Map(), + messageRenderers: new Map(), + commands: new Map(), + flags: new Map(), + flagValues: new Map(), + shortcuts: new Map(), + setSendMessageHandler: () => {}, + setSendUserMessageHandler: () => {}, + setAppendEntryHandler: () => {}, + setGetActiveToolsHandler: () => {}, + setGetAllToolsHandler: () => {}, + setSetActiveToolsHandler: () => {}, + setFlagValue: () => {}, + }; + + extensionRunner = new ExtensionRunner( + [ext1, ext2], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + await extensionRunner.emitHttpResponse({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + status: 200, + headers: {}, + durationMs: 100, + }); + + expect(callOrder).toEqual(["hook1", "hook2"]); + }); + + it("should handle response extension errors gracefully", async () => { + const errorExt = createExtension(undefined, () => { + throw new Error("Response extension error"); + }); + + extensionRunner = new ExtensionRunner( + [errorExt], + "/test", + createMockSessionManager(), + createMockModelRegistry(), + ); + + const errors: { extensionPath: string; event: string; error: string }[] = []; + extensionRunner.onError((err) => errors.push(err)); + + // Should not throw + await extensionRunner.emitHttpResponse({ + provider: "anthropic", + modelId: "claude-sonnet-4-5", + status: 200, + headers: {}, + durationMs: 100, + }); + + expect(errors).toHaveLength(1); + expect(errors[0].extensionPath).toBe("test-extension"); + expect(errors[0].event).toBe("http_response"); + expect(errors[0].error).toContain("Response extension error"); + }); + + it("should capture non-200 status codes", async () => { + const ext = createExtension(undefined, (event) => { + capturedResponseEvents.push(event); + return undefined; + }); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + await extensionRunner.emitHttpResponse({ + provider: "openai", + modelId: "gpt-4o", + status: 429, + headers: { "retry-after": "60" }, + durationMs: 50, + }); + + expect(capturedResponseEvents).toHaveLength(1); + expect(capturedResponseEvents[0].status).toBe(429); + expect(capturedResponseEvents[0].headers["retry-after"]).toBe("60"); + }); + }); + + describe("hasHandlers", () => { + it("should return true when http_request handlers exist", () => { + const ext = createExtension(() => undefined); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + expect(extensionRunner.hasHandlers("http_request")).toBe(true); + expect(extensionRunner.hasHandlers("http_response")).toBe(false); + }); + + it("should return true when http_response handlers exist", () => { + const ext = createExtension(undefined, () => undefined); + + extensionRunner = new ExtensionRunner([ext], "/test", createMockSessionManager(), createMockModelRegistry()); + + expect(extensionRunner.hasHandlers("http_request")).toBe(false); + expect(extensionRunner.hasHandlers("http_response")).toBe(true); + }); + + it("should return false when no HTTP handlers exist", () => { + extensionRunner = new ExtensionRunner([], "/test", createMockSessionManager(), createMockModelRegistry()); + + expect(extensionRunner.hasHandlers("http_request")).toBe(false); + expect(extensionRunner.hasHandlers("http_response")).toBe(false); + }); + }); +}); [Showing lines 362-2008 of 2008 (50.0KB limit). Full output: /var/folders/49/l4171l3n219_xwq30fmyzr8w0000gn/T/pi-bash-a4a5107026487cbb.log]

Summary

Summary