doru 1.0.0

package/dist/index.mjs

@@ -0,0 +1,605 @@
+import { z } from 'zod';
+import { BatchInterceptor } from '@mswjs/interceptors';
+import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest';
+import { FetchInterceptor } from '@mswjs/interceptors/fetch';
+import * as zlib from 'zlib';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// src/core/config.ts
+var statusCodesSchema = z.object({
+  min: z.number().int().min(100).max(599).nullable().default(null),
+  max: z.number().int().min(100).max(599).nullable().default(null)
+}).refine((s) => s.min === null || s.max === null || s.min <= s.max, {
+  message: "filters.statusCodes.min must be <= filters.statusCodes.max"
+});
+var filtersSchema = z.object({
+  includeHosts: z.array(z.string()).default([]),
+  excludeHosts: z.array(z.string()).default([]),
+  includePaths: z.array(z.string()).default([]),
+  excludePaths: z.array(z.string()).default([]),
+  methods: z.array(z.string()).default([]),
+  statusCodes: statusCodesSchema.default({ min: null, max: null }),
+  minSize: z.number().int().nullable().default(null),
+  maxSize: z.number().int().nullable().default(null)
+});
+var performanceSchema = z.object({
+  bufferSize: z.number().int().positive().default(1024),
+  flushInterval: z.number().int().positive().default(1e3),
+  compression: z.boolean().default(false)
+  // minimal core: compression disabled by default
+});
+var doruConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  outputFile: z.string().default("./network-capture.jsonl"),
+  format: z.enum(["json", "jsonl"]).default("jsonl"),
+  maxFileSize: z.number().int().positive().default(10 * 1024 * 1024),
+  // 10MB
+  filters: filtersSchema.default({
+    includeHosts: [],
+    excludeHosts: [],
+    includePaths: [],
+    excludePaths: [],
+    methods: [],
+    statusCodes: { min: null, max: null },
+    minSize: null,
+    maxSize: null
+  }),
+  performance: performanceSchema.default({
+    bufferSize: 1024,
+    flushInterval: 1e3,
+    compression: false
+  }),
+  debug: z.boolean().default(false)
+});
+var deepMerge = (a, b) => {
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b || {})) {
+    if (v === void 0) continue;
+    const key = k;
+    const av = a[key];
+    if (Array.isArray(v)) {
+      out[key] = v.slice();
+    } else if (v && typeof v === "object" && av && typeof av === "object" && !Array.isArray(av)) {
+      out[key] = deepMerge(
+        av,
+        v
+      );
+    } else out[key] = v;
+  }
+  return out;
+};
+var envDebugDefault = () => {
+  const v = process.env.DORU_DEBUG;
+  if (v === "true") return true;
+  if (v === "false") return false;
+  const legacy = process.env.NETPEEK_DEBUG;
+  if (legacy === "true") return true;
+  if (legacy === "false") return false;
+  return false;
+};
+var normalizeConfig = (c) => {
+  return {
+    ...c,
+    filters: {
+      ...c.filters,
+      methods: c.filters.methods.map((m) => m.toUpperCase())
+    }
+  };
+};
+var createDefaultConfig = (user = {}) => {
+  const defaults = doruConfigSchema.parse({});
+  const merged = deepMerge(defaults, { ...user, debug: user.debug ?? envDebugDefault() });
+  const parsed = doruConfigSchema.parse(merged);
+  return normalizeConfig(parsed);
+};
+
+// src/core/filters.ts
+var FilterEngine = class _FilterEngine {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  updateConfig(next) {
+    this.cfg = next;
+  }
+  shouldCaptureRequest(req) {
+    if (!this.checkHost(req.hostname)) return false;
+    if (!this.checkPath(req.path)) return false;
+    if (!this.checkMethod(req.method)) return false;
+    if (!this.checkSize(req.body)) return false;
+    return true;
+  }
+  shouldCaptureResponse(res) {
+    if (!this.checkStatus(res.statusCode)) return false;
+    if (!this.checkSize(res.body)) return false;
+    return true;
+  }
+  checkHost(host) {
+    const { includeHosts, excludeHosts } = this.cfg;
+    if (includeHosts.length > 0) {
+      const ok = includeHosts.some((p) => _FilterEngine.matchStringOrRegex(host, p));
+      if (!ok) return false;
+    }
+    if (excludeHosts.length > 0) {
+      const hit = excludeHosts.some((p) => _FilterEngine.matchStringOrRegex(host, p));
+      if (hit) return false;
+    }
+    return true;
+  }
+  checkPath(path2) {
+    const { includePaths, excludePaths } = this.cfg;
+    if (includePaths.length > 0) {
+      const ok = includePaths.some((p) => _FilterEngine.matchRegexSafe(path2, p));
+      if (!ok) return false;
+    }
+    if (excludePaths.length > 0) {
+      const hit = excludePaths.some((p) => _FilterEngine.matchRegexSafe(path2, p));
+      if (hit) return false;
+    }
+    return true;
+  }
+  checkMethod(method) {
+    const { methods } = this.cfg;
+    if (methods.length === 0) return true;
+    return methods.includes(method.toUpperCase());
+  }
+  checkStatus(code) {
+    const { min, max } = this.cfg.statusCodes;
+    if (min !== null && code < min) return false;
+    if (max !== null && code > max) return false;
+    return true;
+  }
+  checkSize(body) {
+    if (!body) return true;
+    const size = Buffer.isBuffer(body) ? body.length : Buffer.byteLength(body);
+    const { minSize, maxSize } = this.cfg;
+    if (minSize !== null && size < minSize) return false;
+    if (maxSize !== null && size > maxSize) return false;
+    return true;
+  }
+  // accept user-provided regex in /.../ form, otherwise do substring match
+  static matchStringOrRegex(value, pattern) {
+    if (pattern.startsWith("/") && pattern.endsWith("/")) {
+      try {
+        return new RegExp(pattern.slice(1, -1)).test(value);
+      } catch {
+        return value.includes(pattern);
+      }
+    }
+    return value.includes(pattern);
+  }
+  static matchRegexSafe(value, pattern) {
+    try {
+      return new RegExp(pattern).test(value);
+    } catch {
+      return value.includes(pattern);
+    }
+  }
+};
+
+// src/core/logging.ts
+var DebugLogger = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  info(msg, data) {
+    if (!this.cfg.debug) return;
+    if (data === void 0) console.log(msg);
+    else console.log(msg, data);
+  }
+  error(msg, err) {
+    if (!this.cfg.debug) return;
+    if (err === void 0) console.error(msg);
+    else console.error(msg, err);
+  }
+  tag(tag, msg, data) {
+    this.info(`${tag} ${msg}`, data);
+  }
+};
+var createDebugLogger = (cfg) => new DebugLogger(cfg);
+
+// src/core/interceptor.ts
+var isErrorPayload = (p) => {
+  return p !== null && typeof p === "object" && "requestId" in p && typeof p.requestId === "string";
+};
+var NetworkInterceptor = class _NetworkInterceptor {
+  constructor(cfg, storage) {
+    this.started = false;
+    this.counter = 0;
+    this.pendings = /* @__PURE__ */ new Map();
+    this.storage = storage;
+    this.filter = new FilterEngine(cfg.filters);
+    this.log = createDebugLogger(cfg);
+    this.interceptor = new BatchInterceptor({
+      name: "doru",
+      interceptors: [new ClientRequestInterceptor(), new FetchInterceptor()]
+    });
+    this.wire();
+  }
+  wire() {
+    this.interceptor.on(
+      "request",
+      async ({ request, requestId }) => {
+        try {
+          if (request.url.startsWith("data:") || request.url.startsWith("blob:")) return;
+          const captureId = _NetworkInterceptor.newCaptureId();
+          const start = Date.now();
+          const req = await _NetworkInterceptor.getRequestData(request);
+          if (!this.filter.shouldCaptureRequest(req)) {
+            this.log.tag("\u{1F4E4}", "Request filtered", req.hostname);
+            return;
+          }
+          this.pendings.set(requestId, {
+            captureId,
+            start,
+            hostname: req.hostname,
+            method: req.method
+          });
+          this.captureRequest(captureId, req);
+        } catch (error) {
+          this.log.error("Request intercept error", error);
+        }
+      }
+    );
+    this.interceptor.on(
+      "response",
+      async ({ response, requestId }) => {
+        try {
+          const pending = this.pendings.get(requestId);
+          if (!pending) return;
+          this.pendings.delete(requestId);
+          const res = await _NetworkInterceptor.getResponseData(response);
+          if (!this.filter.shouldCaptureResponse(res)) return;
+          this.captureResponse(pending.captureId, res, pending.start);
+        } catch (error) {
+          this.log.error("Response intercept error", error);
+        }
+      }
+    );
+    const handleErrorEvent = (event) => (payload) => {
+      if (!isErrorPayload(payload)) return;
+      const { error, requestId } = payload;
+      try {
+        const pending = this.pendings.get(requestId);
+        if (!pending) return;
+        this.pendings.delete(requestId);
+        this.captureError(pending.captureId, error, pending.start);
+      } catch (error_) {
+        this.log.error(`${event} handler error`, error_);
+      }
+    };
+    this.interceptor.on("unhandledException", handleErrorEvent("unhandledException"));
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.interceptor.apply();
+    this.log.tag("\u{1F527}", "Network interception started");
+  }
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    this.interceptor.dispose();
+    this.pendings.clear();
+    this.log.tag("\u{1F527}", "Network interception stopped");
+  }
+  updateConfig(next) {
+    this.filter.updateConfig(next.filters);
+  }
+  static async getRequestData(request) {
+    const url = new URL(request.url);
+    const headers = {};
+    for (const [k, v] of request.headers.entries()) {
+      headers[k.toLowerCase()] = v;
+    }
+    let body = null;
+    if (request.body && ["PATCH", "POST", "PUT"].includes(request.method.toUpperCase())) {
+      try {
+        const cloned = request.clone();
+        const ab = await cloned.arrayBuffer();
+        body = ab.byteLength > 0 ? Buffer.from(ab) : null;
+      } catch {
+      }
+    }
+    return {
+      method: request.method,
+      hostname: url.hostname,
+      port: url.port ? Number.parseInt(url.port) : void 0,
+      path: url.pathname + url.search,
+      protocol: url.protocol.replace(/:$/, ""),
+      headers,
+      body
+    };
+  }
+  static async getResponseData(response) {
+    const headers = {};
+    for (const [k, v] of response.headers.entries()) {
+      headers[k.toLowerCase()] = v;
+    }
+    let body = null;
+    try {
+      const cloned = response.clone();
+      const ab = await cloned.arrayBuffer();
+      if (ab.byteLength > 0) {
+        body = Buffer.from(ab);
+        const enc = headers["content-encoding"];
+        if (enc && enc.includes("gzip") && body) {
+          try {
+            const head = body.toString("utf8", 0, Math.min(body.length, 100));
+            const looksText = /^[\s\u0020-\u007E]*$/.test(head) && /^\s*[<[{]/.test(head.trim());
+            if (!looksText) body = zlib.gunzipSync(body);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return {
+      statusCode: response.status,
+      statusMessage: response.statusText,
+      headers,
+      body
+    };
+  }
+  captureRequest(captureId, req) {
+    const rec = {
+      id: this.newRequestId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "request",
+      method: req.method,
+      hostname: req.hostname,
+      port: req.port,
+      path: req.path,
+      url: _NetworkInterceptor.buildUrl(req),
+      headers: req.headers,
+      body: req.body ?? null,
+      captureId
+    };
+    this.storage.write(rec);
+  }
+  captureResponse(captureId, res, start) {
+    const rec = {
+      id: this.newRequestId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "response",
+      statusCode: res.statusCode,
+      statusMessage: res.statusMessage,
+      headers: res.headers,
+      body: res.body ?? null,
+      duration: Date.now() - start,
+      captureId
+    };
+    this.storage.write(rec);
+  }
+  captureError(captureId, error, start) {
+    const rec = {
+      id: this.newRequestId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "error",
+      error: error?.message ?? String(error),
+      duration: Date.now() - start,
+      captureId
+    };
+    this.storage.write(rec);
+  }
+  static buildUrl(req) {
+    const proto = req.protocol;
+    const port = req.port && (proto === "http" && req.port !== 80 || proto === "https" && req.port !== 443) ? `:${req.port}` : "";
+    return `${proto}://${req.hostname}${port}${req.path}`;
+  }
+  static newCaptureId() {
+    return `cap-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+  newRequestId() {
+    return `req-${++this.counter}-${Date.now()}`;
+  }
+  updateStorage(storage) {
+    this.storage = storage;
+  }
+};
+
+// src/core/storage/data-serializer.ts
+var DataSerializer = {
+  serialize(data, compact) {
+    const { body, ...rest } = data;
+    let outBody = null;
+    if (typeof body === "string") {
+      outBody = body;
+    } else if (body && Buffer.isBuffer(body)) {
+      if (DataSerializer.isTextContent(body, data.headers)) {
+        outBody = body.toString("utf8");
+      } else {
+        outBody = {
+          type: "buffer",
+          data: body.toString("base64"),
+          encoding: "base64"
+        };
+      }
+    }
+    const out = { ...rest, body: outBody };
+    return JSON.stringify(out, null, compact ? 0 : 2);
+  },
+  isTextContent(buffer, headers) {
+    if (buffer.length === 0) return true;
+    const getHeader = (name) => {
+      if (!headers) return void 0;
+      const v = headers[name] ?? headers[name.toLowerCase()] ?? headers[name.toUpperCase()];
+      return Array.isArray(v) ? v[0] : v;
+    };
+    const ct = getHeader("content-type");
+    if (ct) {
+      if (/^(text\/|application\/(json|xml|javascript|x-www-form-urlencoded))/.test(ct)) return true;
+      if (/^(image\/|video\/|audio\/|application\/(pdf|zip|octet-stream))/.test(ct)) return false;
+    }
+    const sampleSize = Math.min(buffer.length, 1024);
+    const sample = buffer.subarray(0, sampleSize);
+    let textish = 0;
+    for (const byte of sample) {
+      if (byte >= 32 && byte <= 126 || byte === 9 || byte === 10 || byte === 13 || byte >= 128) textish++;
+    }
+    return textish / sample.length > 0.9;
+  }
+};
+var FileManager = class _FileManager {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  getExt() {
+    return this.cfg.format === "jsonl" ? ".jsonl" : ".json";
+  }
+  genPath(counter) {
+    const ext = this.getExt();
+    const base = path.basename(this.cfg.outputFile, path.extname(this.cfg.outputFile));
+    const dir = path.dirname(this.cfg.outputFile);
+    const file = counter === 0 ? `${base}${ext}` : `${base}-${counter}${ext}`;
+    return path.join(dir, file);
+  }
+  static ensureDir(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  }
+  shouldRotate(currentSize) {
+    return currentSize > this.cfg.maxFileSize;
+  }
+  static createWriteStream(filePath) {
+    _FileManager.ensureDir(filePath);
+    return fs.createWriteStream(filePath, { flags: "w", encoding: "utf8" });
+  }
+};
+
+// src/core/storage/formats.ts
+var JsonFormatter = {
+  writeHeader(stream) {
+    stream.write("[\n");
+  },
+  formatEntry(json, isFirst) {
+    return isFirst ? `  ${json}` : `,
+  ${json}`;
+  },
+  getHeaderSize() {
+    return 2;
+  },
+  close(stream, isFirst) {
+    if (isFirst) stream.write("]");
+    else stream.write("\n]");
+  }
+};
+var StreamFormatter = {
+  writeHeader() {
+  },
+  formatEntry(json) {
+    return `${json}
+`;
+  },
+  getHeaderSize() {
+    return 0;
+  },
+  close() {
+  }
+};
+var createFormatHandler = (fmt) => fmt === "json" ? JsonFormatter : StreamFormatter;
+
+// src/core/storage/storage.ts
+var StorageManager = class {
+  constructor(config) {
+    this.stream = null;
+    this.size = 0;
+    this.counter = 0;
+    this.isFirst = true;
+    this.closed = false;
+    this.cfg = config;
+    this.fm = new FileManager(config);
+    this.fmt = createFormatHandler(config.format);
+    this.log = createDebugLogger(config);
+    this.initFile();
+  }
+  write(data) {
+    if (this.closed || !this.stream) return;
+    try {
+      if (this.fm.shouldRotate(this.size)) this.rotate();
+      const compact = this.cfg.format === "jsonl";
+      const json = DataSerializer.serialize(data, compact);
+      const chunk = this.fmt.formatEntry(json, this.isFirst);
+      this.stream.write(chunk);
+      this.size += Buffer.byteLength(chunk);
+      if (this.isFirst) this.isFirst = false;
+      this.log.tag("\u{1F4BE}", `Wrote ${Buffer.byteLength(chunk)} bytes (${data.type})`);
+    } catch (error) {
+      this.log.error("Storage write error:", error);
+    }
+  }
+  close() {
+    if (this.closed || !this.stream) return;
+    try {
+      this.fmt.close(this.stream, this.isFirst);
+      this.stream.end();
+      this.stream = null;
+      this.closed = true;
+      this.log.tag("\u{1F4BE}", "Storage closed");
+    } catch {
+    }
+  }
+  initFile() {
+    try {
+      const filePath = this.fm.genPath(this.counter);
+      this.stream = FileManager.createWriteStream(filePath);
+      this.size = this.fmt.getHeaderSize();
+      this.isFirst = true;
+      this.fmt.writeHeader(this.stream);
+      if (!this.stream.writableNeedDrain) {
+        this.stream.cork();
+        this.stream.uncork();
+      }
+      this.log.tag("\u{1F4C1}", `Writing to ${filePath}`);
+    } catch (error) {
+      this.log.error("Storage init error:", error);
+    }
+  }
+  rotate() {
+    if (this.stream) {
+      this.fmt.close(this.stream, this.isFirst);
+      this.stream.end();
+    }
+    this.counter++;
+    this.initFile();
+  }
+};
+
+// src/index.ts
+var createInterceptor = (userConfig = {}) => {
+  let config = createDefaultConfig(userConfig);
+  let storage = new StorageManager(config);
+  const interceptor = new NetworkInterceptor(config, storage);
+  const api = {
+    start() {
+      interceptor.start();
+    },
+    stop() {
+      try {
+        interceptor.stop();
+      } finally {
+        storage.close();
+      }
+    },
+    updateConfig(next) {
+      const updated = createDefaultConfig({ ...config, ...next });
+      const old = config;
+      config = updated;
+      interceptor.updateConfig(updated);
+      const changed = updated.outputFile !== old.outputFile || updated.format !== old.format || updated.maxFileSize !== old.maxFileSize || updated.performance.compression !== old.performance.compression;
+      if (changed) {
+        storage.close();
+        storage = new StorageManager(updated);
+        interceptor.updateStorage(storage);
+      }
+    },
+    getConfig() {
+      return config;
+    }
+  };
+  return api;
+};
+
+export { NetworkInterceptor, StorageManager, createInterceptor };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map