1import type { TargetSession } from "./cdp-client";
2import type { Logger } from "../utils/logger";
3 
4type JsonObject = Record<string, unknown>;
5 
6export interface NetworkEntry {
7  requestId: string;
8  url: string;
9  method: string;
10  resourceType: string;
11  timestamp: number;
12  requestHeaders?: Record<string, string>;
13  requestBody?: string;
14  status?: number;
15  statusText?: string;
16  responseHeaders?: Record<string, string>;
17  mimeType?: string;
18  body?: string;
19  bodyBase64?: boolean;
20  bodyError?: string;
21  failed?: boolean;
22  failureReason?: string;
23  finished: boolean;
24}
25 
26function normalizeHeaders(headers: unknown): Record<string, string> | undefined {
27  if (!headers || typeof headers !== "object") {
28    return undefined;
29  }
30  return Object.fromEntries(
31    Object.entries(headers as Record<string, unknown>).map(([key, value]) => [key, String(value)]),
32  );
33}
34 
35function sleep(ms: number): Promise<void> {
36  return new Promise((resolve) => setTimeout(resolve, ms));
37}
38 
39export class NetworkJournal {
40  private readonly entries = new Map<string, NetworkEntry>();
41  private lastActivityAt = Date.now();
42  private started = false;
43 
44  constructor(
45    private readonly session: TargetSession,
46    private readonly log: Logger,
47  ) {}
48 
49  async start(): Promise<void> {
50    if (this.started) {
51      return;
52    }
53 
54    this.started = true;
55    this.session.on("Network.requestWillBeSent", this.handleRequestWillBeSent);
56    this.session.on("Network.responseReceived", this.handleResponseReceived);
57    this.session.on("Network.loadingFinished", this.handleLoadingFinished);
58    this.session.on("Network.loadingFailed", this.handleLoadingFailed);
59    await this.session.send("Network.enable");
60  }
61 
62  stop(): void {
63    if (!this.started) {
64      return;
65    }
66    this.session.off("Network.requestWillBeSent", this.handleRequestWillBeSent);
67    this.session.off("Network.responseReceived", this.handleResponseReceived);
68    this.session.off("Network.loadingFinished", this.handleLoadingFinished);
69    this.session.off("Network.loadingFailed", this.handleLoadingFailed);
70    this.started = false;
71  }
72 
73  private touch(): void {
74    this.lastActivityAt = Date.now();
75  }
76 
77  private readonly handleRequestWillBeSent = (params: JsonObject): void => {
78    const requestId = typeof params.requestId === "string" ? params.requestId : undefined;
79    const request = params.request as JsonObject | undefined;
80    if (!requestId || !request) {
81      return;
82    }
83 
84    this.touch();
85    this.entries.set(requestId, {
86      requestId,
87      url: String(request.url ?? ""),
88      method: String(request.method ?? "GET"),
89      resourceType: String(params.type ?? "Other"),
90      timestamp: Date.now(),
91      requestHeaders: normalizeHeaders(request.headers),
92      requestBody: typeof request.postData === "string" ? request.postData : undefined,
93      finished: false,
94    });
95  };
96 
97  private readonly handleResponseReceived = (params: JsonObject): void => {
98    const requestId = typeof params.requestId === "string" ? params.requestId : undefined;
99    const response = params.response as JsonObject | undefined;
100    if (!requestId || !response) {
101      return;
102    }
103 
104    this.touch();
105    const existing = this.entries.get(requestId);
106    if (!existing) {
107      return;
108    }
109 
110    existing.status = typeof response.status === "number" ? response.status : undefined;
111    existing.statusText = typeof response.statusText === "string" ? response.statusText : undefined;
112    existing.responseHeaders = normalizeHeaders(response.headers);
113    existing.mimeType = typeof response.mimeType === "string" ? response.mimeType : undefined;
114    this.entries.set(requestId, existing);
115  };
116 
117  private readonly handleLoadingFinished = (params: JsonObject): void => {
118    const requestId = typeof params.requestId === "string" ? params.requestId : undefined;
119    if (!requestId) {
120      return;
121    }
122 
123    this.touch();
124    const existing = this.entries.get(requestId);
125    if (!existing) {
126      return;
127    }
128    existing.finished = true;
129    this.entries.set(requestId, existing);
130  };
131 
132  private readonly handleLoadingFailed = (params: JsonObject): void => {
133    const requestId = typeof params.requestId === "string" ? params.requestId : undefined;
134    if (!requestId) {
135      return;
136    }
137 
138    this.touch();
139    const existing = this.entries.get(requestId);
140    if (!existing) {
141      return;
142    }
143    existing.finished = true;
144    existing.failed = true;
145    existing.failureReason = typeof params.errorText === "string" ? params.errorText : "Unknown error";
146    this.entries.set(requestId, existing);
147  };
148 
149  getEntries(): NetworkEntry[] {
150    return Array.from(this.entries.values());
151  }
152 
153  findEntries(predicate: (entry: NetworkEntry) => boolean): NetworkEntry[] {
154    return this.getEntries().filter(predicate);
155  }
156 
157  async waitForIdle(options: { idleMs?: number; timeoutMs?: number } = {}): Promise<void> {
158    const idleMs = options.idleMs ?? 1_200;
159    const timeoutMs = options.timeoutMs ?? 15_000;
160    const startedAt = Date.now();
161 
162    while (Date.now() - startedAt < timeoutMs) {
163      if (Date.now() - this.lastActivityAt >= idleMs) {
164        return;
165      }
166      await sleep(Math.min(150, idleMs));
167    }
168 
169    throw new Error("Timed out waiting for network idle");
170  }
171 
172  async waitForResponse(
173    predicate: (entry: NetworkEntry) => boolean,
174    options: { timeoutMs?: number } = {},
175  ): Promise<NetworkEntry> {
176    const timeoutMs = options.timeoutMs ?? 10_000;
177    const startedAt = Date.now();
178 
179    while (Date.now() - startedAt < timeoutMs) {
180      const matched = this.getEntries().find((entry) => entry.finished && predicate(entry));
181      if (matched) {
182        return matched;
183      }
184      await sleep(150);
185    }
186 
187    throw new Error("Timed out waiting for matching network response");
188  }
189 
190  async ensureBody(entry: NetworkEntry): Promise<string | undefined> {
191    if (entry.body !== undefined) {
192      return entry.body;
193    }
194    if (entry.bodyError || entry.failed || !entry.finished) {
195      return undefined;
196    }
197 
198    try {
199      const result = await this.session.send<{ body: string; base64Encoded: boolean }>("Network.getResponseBody", {
200        requestId: entry.requestId,
201      });
202      entry.bodyBase64 = result.base64Encoded;
203      entry.body = result.base64Encoded ? Buffer.from(result.body, "base64").toString("utf8") : result.body;
204      return entry.body;
205    } catch (error) {
206      entry.bodyError = error instanceof Error ? error.message : String(error);
207      this.log.debug(`Failed to fetch response body for ${entry.url}: ${entry.bodyError}`);
208      return undefined;
209    }
210  }
211 
212  async getJsonBody(entry: NetworkEntry): Promise<unknown | null> {
213    const body = await this.ensureBody(entry);
214    if (!body) {
215      return null;
216    }
217 
218    try {
219      return JSON.parse(body);
220    } catch {
221      return null;
222    }
223  }
224 
225  async toJSON(options: { includeBodies?: boolean } = {}): Promise<NetworkEntry[]> {
226    const entries = this.getEntries();
227    if (!options.includeBodies) {
228      return entries;
229    }
230 
231    await Promise.all(entries.map((entry) => this.ensureBody(entry)));
232    return entries;
233  }
234}
235 
236