@gpzhang2001/sharpkit-proxy 0.2.1

package/src/replay.ts

@@ -0,0 +1,228 @@
+/**
+ * Pure HTTP replay helpers, ported from strix tools/proxy/caido_api.py:
+ * raw request parsing/rebuilding with framing-header hygiene (:173-218),
+ * response parsing (:220-258), request-line parsing (:260-279), URL
+ * composition (:281-292), and field modifications (:294-331). Total pure
+ * functions — exhaustively unit-testable.
+ * @module @gpzhang2001/sharpkit-proxy/replay
+ */
+
+/** Parsed components of a raw HTTP request text. */
+export interface RawRequestComponents {
+  readonly method: string
+  readonly urlPath: string
+  readonly headers: Record<string, string>
+  readonly body: string
+}
+
+/** A connection target for Caido's replay dispatch. */
+export interface ConnectionInfo {
+  readonly host: string
+  readonly port: number
+  readonly tls: boolean
+  readonly sni?: string
+}
+
+/** Parsed summary of a raw HTTP response (strix list_requests shape). */
+export interface RawResponseParts {
+  readonly statusCode: number
+  readonly length: number
+  readonly headers: Record<string, string>
+  readonly body: string
+  readonly bodyTruncated: boolean
+}
+
+/** strix clips replay response bodies at 8192 chars (caido_api.py:222). */
+const RESPONSE_BODY_MAX_CHARS = 8192
+
+/** Framing headers that must never survive into a modified replay (strix :175). */
+const FRAMING_HEADERS = new Set(['content-length', 'transfer-encoding'])
+
+/**
+ * Parse a raw HTTP request text into components (strix `parse_raw_request`).
+ * @param rawContent - the raw request text.
+ * @returns the parsed components.
+ * @throws when the request line is malformed.
+ */
+export function parseRawRequest(rawContent: string): RawRequestComponents {
+  const lines = rawContent.split('\n')
+  const requestLine = (lines[0] ?? '').trim().split(' ')
+  if (requestLine.length < 2) throw new Error('Invalid request line format')
+  const headers: Record<string, string> = {}
+  let bodyStart = 0
+  for (let index = 1; index < lines.length; index++) {
+    const line = lines[index] ?? ''
+    if (line.trim() === '') {
+      bodyStart = index + 1
+      break
+    }
+    const separator = line.indexOf(':')
+    if (separator !== -1) headers[line.slice(0, separator).trim()] = line.slice(separator + 1).trim()
+  }
+  const body = bodyStart < lines.length ? lines.slice(bodyStart).join('\n').trim() : ''
+  return { method: requestLine[0] ?? '', urlPath: requestLine[1] ?? '', headers, body }
+}
+
+/**
+ * Compose the full URL from the original request's connection facts, the
+ * parsed components, and an optional explicit url override (strix
+ * `full_url_from_components`).
+ * @param original - the stored request's host/tls facts.
+ * @param components - parsed raw request components.
+ * @param modifications - the patch dict.
+ * @returns the absolute target URL.
+ */
+export function fullUrlFromComponents(
+  original: { readonly host: string; readonly tls: boolean },
+  components: RawRequestComponents,
+  modifications: Readonly<Record<string, unknown>>,
+): string {
+  const override = modifications['url']
+  if (typeof override === 'string' && override !== '') return override
+  const hostHeader = components.headers['Host'] ?? original.host
+  const scheme = original.tls ? 'https' : 'http'
+  return `${scheme}://${hostHeader}${components.urlPath}`
+}
+
+/** Parse a query string into a first-value map (Node parity of parse_qs). */
+function parseQuery(query: string): Record<string, string> {
+  const params: Record<string, string> = {}
+  for (const pair of query.split('&')) {
+    if (pair === '') continue
+    const eq = pair.indexOf('=')
+    const key = eq === -1 ? pair : pair.slice(0, eq)
+    const value = eq === -1 ? '' : pair.slice(eq + 1)
+    params[decodeURIComponent(key)] = decodeURIComponent(value)
+  }
+  return params
+}
+
+/** Serialize a query map back to a string (Node parity of urlencode). */
+function encodeQuery(params: Readonly<Record<string, string>>): string {
+  return Object.entries(params)
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+    .join('&')
+}
+
+/**
+ * Overlay the patch dict onto parsed components (strix `apply_modifications`):
+ * params merge into the query string, headers/cookies merge, body replaces.
+ * @param components - parsed raw request components.
+ * @param modifications - the patch dict (url/params/headers/body/cookies).
+ * @param fullUrl - the composed final URL.
+ * @returns the modified components keyed like strix.
+ */
+export function applyModifications(
+  components: RawRequestComponents,
+  modifications: Readonly<Record<string, unknown>>,
+  fullUrl: string,
+): { readonly method: string; readonly url: string; readonly headers: Record<string, string>; readonly body: string } {
+  const headers = { ...components.headers }
+  let body = components.body
+  let finalUrl = fullUrl
+
+  const params = modifications['params']
+  if (params !== undefined && params !== null && typeof params === 'object') {
+    const question = finalUrl.indexOf('?')
+    const existing = question === -1 ? {} : parseQuery(finalUrl.slice(question + 1))
+    for (const [key, value] of Object.entries(params as Record<string, unknown>)) {
+      existing[key] = String(value)
+    }
+    const base = question === -1 ? finalUrl : finalUrl.slice(0, question)
+    finalUrl = `${base}?${encodeQuery(existing)}`
+  }
+  const headerPatch = modifications['headers']
+  if (headerPatch !== undefined && headerPatch !== null && typeof headerPatch === 'object') {
+    for (const [key, value] of Object.entries(headerPatch as Record<string, unknown>)) {
+      headers[key] = String(value)
+    }
+  }
+  const bodyPatch = modifications['body']
+  if (typeof bodyPatch === 'string') body = bodyPatch
+  const cookiePatch = modifications['cookies']
+  if (cookiePatch !== undefined && cookiePatch !== null && typeof cookiePatch === 'object') {
+    const cookies: Record<string, string> = {}
+    const existingCookie = headers['Cookie']
+    if (existingCookie !== undefined) {
+      for (const cookie of existingCookie.split(';')) {
+        const eq = cookie.indexOf('=')
+        if (eq !== -1) cookies[cookie.slice(0, eq).trim()] = cookie.slice(eq + 1).trim()
+      }
+    }
+    for (const [key, value] of Object.entries(cookiePatch as Record<string, unknown>)) {
+      cookies[key] = String(value)
+    }
+    headers['Cookie'] = Object.entries(cookies).map(([key, value]) => `${key}=${value}`).join('; ')
+  }
+
+  return { method: components.method, url: finalUrl, headers, body }
+}
+
+/**
+ * Rebuild a raw HTTP/1.1 request with connection facts (strix
+ * `build_raw_request`): Host/UA defaults, framing headers dropped,
+ * Content-Length recomputed from the actual body.
+ * @param parts - method/url/headers/body of the replay.
+ * @returns the connection target and encoded raw request bytes.
+ */
+export function buildRawRequest(parts: {
+  readonly method: string
+  readonly url: string
+  readonly headers: Record<string, string>
+  readonly body: string
+}): { readonly connection: ConnectionInfo; readonly raw: Uint8Array } {
+  let parsed: URL
+  try {
+    parsed = new URL(parts.url)
+  } catch {
+    throw new Error(`Invalid URL: ${parts.url}`)
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') throw new Error(`Invalid URL: ${parts.url}`)
+  const tls = parsed.protocol === 'https:'
+  const port = parsed.port !== '' ? Number(parsed.port) : tls ? 443 : 80
+  const path = `${parsed.pathname}${parsed.search}`
+
+  const headers: Record<string, string> = { ...parts.headers }
+  if (headers['Host'] === undefined) headers['Host'] = parsed.host
+  if (headers['User-Agent'] === undefined) {
+    headers['User-Agent'] = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36'
+  }
+  for (const key of Object.keys(headers)) {
+    if (FRAMING_HEADERS.has(key.toLowerCase())) delete headers[key]
+  }
+  if (parts.body !== '') headers['Content-Length'] = String(Buffer.byteLength(parts.body, 'utf8'))
+
+  const lines = [`${parts.method.toUpperCase()} ${path} HTTP/1.1`]
+  for (const [key, value] of Object.entries(headers)) lines.push(`${key}: ${value}`)
+  const raw = Buffer.from(`${lines.join('\r\n')}\r\n\r\n${parts.body}`, 'utf8')
+  return { connection: { host: parsed.hostname, port, tls }, raw }
+}
+
+/**
+ * Parse a raw HTTP response into the list_requests summary shape (strix
+ * `parse_raw_response`); null when missing/unparseable. Body clipped at 8192
+ * chars with a truncation flag.
+ * @param rawBytes - the raw response bytes.
+ * @returns the parsed parts, or null.
+ */
+export function parseRawResponse(rawBytes: Uint8Array | null | undefined): RawResponseParts | null {
+  if (rawBytes === null || rawBytes === undefined || rawBytes.byteLength === 0) return null
+  const text = Buffer.from(rawBytes).toString('latin1')
+  const separator = text.indexOf('\r\n\r\n')
+  if (separator === -1) return null
+  const head = text.slice(0, separator)
+  const lines = head.split('\r\n')
+  const statusParts = (lines[0] ?? '').split(' ')
+  if (statusParts.length < 2 || !/^\d+$/.test(statusParts[1] ?? '')) return null
+  const headers: Record<string, string> = {}
+  for (const line of lines.slice(1)) {
+    const colon = line.indexOf(':')
+    if (colon === -1) continue
+    headers[line.slice(0, colon).trim()] = line.slice(colon + 1).trim()
+  }
+  const bodyBytes = Buffer.from(text.slice(separator + 4), 'latin1')
+  let body = bodyBytes.toString('utf8')
+  const truncated = body.length > RESPONSE_BODY_MAX_CHARS
+  if (truncated) body = body.slice(0, RESPONSE_BODY_MAX_CHARS)
+  return { statusCode: Number(statusParts[1]), length: bodyBytes.byteLength, headers, body, bodyTruncated: truncated }
+}