feat(har): parse cookies and redirect URL from headers

Extract additional HAR fields from existing log data:
- Parse request cookies from Cookie header
- Parse response cookies from Set-Cookie header (with path, domain,
  expires, httpOnly, secure attributes)
- Extract redirectURL from Location header

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kamilio

src/services/har-service.js

@@ -82,14 +82,15 @@ function buildHarRequest(req) {
   const headers = objectToNameValuePairs(sanitizedHeaders);
   const queryString = extractQueryString(sanitizedUrl);
   const postData = buildPostData(sanitizedBody, sanitizedHeaders);
+  const cookies = parseCookiesFromHeaders(sanitizedHeaders);
 
   return {
     method: req.method || 'GET',
     url: sanitizedUrl,
     httpVersion: 'HTTP/1.1',
     headers,
     queryString,
-    cookies: [],
+    cookies,
     headersSize: -1,
     bodySize: postData ? postData.text.length : -1,
     ...(postData && { postData }),
@@ -120,15 +121,17 @@ function buildHarResponse(res) {
 
   const headers = objectToNameValuePairs(sanitizedHeaders);
   const content = buildContent(sanitizedBody, sanitizedHeaders);
+  const cookies = parseSetCookiesFromHeaders(sanitizedHeaders);
+  const redirectURL = extractRedirectURL(sanitizedHeaders);
 
   return {
     status: res.status || 0,
     statusText: getStatusText(res.status),
     httpVersion: 'HTTP/1.1',
     headers,
-    cookies: [],
+    cookies,
     content,
-    redirectURL: '',
+    redirectURL,
     headersSize: -1,
     bodySize: content.size,
   };
@@ -223,3 +226,84 @@ function getStatusText(status) {
   };
   return statusTexts[status] || '';
 }
+
+function parseCookiesFromHeaders(headers) {
+  if (!headers || typeof headers !== 'object') {
+    return [];
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === 'cookie') {
+      return parseCookieHeader(String(value));
+    }
+  }
+  return [];
+}
+
+function parseCookieHeader(cookieStr) {
+  if (!cookieStr) return [];
+  return cookieStr.split(';').map((pair) => {
+    const [name, ...rest] = pair.trim().split('=');
+    return {
+      name: name || '',
+      value: rest.join('=') || '',
+    };
+  }).filter((c) => c.name);
+}
+
+function parseSetCookiesFromHeaders(headers) {
+  if (!headers || typeof headers !== 'object') {
+    return [];
+  }
+  const cookies = [];
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === 'set-cookie') {
+      const values = Array.isArray(value) ? value : [value];
+      for (const v of values) {
+        const cookie = parseSetCookieValue(String(v));
+        if (cookie) cookies.push(cookie);
+      }
+    }
+  }
+  return cookies;
+}
+
+function parseSetCookieValue(setCookieStr) {
+  if (!setCookieStr) return null;
+  const parts = setCookieStr.split(';').map((p) => p.trim());
+  if (parts.length === 0) return null;
+
+  const [nameValue, ...attributes] = parts;
+  const [name, ...rest] = nameValue.split('=');
+  if (!name) return null;
+
+  const cookie = {
+    name,
+    value: rest.join('=') || '',
+  };
+
+  for (const attr of attributes) {
+    const [attrName, ...attrRest] = attr.split('=');
+    const attrLower = (attrName || '').toLowerCase();
+    const attrValue = attrRest.join('=');
+
+    if (attrLower === 'path') cookie.path = attrValue;
+    else if (attrLower === 'domain') cookie.domain = attrValue;
+    else if (attrLower === 'expires') cookie.expires = attrValue;
+    else if (attrLower === 'httponly') cookie.httpOnly = true;
+    else if (attrLower === 'secure') cookie.secure = true;
+  }
+
+  return cookie;
+}
+
+function extractRedirectURL(headers) {
+  if (!headers || typeof headers !== 'object') {
+    return '';
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === 'location') {
+      return String(value);
+    }
+  }
+  return '';
+}

tests/har-service.test.js

@@ -154,6 +154,74 @@ describe('logToHar', () => {
 
     assert.strictEqual(postData.mimeType, 'application/json');
   });
+
+  it('should parse cookies from Cookie header', () => {
+    const log = {
+      timestamp: '2026-01-24T19:35:45.748Z',
+      request: {
+        method: 'GET',
+        url: 'https://api.example.com/v1/chat',
+        headers: {
+          'cookie': 'session=abc123; user=john; token=xyz',
+        },
+      },
+      response: { status: 200, headers: {}, body: {} },
+    };
+
+    const har = logToHar(log);
+    const cookies = har.log.entries[0].request.cookies;
+
+    assert.strictEqual(cookies.length, 3);
+    assert.strictEqual(cookies[0].name, 'session');
+    assert.strictEqual(cookies[0].value, 'abc123');
+    assert.strictEqual(cookies[1].name, 'user');
+    assert.strictEqual(cookies[1].value, 'john');
+  });
+
+  it('should parse Set-Cookie headers in response', () => {
+    const log = {
+      timestamp: '2026-01-24T19:35:45.748Z',
+      request: { method: 'GET', url: 'https://api.example.com/v1/chat', headers: {} },
+      response: {
+        status: 200,
+        headers: {
+          'set-cookie': 'session=abc123; Path=/; HttpOnly; Secure',
+        },
+        body: {},
+      },
+    };
+
+    const har = logToHar(log);
+    const cookies = har.log.entries[0].response.cookies;
+
+    assert.strictEqual(cookies.length, 1);
+    assert.strictEqual(cookies[0].name, 'session');
+    assert.strictEqual(cookies[0].value, 'abc123');
+    assert.strictEqual(cookies[0].path, '/');
+    assert.strictEqual(cookies[0].httpOnly, true);
+    assert.strictEqual(cookies[0].secure, true);
+  });
+
+  it('should extract redirectURL from Location header', () => {
+    const log = {
+      timestamp: '2026-01-24T19:35:45.748Z',
+      request: { method: 'GET', url: 'https://api.example.com/old', headers: {} },
+      response: {
+        status: 302,
+        headers: {
+          'location': 'https://api.example.com/new',
+        },
+        body: {},
+      },
+    };
+
+    const har = logToHar(log);
+    const entry = har.log.entries[0];
+
+    assert.strictEqual(entry.response.redirectURL, 'https://api.example.com/new');
+    assert.strictEqual(entry.response.status, 302);
+    assert.strictEqual(entry.response.statusText, 'Found');
+  });
 });
 
 describe('logsToHar', () => {