har-mcp 0.1.0

package/src/tools/read-har/formatters/content.ts

@@ -0,0 +1,90 @@
+/**
+ * Content Formatter for Read HAR Tool
+ */
+
+import type { HarEntry } from "../../../types/har.ts"
+import { formatBytes, formatContentForDisplay, getCodeFenceLanguage } from "../helpers.ts"
+import type { ReadHarInput } from "../schema.ts"
+
+/**
+ * Formats content mode output for a single entry
+ */
+export function formatEntryContent(
+  index: number,
+  entry: HarEntry,
+  options: NonNullable<ReadHarInput["contentOptions"]>,
+): string {
+  const lines: string[] = []
+
+  lines.push(`# Entry #${index} Content`)
+  lines.push("")
+
+  // Request summary
+  lines.push("## Request")
+  lines.push(`- **${entry.request.method}** ${entry.request.url}`)
+  lines.push(`- **Status:** ${entry.response.status} ${entry.response.statusText}`)
+  lines.push("")
+
+  // Request body
+  if (options.includeRequestBody && entry.request.postData?.text) {
+    const mimeType = entry.request.postData.mimeType
+    const size = entry.request.bodySize
+    let content = entry.request.postData.text
+    let truncated = false
+
+    if (content.length > options.maxContentLength) {
+      content = content.slice(0, options.maxContentLength)
+      truncated = true
+    }
+
+    lines.push(`### Request Body (${mimeType}, ${formatBytes(size)})`)
+
+    // Determine code fence language
+    const lang = getCodeFenceLanguage(mimeType)
+    lines.push(`\`\`\`${lang}`)
+    lines.push(formatContentForDisplay(content, mimeType))
+    lines.push("```")
+
+    if (truncated) {
+      lines.push(`> Content truncated at ${options.maxContentLength.toLocaleString()} characters`)
+    }
+    lines.push("")
+  }
+
+  // Response body
+  if (options.includeResponseBody && entry.response.content.text) {
+    const mimeType = entry.response.content.mimeType
+    const size = entry.response.content.size
+    let content = entry.response.content.text
+    let truncated = false
+
+    // Handle base64 encoded content
+    if (entry.response.content.encoding === "base64") {
+      try {
+        content = Buffer.from(content, "base64").toString("utf-8")
+      } catch {
+        content = "[Base64 content - unable to decode as UTF-8]"
+      }
+    }
+
+    if (content.length > options.maxContentLength) {
+      content = content.slice(0, options.maxContentLength)
+      truncated = true
+    }
+
+    lines.push(`### Response Body (${mimeType}, ${formatBytes(size)})`)
+
+    // Determine code fence language
+    const lang = getCodeFenceLanguage(mimeType)
+    lines.push(`\`\`\`${lang}`)
+    lines.push(formatContentForDisplay(content, mimeType))
+    lines.push("```")
+
+    if (truncated) {
+      lines.push(`> Content truncated at ${options.maxContentLength.toLocaleString()} characters`)
+    }
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}

package/src/tools/read-har/formatters/cookies.ts

@@ -0,0 +1,164 @@
+/**
+ * Cookies Analysis Formatter for Read HAR Tool
+ */
+
+import type { HarFile } from "../../../types/har.ts"
+
+/**
+ * Formats cookies analysis mode output - tracks cookie propagation
+ */
+export function formatCookiesAnalysis(harFile: HarFile, filename: string): string {
+  const entries = harFile.log.entries
+  const lines: string[] = []
+
+  // Track all cookies
+  const cookieHistory = new Map<
+    string,
+    {
+      domain: string
+      setAt: { index: number; url: string; value: string }[]
+      sentAt: { index: number; url: string }[]
+      values: Set<string>
+    }
+  >()
+
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i]!
+    let domain: string
+    try {
+      domain = new URL(entry.request.url).hostname
+    } catch {
+      domain = "unknown"
+    }
+
+    // Track cookies sent in request
+    for (const cookie of entry.request.cookies) {
+      const existing = cookieHistory.get(cookie.name) || {
+        domain,
+        setAt: [],
+        sentAt: [],
+        values: new Set<string>(),
+      }
+      existing.sentAt.push({ index: i, url: entry.request.url })
+      existing.values.add(cookie.value)
+      cookieHistory.set(cookie.name, existing)
+    }
+
+    // Track cookies set in response
+    for (const cookie of entry.response.cookies) {
+      const existing = cookieHistory.get(cookie.name) || {
+        domain: cookie.domain || domain,
+        setAt: [],
+        sentAt: [],
+        values: new Set<string>(),
+      }
+      existing.setAt.push({ index: i, url: entry.request.url, value: cookie.value })
+      existing.values.add(cookie.value)
+      if (cookie.domain) existing.domain = cookie.domain
+      cookieHistory.set(cookie.name, existing)
+    }
+
+    // Also check Set-Cookie headers
+    for (const header of entry.response.headers) {
+      if (header.name.toLowerCase() === "set-cookie") {
+        const match = header.value.match(/^([^=]+)=([^;]*)/)
+        if (match) {
+          const [, name, value] = match
+          if (name && value !== undefined) {
+            const existing = cookieHistory.get(name) || {
+              domain,
+              setAt: [],
+              sentAt: [],
+              values: new Set<string>(),
+            }
+            existing.setAt.push({ index: i, url: entry.request.url, value })
+            existing.values.add(value)
+            cookieHistory.set(name, existing)
+          }
+        }
+      }
+    }
+  }
+
+  lines.push(`# HAR Cookie Analysis: ${filename}`)
+  lines.push("")
+
+  if (cookieHistory.size === 0) {
+    lines.push("No cookies found in this HAR file.")
+    return lines.join("\n")
+  }
+
+  lines.push(`**Total Unique Cookies:** ${cookieHistory.size}`)
+  lines.push("")
+
+  // Cookie Summary Table
+  lines.push("## Cookie Summary")
+  lines.push("| Cookie Name | Domain | Set Count | Sent Count | Value Changes |")
+  lines.push("|-------------|--------|-----------|------------|---------------|")
+
+  const sortedCookies = Array.from(cookieHistory.entries()).sort(
+    (a, b) => b[1].setAt.length + b[1].sentAt.length - (a[1].setAt.length + a[1].sentAt.length),
+  )
+
+  for (const [name, data] of sortedCookies) {
+    const valueChanges = data.values.size > 1 ? `${data.values.size} values` : "static"
+    lines.push(
+      `| ${name.slice(0, 20)} | ${data.domain.slice(0, 15)} | ${data.setAt.length} | ${data.sentAt.length} | ${valueChanges} |`,
+    )
+  }
+  lines.push("")
+
+  // Session cookies (likely auth-related)
+  const sessionCookies = Array.from(cookieHistory.entries()).filter(([name]) =>
+    /session|auth|token|jwt|sid/i.test(name),
+  )
+
+  if (sessionCookies.length > 0) {
+    lines.push("## Session/Auth Cookies")
+    for (const [name, data] of sessionCookies) {
+      lines.push(`### ${name}`)
+      lines.push(`- **Domain:** ${data.domain}`)
+      lines.push(`- **Value Changes:** ${data.values.size}`)
+
+      if (data.setAt.length > 0) {
+        lines.push(`- **First Set:** Entry #${data.setAt[0]?.index}`)
+      }
+      if (data.sentAt.length > 0) {
+        lines.push(`- **First Sent:** Entry #${data.sentAt[0]?.index}`)
+        lines.push(`- **Last Sent:** Entry #${data.sentAt[data.sentAt.length - 1]?.index}`)
+      }
+      lines.push("")
+    }
+  }
+
+  // Cookie flow timeline
+  lines.push("## Cookie Flow (first 10 events)")
+
+  type CookieEvent = { index: number; type: "set" | "sent"; cookie: string; url: string }
+  const events: CookieEvent[] = []
+
+  for (const [name, data] of cookieHistory) {
+    for (const set of data.setAt) {
+      events.push({ index: set.index, type: "set", cookie: name, url: set.url })
+    }
+    for (const sent of data.sentAt.slice(0, 3)) {
+      // Limit sent events
+      events.push({ index: sent.index, type: "sent", cookie: name, url: sent.url })
+    }
+  }
+
+  events.sort((a, b) => a.index - b.index)
+
+  for (const event of events.slice(0, 10)) {
+    const icon = event.type === "set" ? "SET" : "SENT"
+    let url: string
+    try {
+      url = new URL(event.url).pathname.slice(0, 30)
+    } catch {
+      url = event.url.slice(0, 30)
+    }
+    lines.push(`- #${event.index} [${icon}] **${event.cookie}** ${event.type === "set" ? "set by" : "sent to"} ${url}`)
+  }
+
+  return lines.join("\n")
+}

package/src/tools/read-har/formatters/detail.ts

@@ -0,0 +1,148 @@
+/**
+ * Detail Formatter for Read HAR Tool
+ */
+
+import type { HarEntry } from "../../../types/har.ts"
+import { formatBytes, formatDuration, getTotalTiming, isError, truncateUrl } from "../helpers.ts"
+import type { ReadHarInput } from "../schema.ts"
+
+/**
+ * Formats detail mode output for a single entry
+ */
+export function formatEntryDetail(
+  index: number,
+  entry: HarEntry,
+  include: NonNullable<ReadHarInput["include"]>,
+): string {
+  const lines: string[] = []
+
+  lines.push(`# Entry #${index} Details`)
+  lines.push("")
+
+  // Request section
+  lines.push("## Request")
+  lines.push(`- **Method:** ${entry.request.method}`)
+  lines.push(`- **URL:** ${entry.request.url}`)
+  lines.push(`- **HTTP Version:** ${entry.request.httpVersion}`)
+  lines.push("")
+
+  // Query Parameters
+  if (include.queryParams && entry.request.queryString.length > 0) {
+    lines.push("### Query Parameters")
+    lines.push("| Name | Value |")
+    lines.push("|------|-------|")
+    for (const param of entry.request.queryString) {
+      lines.push(`| ${param.name} | ${truncateUrl(param.value, 50)} |`)
+    }
+    lines.push("")
+  }
+
+  // Request Headers
+  if (include.headers && entry.request.headers.length > 0) {
+    lines.push("### Headers")
+    lines.push("| Name | Value |")
+    lines.push("|------|-------|")
+    for (const header of entry.request.headers) {
+      // Redact sensitive headers
+      let value = header.value
+      if (/^(authorization|cookie|x-api-key|x-auth)/i.test(header.name)) {
+        value = "[REDACTED]"
+      }
+      lines.push(`| ${header.name} | ${truncateUrl(value, 50)} |`)
+    }
+    lines.push("")
+  }
+
+  // Request Cookies
+  if (include.cookies && entry.request.cookies.length > 0) {
+    lines.push("### Cookies")
+    lines.push("| Name | Value |")
+    lines.push("|------|-------|")
+    for (const cookie of entry.request.cookies) {
+      lines.push(`| ${cookie.name} | ${truncateUrl(cookie.value, 50)} |`)
+    }
+    lines.push("")
+  }
+
+  // Request Body info
+  if (entry.request.postData) {
+    lines.push("### Body")
+    lines.push(`- **Type:** ${entry.request.postData.mimeType}`)
+    lines.push(`- **Size:** ${formatBytes(entry.request.bodySize)}`)
+    lines.push('- _(Content not included - use mode: "content" to view)_')
+    lines.push("")
+  }
+
+  // Response section
+  lines.push("## Response")
+  lines.push(`- **Status:** ${entry.response.status} ${entry.response.statusText}`)
+  lines.push(`- **HTTP Version:** ${entry.response.httpVersion}`)
+  lines.push("")
+
+  // Response Headers
+  if (include.headers && entry.response.headers.length > 0) {
+    lines.push("### Headers")
+    lines.push("| Name | Value |")
+    lines.push("|------|-------|")
+    for (const header of entry.response.headers) {
+      // Redact sensitive headers
+      let value = header.value
+      if (/^(set-cookie)/i.test(header.name)) {
+        value = "[REDACTED]"
+      }
+      lines.push(`| ${header.name} | ${truncateUrl(value, 50)} |`)
+    }
+    lines.push("")
+  }
+
+  // Response Cookies
+  if (include.cookies && entry.response.cookies.length > 0) {
+    lines.push("### Cookies")
+    lines.push("| Name | Value |")
+    lines.push("|------|-------|")
+    for (const cookie of entry.response.cookies) {
+      lines.push(`| ${cookie.name} | ${truncateUrl(cookie.value, 50)} |`)
+    }
+    lines.push("")
+  }
+
+  // Response Body info
+  lines.push("### Body")
+  lines.push(`- **Type:** ${entry.response.content.mimeType}`)
+  lines.push(`- **Size:** ${formatBytes(entry.response.content.size)}`)
+  lines.push('- _(Content not included - use mode: "content" to view)_')
+  lines.push("")
+
+  // Timing section
+  if (include.timing) {
+    const timings = entry.timings
+    lines.push("## Timing Breakdown")
+    lines.push("| Phase | Duration |")
+    lines.push("|-------|----------|")
+
+    const formatTiming = (val?: number): string => {
+      if (val === undefined || val < 0) return "-"
+      return formatDuration(val)
+    }
+
+    lines.push(`| Blocked | ${formatTiming(timings.blocked)} |`)
+    lines.push(`| DNS | ${formatTiming(timings.dns)} |`)
+    lines.push(`| Connect | ${formatTiming(timings.connect)} |`)
+    lines.push(`| SSL | ${formatTiming(timings.ssl)} |`)
+    lines.push(`| Send | ${formatTiming(timings.send)} |`)
+    lines.push(`| Wait (TTFB) | ${formatTiming(timings.wait)} |`)
+    lines.push(`| Receive | ${formatTiming(timings.receive)} |`)
+
+    const total = getTotalTiming(timings)
+    lines.push(`| **Total** | **${formatDuration(total)}** |`)
+    lines.push("")
+
+    // Add note about high wait times for errors
+    if (isError(entry) && timings.wait > 1000) {
+      lines.push(`> Note: Server took ${formatDuration(timings.wait)} before returning error (high wait time)`)
+      lines.push("")
+    }
+  }
+
+  return lines.join("\n")
+}

package/src/tools/read-har/formatters/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Formatters Index - Re-export all formatters
+ */
+
+export { formatSummary } from "./summary.ts"
+export { formatList } from "./list.ts"
+export { formatEntryDetail } from "./detail.ts"
+export { formatEntryContent } from "./content.ts"
+export { formatTimeline } from "./timeline.ts"
+export { formatStats } from "./stats.ts"
+export { formatSizeAnalysis } from "./size.ts"
+export { formatCookiesAnalysis } from "./cookies.ts"

package/src/tools/read-har/formatters/list.ts

@@ -0,0 +1,89 @@
+/**
+ * List Formatter for Read HAR Tool
+ */
+
+import type { IndexedEntry } from "../filters.ts"
+import { formatBytes, formatDuration, getResponseSize, getUrlPath, isError, truncateUrl } from "../helpers.ts"
+import type { ReadHarInput } from "../schema.ts"
+
+/**
+ * Formats list mode output
+ */
+export function formatList(
+  indexedEntries: IndexedEntry[],
+  filename: string,
+  page: number,
+  pageSize: number,
+  totalCount: number,
+  filter?: ReadHarInput["filter"],
+): string {
+  const lines: string[] = []
+  const totalPages = Math.ceil(totalCount / pageSize)
+  const start = (page - 1) * pageSize + 1
+  const end = Math.min(page * pageSize, totalCount)
+
+  lines.push(`# HAR Entries: ${filename}`)
+  lines.push("")
+  lines.push(`**Showing ${start}-${end} of ${totalCount} entries** (Page ${page}/${totalPages})`)
+
+  // Show active filters
+  if (filter) {
+    const filterParts: string[] = []
+    if (filter.url) filterParts.push(`url=${filter.url}`)
+    if (filter.method) {
+      const methods = Array.isArray(filter.method) ? filter.method.join(",") : filter.method
+      filterParts.push(`method=${methods}`)
+    }
+    if (filter.status !== undefined) {
+      if (typeof filter.status === "object") {
+        const { min, max } = filter.status
+        filterParts.push(`status=${min || ""}..${max || ""}`)
+      } else {
+        filterParts.push(`status=${filter.status}`)
+      }
+    }
+    if (filter.contentType) filterParts.push(`type=${filter.contentType}`)
+    if (filter.minDuration) filterParts.push(`minDuration=${filter.minDuration}ms`)
+    if (filter.hasError !== undefined) filterParts.push(`hasError=${filter.hasError}`)
+    if (filter.bodyContains) filterParts.push(`bodyContains="${filter.bodyContains}"`)
+
+    if (filterParts.length > 0) {
+      lines.push(`**Filter:** ${filterParts.join(", ")}`)
+    }
+  }
+
+  lines.push("")
+  lines.push("| # | Method | URL | Status | Size | Time |")
+  lines.push("|---|--------|-----|--------|------|------|")
+
+  let totalSize = 0
+  let totalTime = 0
+  let errorCount = 0
+
+  for (const { index, entry } of indexedEntries) {
+    const method = entry.request.method
+    const url = truncateUrl(getUrlPath(entry.request.url), 45)
+    const status = entry.response.status
+    const size = getResponseSize(entry)
+    const time = entry.time
+
+    totalSize += size
+    totalTime += time
+    if (isError(entry)) errorCount++
+
+    lines.push(`| ${index} | ${method} | ${url} | ${status} | ${formatBytes(size)} | ${formatDuration(time)} |`)
+  }
+
+  lines.push("")
+
+  // Quick stats
+  const avgTime = indexedEntries.length > 0 ? totalTime / indexedEntries.length : 0
+  lines.push(`**Quick Stats:** ${errorCount} errors, avg ${formatDuration(avgTime)}, total ${formatBytes(totalSize)}`)
+  lines.push("")
+
+  // Usage hints
+  lines.push('> Use `mode: "detail", entries: [INDEX]` to see full details')
+  lines.push('> Use `mode: "content", entries: [INDEX]` to see response body')
+
+  return lines.join("\n")
+}

package/src/tools/read-har/formatters/size.ts

@@ -0,0 +1,150 @@
+/**
+ * Size Analysis Formatter for Read HAR Tool
+ */
+
+import type { HarFile } from "../../../types/har.ts"
+import { formatBytes, getContentTypeCategory } from "../helpers.ts"
+
+/**
+ * Formats size analysis mode output
+ */
+export function formatSizeAnalysis(harFile: HarFile, filename: string): string {
+  const entries = harFile.log.entries
+  const lines: string[] = []
+
+  // Collect size data by type
+  const sizeByType = new Map<
+    string,
+    { count: number; totalSize: number; entries: { index: number; url: string; size: number }[] }
+  >()
+  let totalSize = 0
+  let totalTransferred = 0
+
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i]!
+    const contentType = getContentTypeCategory(entry.response.content.mimeType)
+    const size = entry.response.content.size
+    const transferred = entry.response.bodySize > 0 ? entry.response.bodySize : size
+
+    totalSize += size
+    totalTransferred += transferred
+
+    const existing = sizeByType.get(contentType) || { count: 0, totalSize: 0, entries: [] }
+    existing.count++
+    existing.totalSize += size
+    existing.entries.push({
+      index: i,
+      url: entry.request.url,
+      size,
+    })
+    sizeByType.set(contentType, existing)
+  }
+
+  lines.push(`# HAR Size Analysis: ${filename}`)
+  lines.push("")
+
+  // Overview
+  lines.push("## Overview")
+  lines.push(`- **Total Entries:** ${entries.length}`)
+  lines.push(`- **Total Size:** ${formatBytes(totalSize)}`)
+  lines.push(`- **Total Transferred:** ${formatBytes(totalTransferred)}`)
+  if (totalTransferred < totalSize) {
+    const savings = ((1 - totalTransferred / totalSize) * 100).toFixed(1)
+    lines.push(`- **Compression Savings:** ${savings}%`)
+  }
+  lines.push("")
+
+  // Size by Type
+  lines.push("## Size by Content Type")
+  lines.push("| Type | Count | Total Size | Avg Size | % of Total |")
+  lines.push("|------|-------|------------|----------|------------|")
+
+  const sortedTypes = Array.from(sizeByType.entries()).sort((a, b) => b[1].totalSize - a[1].totalSize)
+
+  for (const [type, data] of sortedTypes) {
+    const avgSize = data.totalSize / data.count
+    const percentage = ((data.totalSize / totalSize) * 100).toFixed(1)
+    lines.push(
+      `| ${type} | ${data.count} | ${formatBytes(data.totalSize)} | ${formatBytes(avgSize)} | ${percentage}% |`,
+    )
+  }
+  lines.push("")
+
+  // Largest resources
+  const allEntries = entries
+    .map((e, i) => ({
+      index: i,
+      url: e.request.url,
+      size: e.response.content.size,
+      type: getContentTypeCategory(e.response.content.mimeType),
+    }))
+    .sort((a, b) => b.size - a.size)
+
+  lines.push("## Largest Resources")
+  lines.push("| # | Type | Size | URL |")
+  lines.push("|---|------|------|-----|")
+
+  for (const entry of allEntries.slice(0, 10)) {
+    let url: string
+    try {
+      const parsed = new URL(entry.url)
+      url = parsed.pathname.slice(0, 40)
+    } catch {
+      url = entry.url.slice(0, 40)
+    }
+    lines.push(`| ${entry.index} | ${entry.type} | ${formatBytes(entry.size)} | ${url} |`)
+  }
+  lines.push("")
+
+  // Optimization Suggestions
+  lines.push("## Optimization Suggestions")
+
+  const suggestions: string[] = []
+
+  // Check for large images
+  const imageData = sizeByType.get("Image")
+  if (imageData && imageData.totalSize > 500 * 1024) {
+    const largeImages = imageData.entries.filter(e => e.size > 100 * 1024)
+    if (largeImages.length > 0) {
+      suggestions.push(
+        `- **Large Images:** ${largeImages.length} images over 100KB. Consider compression or WebP format.`,
+      )
+    }
+  }
+
+  // Check for large JS
+  const jsData = sizeByType.get("JS")
+  if (jsData && jsData.totalSize > 500 * 1024) {
+    suggestions.push(
+      `- **Large JavaScript:** ${formatBytes(jsData.totalSize)} total. Consider code splitting or lazy loading.`,
+    )
+  }
+
+  // Check for uncompressed responses
+  const largeUncompressed = entries.filter(
+    e => e.response.content.size > 10 * 1024 && e.response.bodySize >= e.response.content.size * 0.9,
+  )
+  if (largeUncompressed.length > 0) {
+    suggestions.push(
+      `- **Uncompressed Responses:** ${largeUncompressed.length} responses may benefit from gzip/brotli compression.`,
+    )
+  }
+
+  // Check for duplicate requests
+  const urlCounts = new Map<string, number>()
+  for (const entry of entries) {
+    urlCounts.set(entry.request.url, (urlCounts.get(entry.request.url) || 0) + 1)
+  }
+  const duplicates = Array.from(urlCounts.entries()).filter(([, count]) => count > 1)
+  if (duplicates.length > 0) {
+    suggestions.push(`- **Duplicate Requests:** ${duplicates.length} URLs requested multiple times. Consider caching.`)
+  }
+
+  if (suggestions.length === 0) {
+    suggestions.push("- No major optimization issues detected.")
+  }
+
+  lines.push(...suggestions)
+
+  return lines.join("\n")
+}