peep-proxy 0.1.0

package/dist/proxy/proxy-server.js

@@ -0,0 +1,262 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ProxyServer_instances, _ProxyServer_config, _ProxyServer_server, _ProxyServer_emitter, _ProxyServer_certCache, _ProxyServer_sockets, _ProxyServer_tunnelSockets, _ProxyServer_mitmServers, _ProxyServer_handleRequest, _ProxyServer_handleConnect, _ProxyServer_handleTunnel, _ProxyServer_handleMitm;
+import { randomUUID } from "node:crypto";
+import * as http from "node:http";
+import * as https from "node:https";
+import * as net from "node:net";
+import * as tls from "node:tls";
+import { EventEmitter } from "node:events";
+import { generateHostCert } from "./ca.js";
+export class ProxyServer {
+    constructor(config) {
+        _ProxyServer_instances.add(this);
+        _ProxyServer_config.set(this, void 0);
+        _ProxyServer_server.set(this, void 0);
+        _ProxyServer_emitter.set(this, void 0);
+        _ProxyServer_certCache.set(this, new Map());
+        _ProxyServer_sockets.set(this, new Set());
+        _ProxyServer_tunnelSockets.set(this, new Set());
+        _ProxyServer_mitmServers.set(this, new Set());
+        _ProxyServer_handleRequest.set(this, (clientReq, clientRes) => {
+            const id = randomUUID();
+            const timestamp = Date.now();
+            let parsed;
+            try {
+                parsed = new URL(clientReq.url ?? "");
+            }
+            catch {
+                clientRes.writeHead(400, { "Content-Type": "text/plain" });
+                clientRes.end("Bad Request: invalid URL");
+                return;
+            }
+            const reqChunks = [];
+            clientReq.on("data", (chunk) => {
+                reqChunks.push(chunk);
+            });
+            clientReq.on("end", () => {
+                const reqBody = Buffer.concat(reqChunks);
+                const requestEvent = {
+                    id,
+                    method: clientReq.method ?? "GET",
+                    url: clientReq.url ?? "",
+                    host: parsed.hostname,
+                    path: parsed.pathname + parsed.search,
+                    headers: clientReq.headers,
+                    body: reqBody,
+                    timestamp,
+                };
+                __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("request", requestEvent);
+                const upstreamOptions = {
+                    hostname: parsed.hostname,
+                    port: parsed.port || 80,
+                    path: parsed.pathname + parsed.search,
+                    method: clientReq.method,
+                    headers: clientReq.headers,
+                };
+                const upstreamReq = http.request(upstreamOptions, (upstreamRes) => {
+                    const chunks = [];
+                    upstreamRes.on("data", (chunk) => {
+                        chunks.push(chunk);
+                    });
+                    upstreamRes.on("end", () => {
+                        const body = Buffer.concat(chunks);
+                        __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("response", {
+                            id,
+                            statusCode: upstreamRes.statusCode ?? 0,
+                            headers: upstreamRes.headers,
+                            body,
+                            duration: Date.now() - timestamp,
+                        });
+                    });
+                    clientRes.writeHead(upstreamRes.statusCode ?? 502, upstreamRes.headers);
+                    upstreamRes.pipe(clientRes);
+                });
+                upstreamReq.on("error", (error) => {
+                    __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("error", { id, error, phase: "request" });
+                    if (!clientRes.headersSent) {
+                        clientRes.writeHead(502, { "Content-Type": "text/plain" });
+                    }
+                    clientRes.end("Bad Gateway");
+                });
+                upstreamReq.end(reqBody);
+            });
+        });
+        _ProxyServer_handleConnect.set(this, (req, clientSocket, head) => {
+            const [host, portStr] = (req.url ?? "").split(":");
+            const port = Number.parseInt(portStr ?? "443", 10);
+            const hostname = host ?? "";
+            if (__classPrivateFieldGet(this, _ProxyServer_config, "f").ca) {
+                __classPrivateFieldGet(this, _ProxyServer_instances, "m", _ProxyServer_handleMitm).call(this, hostname, port, clientSocket, head);
+            }
+            else {
+                __classPrivateFieldGet(this, _ProxyServer_instances, "m", _ProxyServer_handleTunnel).call(this, hostname, port, clientSocket, head);
+            }
+        });
+        __classPrivateFieldSet(this, _ProxyServer_config, config, "f");
+        __classPrivateFieldSet(this, _ProxyServer_emitter, new EventEmitter(), "f");
+        __classPrivateFieldSet(this, _ProxyServer_server, http.createServer(__classPrivateFieldGet(this, _ProxyServer_handleRequest, "f")), "f");
+        __classPrivateFieldGet(this, _ProxyServer_server, "f").on("connect", __classPrivateFieldGet(this, _ProxyServer_handleConnect, "f"));
+        __classPrivateFieldGet(this, _ProxyServer_server, "f").on("connection", (socket) => {
+            __classPrivateFieldGet(this, _ProxyServer_sockets, "f").add(socket);
+            socket.once("close", () => __classPrivateFieldGet(this, _ProxyServer_sockets, "f").delete(socket));
+        });
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ProxyServer_server, "f").once("error", reject);
+            __classPrivateFieldGet(this, _ProxyServer_server, "f").listen(__classPrivateFieldGet(this, _ProxyServer_config, "f").port, __classPrivateFieldGet(this, _ProxyServer_config, "f").hostname, () => {
+                __classPrivateFieldGet(this, _ProxyServer_server, "f").removeListener("error", reject);
+                resolve();
+            });
+        });
+    }
+    stop() {
+        for (const socket of __classPrivateFieldGet(this, _ProxyServer_tunnelSockets, "f")) {
+            socket.destroy();
+        }
+        __classPrivateFieldGet(this, _ProxyServer_tunnelSockets, "f").clear();
+        for (const server of __classPrivateFieldGet(this, _ProxyServer_mitmServers, "f")) {
+            server.closeAllConnections();
+            server.close();
+        }
+        __classPrivateFieldGet(this, _ProxyServer_mitmServers, "f").clear();
+        for (const socket of __classPrivateFieldGet(this, _ProxyServer_sockets, "f")) {
+            socket.destroy();
+        }
+        __classPrivateFieldGet(this, _ProxyServer_sockets, "f").clear();
+        return new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ProxyServer_server, "f").close((error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    on(event, listener) {
+        __classPrivateFieldGet(this, _ProxyServer_emitter, "f").on(event, listener);
+    }
+    off(event, listener) {
+        __classPrivateFieldGet(this, _ProxyServer_emitter, "f").off(event, listener);
+    }
+}
+_ProxyServer_config = new WeakMap(), _ProxyServer_server = new WeakMap(), _ProxyServer_emitter = new WeakMap(), _ProxyServer_certCache = new WeakMap(), _ProxyServer_sockets = new WeakMap(), _ProxyServer_tunnelSockets = new WeakMap(), _ProxyServer_mitmServers = new WeakMap(), _ProxyServer_handleRequest = new WeakMap(), _ProxyServer_handleConnect = new WeakMap(), _ProxyServer_instances = new WeakSet(), _ProxyServer_handleTunnel = function _ProxyServer_handleTunnel(host, port, clientSocket, head) {
+    const id = randomUUID();
+    __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("connect", {
+        id,
+        host,
+        port,
+        timestamp: Date.now(),
+    });
+    const upstreamSocket = net.connect(port, host, () => {
+        clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+        if (head.length > 0) {
+            upstreamSocket.write(head);
+        }
+        upstreamSocket.pipe(clientSocket);
+        clientSocket.pipe(upstreamSocket);
+    });
+    __classPrivateFieldGet(this, _ProxyServer_tunnelSockets, "f").add(upstreamSocket);
+    upstreamSocket.once("close", () => __classPrivateFieldGet(this, _ProxyServer_tunnelSockets, "f").delete(upstreamSocket));
+    upstreamSocket.on("error", (error) => {
+        __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("error", { id, error, phase: "connect" });
+        clientSocket.end();
+    });
+    clientSocket.on("error", () => {
+        upstreamSocket.end();
+    });
+}, _ProxyServer_handleMitm = function _ProxyServer_handleMitm(host, port, clientSocket, _head) {
+    const ca = __classPrivateFieldGet(this, _ProxyServer_config, "f").ca;
+    let hostCert = __classPrivateFieldGet(this, _ProxyServer_certCache, "f").get(host);
+    if (!hostCert) {
+        hostCert = generateHostCert(host, ca);
+        __classPrivateFieldGet(this, _ProxyServer_certCache, "f").set(host, hostCert);
+    }
+    const secureContext = tls.createSecureContext({
+        cert: hostCert.certPem,
+        key: hostCert.keyPem,
+    });
+    clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+    const tlsSocket = new tls.TLSSocket(clientSocket, {
+        isServer: true,
+        secureContext,
+    });
+    const mitmServer = http.createServer((clientReq, clientRes) => {
+        const id = randomUUID();
+        const timestamp = Date.now();
+        const url = `https://${host}${clientReq.url ?? "/"}`;
+        const pathAndSearch = clientReq.url ?? "/";
+        const reqChunks = [];
+        clientReq.on("data", (chunk) => {
+            reqChunks.push(chunk);
+        });
+        clientReq.on("end", () => {
+            const reqBody = Buffer.concat(reqChunks);
+            const requestEvent = {
+                id,
+                method: clientReq.method ?? "GET",
+                url,
+                host,
+                path: pathAndSearch,
+                headers: clientReq.headers,
+                body: reqBody,
+                timestamp,
+            };
+            __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("request", requestEvent);
+            const upstreamOptions = {
+                hostname: host,
+                port,
+                path: pathAndSearch,
+                method: clientReq.method,
+                headers: { ...clientReq.headers, host },
+            };
+            const upstreamReq = https.request(upstreamOptions, (upstreamRes) => {
+                const chunks = [];
+                upstreamRes.on("data", (chunk) => {
+                    chunks.push(chunk);
+                });
+                upstreamRes.on("end", () => {
+                    const body = Buffer.concat(chunks);
+                    __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("response", {
+                        id,
+                        statusCode: upstreamRes.statusCode ?? 0,
+                        headers: upstreamRes.headers,
+                        body,
+                        duration: Date.now() - timestamp,
+                    });
+                });
+                clientRes.writeHead(upstreamRes.statusCode ?? 502, upstreamRes.headers);
+                upstreamRes.pipe(clientRes);
+            });
+            upstreamReq.on("error", (error) => {
+                __classPrivateFieldGet(this, _ProxyServer_emitter, "f").emit("error", { id, error, phase: "request" });
+                if (!clientRes.headersSent) {
+                    clientRes.writeHead(502, { "Content-Type": "text/plain" });
+                }
+                clientRes.end("Bad Gateway");
+            });
+            upstreamReq.end(reqBody);
+        });
+    });
+    __classPrivateFieldGet(this, _ProxyServer_mitmServers, "f").add(mitmServer);
+    mitmServer.emit("connection", tlsSocket);
+    const cleanup = () => {
+        __classPrivateFieldGet(this, _ProxyServer_mitmServers, "f").delete(mitmServer);
+        mitmServer.close();
+    };
+    tlsSocket.on("close", cleanup);
+    tlsSocket.on("error", cleanup);
+    clientSocket.on("error", cleanup);
+};

package/dist/proxy/system-proxy.d.ts

@@ -0,0 +1,2 @@
+export declare function enableSystemProxy(port: number): string | null;
+export declare function disableSystemProxy(service: string): void;

package/dist/proxy/system-proxy.js

@@ -0,0 +1,64 @@
+import { execFileSync } from "node:child_process";
+import { platform } from "node:os";
+function getActiveService() {
+    if (platform() !== "darwin")
+        return null;
+    try {
+        const route = execFileSync("route", ["-n", "get", "default"], {
+            stdio: "pipe",
+        }).toString();
+        const ifaceMatch = route.match(/interface:\s*(\S+)/);
+        if (!ifaceMatch)
+            return null;
+        const iface = ifaceMatch[1];
+        const ports = execFileSync("networksetup", ["-listallhardwareports"], {
+            stdio: "pipe",
+        }).toString();
+        const lines = ports.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i]?.includes(`Device: ${iface}`)) {
+                const serviceMatch = lines[i - 1]?.match(/Hardware Port:\s*(.+)/);
+                if (serviceMatch?.[1])
+                    return serviceMatch[1];
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+export function enableSystemProxy(port) {
+    const service = getActiveService();
+    if (!service)
+        return null;
+    try {
+        const addr = "127.0.0.1";
+        const p = String(port);
+        execFileSync("networksetup", ["-setwebproxy", service, addr, p], {
+            stdio: "pipe",
+        });
+        execFileSync("networksetup", ["-setsecurewebproxy", service, addr, p], {
+            stdio: "pipe",
+        });
+        execFileSync("networksetup", ["-setwebproxystate", service, "on"], {
+            stdio: "pipe",
+        });
+        execFileSync("networksetup", ["-setsecurewebproxystate", service, "on"], {
+            stdio: "pipe",
+        });
+        return service;
+    }
+    catch {
+        return null;
+    }
+}
+export function disableSystemProxy(service) {
+    try {
+        execFileSync("networksetup", ["-setwebproxystate", service, "off"], {
+            stdio: "pipe",
+        });
+        execFileSync("networksetup", ["-setsecurewebproxystate", service, "off"], {
+            stdio: "pipe",
+        });
+    }
+    catch { }
+}

package/dist/proxy/types.d.ts

@@ -0,0 +1,45 @@
+import type { IncomingHttpHeaders } from "node:http";
+export type CaConfig = {
+    certPem: string;
+    keyPem: string;
+};
+export type ProxyConfig = {
+    port: number;
+    hostname?: string;
+    ca?: CaConfig;
+};
+export type RequestId = string;
+export type ProxyRequestEvent = {
+    id: RequestId;
+    method: string;
+    url: string;
+    host: string;
+    path: string;
+    headers: IncomingHttpHeaders;
+    body: Buffer;
+    timestamp: number;
+};
+export type ProxyResponseEvent = {
+    id: RequestId;
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    body: Buffer;
+    duration: number;
+};
+export type ProxyConnectEvent = {
+    id: RequestId;
+    host: string;
+    port: number;
+    timestamp: number;
+};
+export type ProxyErrorEvent = {
+    id?: RequestId;
+    error: Error;
+    phase: "request" | "response" | "connect";
+};
+export type ProxyEventMap = {
+    request: [event: ProxyRequestEvent];
+    response: [event: ProxyResponseEvent];
+    connect: [event: ProxyConnectEvent];
+    error: [event: ProxyErrorEvent];
+};

package/dist/proxy/types.js

@@ -0,0 +1 @@
+export {};

package/dist/store/index.d.ts

@@ -0,0 +1,2 @@
+export { TrafficStore } from "./traffic-store.js";
+export type { TrafficEntry, TrafficStoreEventMap } from "./types.js";

package/dist/store/index.js

@@ -0,0 +1 @@
+export { TrafficStore } from "./traffic-store.js";

package/dist/store/traffic-store.d.ts

@@ -0,0 +1,14 @@
+import type { ProxyServer } from "../proxy/proxy-server.js";
+import type { RequestId } from "../proxy/types.js";
+import type { TrafficEntry, TrafficStoreEventMap } from "./types.js";
+export declare class TrafficStore {
+    #private;
+    constructor(proxy: ProxyServer);
+    get entries(): TrafficEntry[];
+    get size(): number;
+    get(id: RequestId): TrafficEntry | undefined;
+    clear(): void;
+    destroy(): void;
+    on<K extends keyof TrafficStoreEventMap>(event: K, listener: (...args: TrafficStoreEventMap[K]) => void): void;
+    off<K extends keyof TrafficStoreEventMap>(event: K, listener: (...args: TrafficStoreEventMap[K]) => void): void;
+}

package/dist/store/traffic-store.js

@@ -0,0 +1,87 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TrafficStore_entries, _TrafficStore_order, _TrafficStore_emitter, _TrafficStore_proxy, _TrafficStore_nextSeq, _TrafficStore_onRequest, _TrafficStore_onResponse, _TrafficStore_onError;
+import { EventEmitter } from "node:events";
+export class TrafficStore {
+    constructor(proxy) {
+        _TrafficStore_entries.set(this, new Map());
+        _TrafficStore_order.set(this, []);
+        _TrafficStore_emitter.set(this, void 0);
+        _TrafficStore_proxy.set(this, void 0);
+        _TrafficStore_nextSeq.set(this, 1);
+        _TrafficStore_onRequest.set(this, (event) => {
+            var _a, _b;
+            const entry = {
+                id: event.id,
+                seq: (__classPrivateFieldSet(this, _TrafficStore_nextSeq, (_b = __classPrivateFieldGet(this, _TrafficStore_nextSeq, "f"), _a = _b++, _b), "f"), _a),
+                request: event,
+                state: "pending",
+            };
+            __classPrivateFieldGet(this, _TrafficStore_entries, "f").set(event.id, entry);
+            __classPrivateFieldGet(this, _TrafficStore_order, "f").push(event.id);
+            __classPrivateFieldGet(this, _TrafficStore_emitter, "f").emit("add", entry);
+        });
+        _TrafficStore_onResponse.set(this, (event) => {
+            const entry = __classPrivateFieldGet(this, _TrafficStore_entries, "f").get(event.id);
+            if (!entry)
+                return;
+            entry.response = event;
+            entry.state = "complete";
+            __classPrivateFieldGet(this, _TrafficStore_emitter, "f").emit("update", entry);
+        });
+        _TrafficStore_onError.set(this, (event) => {
+            if (!event.id)
+                return;
+            const entry = __classPrivateFieldGet(this, _TrafficStore_entries, "f").get(event.id);
+            if (!entry)
+                return;
+            entry.state = "error";
+            entry.error = event.error;
+            __classPrivateFieldGet(this, _TrafficStore_emitter, "f").emit("update", entry);
+        });
+        __classPrivateFieldSet(this, _TrafficStore_proxy, proxy, "f");
+        __classPrivateFieldSet(this, _TrafficStore_emitter, new EventEmitter(), "f");
+        __classPrivateFieldGet(this, _TrafficStore_proxy, "f").on("request", __classPrivateFieldGet(this, _TrafficStore_onRequest, "f"));
+        __classPrivateFieldGet(this, _TrafficStore_proxy, "f").on("response", __classPrivateFieldGet(this, _TrafficStore_onResponse, "f"));
+        __classPrivateFieldGet(this, _TrafficStore_proxy, "f").on("error", __classPrivateFieldGet(this, _TrafficStore_onError, "f"));
+    }
+    get entries() {
+        return __classPrivateFieldGet(this, _TrafficStore_order, "f").flatMap((id) => {
+            const entry = __classPrivateFieldGet(this, _TrafficStore_entries, "f").get(id);
+            return entry ? [entry] : [];
+        });
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _TrafficStore_entries, "f").size;
+    }
+    get(id) {
+        return __classPrivateFieldGet(this, _TrafficStore_entries, "f").get(id);
+    }
+    clear() {
+        __classPrivateFieldGet(this, _TrafficStore_entries, "f").clear();
+        __classPrivateFieldGet(this, _TrafficStore_order, "f").length = 0;
+        __classPrivateFieldSet(this, _TrafficStore_nextSeq, 1, "f");
+        __classPrivateFieldGet(this, _TrafficStore_emitter, "f").emit("clear");
+    }
+    destroy() {
+        __classPrivateFieldGet(this, _TrafficStore_proxy, "f").off("request", __classPrivateFieldGet(this, _TrafficStore_onRequest, "f"));
+        __classPrivateFieldGet(this, _TrafficStore_proxy, "f").off("response", __classPrivateFieldGet(this, _TrafficStore_onResponse, "f"));
+        __classPrivateFieldGet(this, _TrafficStore_proxy, "f").off("error", __classPrivateFieldGet(this, _TrafficStore_onError, "f"));
+    }
+    on(event, listener) {
+        __classPrivateFieldGet(this, _TrafficStore_emitter, "f").on(event, listener);
+    }
+    off(event, listener) {
+        __classPrivateFieldGet(this, _TrafficStore_emitter, "f").off(event, listener);
+    }
+}
+_TrafficStore_entries = new WeakMap(), _TrafficStore_order = new WeakMap(), _TrafficStore_emitter = new WeakMap(), _TrafficStore_proxy = new WeakMap(), _TrafficStore_nextSeq = new WeakMap(), _TrafficStore_onRequest = new WeakMap(), _TrafficStore_onResponse = new WeakMap(), _TrafficStore_onError = new WeakMap();

package/dist/store/types.d.ts

@@ -0,0 +1,14 @@
+import type { ProxyRequestEvent, ProxyResponseEvent, RequestId } from "../proxy/types.js";
+export type TrafficEntry = {
+    id: RequestId;
+    seq: number;
+    request: ProxyRequestEvent;
+    response?: ProxyResponseEvent;
+    state: "pending" | "complete" | "error";
+    error?: Error;
+};
+export type TrafficStoreEventMap = {
+    add: [entry: TrafficEntry];
+    update: [entry: TrafficEntry];
+    clear: [];
+};

package/dist/store/types.js

@@ -0,0 +1 @@
+export {};

package/dist/theme.d.ts

@@ -0,0 +1 @@
+export declare const PRIMARY_COLOR = "green";

package/dist/theme.js

@@ -0,0 +1 @@
+export const PRIMARY_COLOR = "green";

package/dist/utils/contentType.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingHttpHeaders } from "node:http";
+type HighlightLanguage = "json" | "html" | "xml" | "plain";
+export declare function parseContentType(headers: IncomingHttpHeaders): string;
+export declare function isBinaryContentType(mimeType: string): boolean;
+export declare function hasBinaryBytes(buffer: Buffer): boolean;
+export declare function getHighlightLanguage(mimeType: string): HighlightLanguage;
+export {};

package/dist/utils/contentType.js

@@ -0,0 +1,46 @@
+const BINARY_PREFIXES = [
+    "image/",
+    "audio/",
+    "video/",
+    "font/",
+    "application/octet-stream",
+    "application/zip",
+    "application/gzip",
+    "application/x-tar",
+    "application/pdf",
+    "application/wasm",
+    "application/protobuf",
+    "application/x-protobuf",
+    "application/grpc",
+];
+const MIME_TO_LANGUAGE = {
+    "application/json": "json",
+    "text/html": "html",
+    "application/xhtml+xml": "html",
+    "text/xml": "xml",
+    "application/xml": "xml",
+    "application/rss+xml": "xml",
+    "application/atom+xml": "xml",
+    "image/svg+xml": "xml",
+};
+export function parseContentType(headers) {
+    const raw = headers["content-type"];
+    if (!raw)
+        return "";
+    const value = Array.isArray(raw) ? (raw[0] ?? "") : raw;
+    return value.split(";")[0]?.trim().toLowerCase() ?? "";
+}
+export function isBinaryContentType(mimeType) {
+    return BINARY_PREFIXES.some((prefix) => mimeType === prefix || mimeType.startsWith(prefix));
+}
+export function hasBinaryBytes(buffer) {
+    const limit = Math.min(buffer.length, 8192);
+    for (let i = 0; i < limit; i++) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+export function getHighlightLanguage(mimeType) {
+    return MIME_TO_LANGUAGE[mimeType] ?? "plain";
+}

package/dist/utils/copyToClipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyToClipboard(text: string): void;

package/dist/utils/copyToClipboard.js

@@ -0,0 +1,21 @@
+import { execFile } from "node:child_process";
+import { platform } from "node:os";
+export function copyToClipboard(text) {
+    const os = platform();
+    let command;
+    let args;
+    if (os === "darwin") {
+        command = "pbcopy";
+        args = [];
+    }
+    else if (os === "win32") {
+        command = "clip";
+        args = [];
+    }
+    else {
+        command = "xclip";
+        args = ["-selection", "clipboard"];
+    }
+    const child = execFile(command, args);
+    child.stdin?.end(text);
+}

package/dist/utils/decompress.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingHttpHeaders } from "node:http";
+export declare function decompressBody(body: Buffer, headers: IncomingHttpHeaders): Buffer;

package/dist/utils/decompress.js

@@ -0,0 +1,25 @@
+import { brotliDecompressSync, gunzipSync, inflateSync } from "node:zlib";
+export function decompressBody(body, headers) {
+    const encoding = headers["content-encoding"];
+    if (!encoding)
+        return body;
+    const enc = (Array.isArray(encoding) ? encoding[0] : encoding)
+        ?.trim()
+        .toLowerCase();
+    try {
+        switch (enc) {
+            case "gzip":
+            case "x-gzip":
+                return gunzipSync(body);
+            case "deflate":
+                return inflateSync(body);
+            case "br":
+                return brotliDecompressSync(body);
+            default:
+                return body;
+        }
+    }
+    catch {
+        return body;
+    }
+}

package/dist/utils/formatBytes.d.ts

@@ -0,0 +1 @@
+export declare function formatBytes(bytes: number): string;

package/dist/utils/formatBytes.js

@@ -0,0 +1,14 @@
+const UNITS = ["B", "KB", "MB", "GB"];
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    let unit = 0;
+    let value = bytes;
+    while (value >= 1024 && unit < UNITS.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    if (unit === 0)
+        return `${bytes} B`;
+    return `${value.toFixed(1)} ${UNITS[unit]}`;
+}

package/dist/utils/getTabText.d.ts

@@ -0,0 +1,3 @@
+import type { DetailTab } from "../hooks/useDetailTabs.js";
+import type { TrafficEntry } from "../store/index.js";
+export declare function getTabText(entry: TrafficEntry, side: "request" | "response", tab: DetailTab): string;