midline-agent 0.2.0 → 0.4.0

package/dist/browser/vitals.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observeVitals = observeVitals;
+/** web.dev thresholds: at or under the first is good, over the second is poor. */
+const THRESHOLDS = {
+    LCP: [2500, 4000],
+    INP: [200, 500],
+    CLS: [0.1, 0.25],
+    FCP: [1800, 3000],
+    TTFB: [800, 1800],
+};
+const rate = (name, value) => value <= THRESHOLDS[name][0] ? "good" : value <= THRESHOLDS[name][1] ? "needs-improvement" : "poor";
+/**
+ * Core Web Vitals without a dependency, measured the way the web-vitals library
+ * does and reported once, when the page is first hidden (the last moment a
+ * report reliably gets out). Browsers that don't expose an entry type simply
+ * omit that metric: Safari has no LCP, INP or CLS.
+ */
+function observeVitals(win, onReport) {
+    const Observer = win.PerformanceObserver;
+    const supported = Observer?.supportedEntryTypes ?? [];
+    const perf = win.performance;
+    const doc = win.document;
+    const values = {};
+    const observers = [];
+    let activationStart = 0;
+    let navigationType;
+    try {
+        const navigation = perf?.getEntriesByType?.("navigation")?.[0];
+        if (navigation) {
+            activationStart = navigation.activationStart ?? 0;
+            navigationType = navigation.type;
+            if (typeof navigation.responseStart === "number" && navigation.responseStart > 0) {
+                values.TTFB = Math.max(0, navigation.responseStart - activationStart);
+            }
+        }
+    }
+    catch {
+        // no navigation timing
+    }
+    const observe = (type, handle, extra = {}) => {
+        if (!Observer || !supported.includes(type))
+            return;
+        try {
+            const observer = new Observer((list) => handle(list.getEntries()));
+            observer.observe({ type, buffered: true, ...extra });
+            observers.push({ observer, handle });
+        }
+        catch {
+            // unsupported option in this browser
+        }
+    };
+    observe("paint", (entries) => {
+        for (const entry of entries) {
+            if (entry.name === "first-contentful-paint")
+                values.FCP = Math.max(0, entry.startTime - activationStart);
+        }
+    });
+    observe("largest-contentful-paint", (entries) => {
+        const last = entries[entries.length - 1];
+        if (last)
+            values.LCP = Math.max(0, last.startTime - activationStart);
+    });
+    // CLS is the largest session window: shifts less than 1s apart, at most 5s long.
+    let windowValue = 0;
+    let windowStart = 0;
+    let windowLast = 0;
+    observe("layout-shift", (entries) => {
+        for (const entry of entries) {
+            if (entry.hadRecentInput || typeof entry.value !== "number")
+                continue;
+            if (windowValue && entry.startTime - windowLast < 1000 && entry.startTime - windowStart < 5000) {
+                windowValue += entry.value;
+            }
+            else {
+                windowValue = entry.value;
+                windowStart = entry.startTime;
+            }
+            windowLast = entry.startTime;
+            values.CLS = Math.max(values.CLS ?? 0, windowValue);
+        }
+    });
+    // INP: the slowest interaction, or near the 98th percentile on busy pages.
+    const interactions = new Map();
+    const recordInteractions = (entries) => {
+        for (const entry of entries) {
+            if (!entry.interactionId)
+                continue;
+            interactions.set(entry.interactionId, Math.max(interactions.get(entry.interactionId) ?? 0, entry.duration));
+        }
+    };
+    observe("event", recordInteractions, { durationThreshold: 40 });
+    observe("first-input", recordInteractions);
+    let reported = false;
+    const report = () => {
+        if (reported)
+            return;
+        reported = true;
+        for (const { observer, handle } of observers) {
+            try {
+                handle(observer.takeRecords());
+                observer.disconnect();
+            }
+            catch {
+                // already disconnected
+            }
+        }
+        if (interactions.size) {
+            const durations = [...interactions.values()].sort((a, b) => b - a);
+            values.INP = durations[Math.min(durations.length - 1, Math.floor(durations.length / 50))];
+        }
+        const vitals = {};
+        for (const name of Object.keys(values)) {
+            const raw = values[name];
+            if (typeof raw !== "number" || !Number.isFinite(raw))
+                continue;
+            const value = name === "CLS" ? Math.round(raw * 10000) / 10000 : Math.round(raw);
+            vitals[name] = { value, rating: rate(name, value) };
+        }
+        if (Object.keys(vitals).length)
+            onReport({ vitals, navigationType });
+    };
+    const onVisibility = () => {
+        if (doc?.visibilityState === "hidden")
+            report();
+    };
+    doc?.addEventListener("visibilitychange", onVisibility, true);
+    win.addEventListener("pagehide", report, true);
+    return () => {
+        doc?.removeEventListener("visibilitychange", onVisibility, true);
+        win.removeEventListener("pagehide", report, true);
+        for (const { observer } of observers)
+            observer.disconnect();
+    };
+}

package/dist/config.d.ts

@@ -27,6 +27,7 @@ export interface ResolvedConfig {
     redactFields: string[];
     redactHeaders: string[];
     capture: ResolvedCapture;
+    captureConsole: boolean;
     onError?: (message: string) => void;
     debug: boolean;
     flushIntervalMs: number;

package/dist/config.js

@@ -216,6 +216,7 @@ function resolveConfig(config) {
         redactFields: [...(config.redactFields ?? []), ...(config.maskFields ?? [])],
         redactHeaders: config.redactHeaders ?? [],
         capture: resolveCapture(config.capture),
+        captureConsole: config.captureConsole ?? envFlag("MIDLINE_CAPTURE_CONSOLE") ?? false,
         onError: config.onError,
         debug: config.debug ?? envFlag("MIDLINE_DEBUG") ?? false,
         flushIntervalMs: positiveInt(config.flushIntervalMs, 1500, 50, 60000),

package/dist/console.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Console capture: what the host process prints — `console.log`, Nest's logger,
+ * pino, anything that reaches stdout or stderr — copied into Midline line by line.
+ *
+ * The streams are never changed. The original `write` runs first with the
+ * caller's own arguments and its return value is handed straight back, so
+ * back-pressure, callbacks and the terminal output are exactly what they were.
+ */
+export type ConsoleStream = "stdout" | "stderr";
+export type ConsoleLevel = "info" | "warn" | "error";
+export interface ConsoleLine {
+    stream: ConsoleStream;
+    text: string;
+    level: ConsoleLevel;
+    /** When the line's first chunk was written, not when it was sent. */
+    timestamp: string;
+}
+/** Longest line kept. A log line past this is almost always a dumped payload. */
+export declare const MAX_LINE_CHARS = 4096;
+/**
+ * Runs `fn` with capture paused. The agent writes its own diagnostics through
+ * this, so a warning about delivery can't become an event that needs delivering.
+ */
+export declare function withoutConsoleCapture<T>(fn: () => T): T;
+export declare class ConsoleCapture {
+    private readonly onLine;
+    private readonly originals;
+    private readonly wrappers;
+    private readonly pending;
+    private busy;
+    private stopped;
+    constructor(onLine: (line: ConsoleLine) => void);
+    install(): void;
+    /** Restores the streams. A wrapper installed on top of ours is left alone — ours just goes quiet underneath it. */
+    uninstall(): void;
+    /**
+     * Emits lines still waiting for a newline. Without `force`, only the ones that
+     * were already unfinished at the previous call, so a line being written in
+     * pieces isn't cut in half by a timer tick.
+     */
+    flushPending(force?: boolean): void;
+    private take;
+    private emit;
+}
+/** Nest, most JSON loggers and console.warn/error leave enough behind to tell a failure from chatter. */
+export declare function levelOf(stream: ConsoleStream, text: string): ConsoleLevel;

package/dist/console.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Console capture: what the host process prints — `console.log`, Nest's logger,
+ * pino, anything that reaches stdout or stderr — copied into Midline line by line.
+ *
+ * The streams are never changed. The original `write` runs first with the
+ * caller's own arguments and its return value is handed straight back, so
+ * back-pressure, callbacks and the terminal output are exactly what they were.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleCapture = exports.MAX_LINE_CHARS = void 0;
+exports.withoutConsoleCapture = withoutConsoleCapture;
+exports.levelOf = levelOf;
+/** Longest line kept. A log line past this is almost always a dumped payload. */
+exports.MAX_LINE_CHARS = 4096;
+const STREAMS = ["stdout", "stderr"];
+/** CSI (colours, cursor moves), OSC (titles, hyperlinks) and the remaining two-byte escapes. */
+const ANSI_ESCAPE = /\x1B\[[0-?]*[ -\/]*[@-~]|\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)|\x1B[@-Z\\-_]/g;
+// Level words are matched in capitals only: lower-case "error" turns up in plenty of harmless lines.
+const ERROR_MARKERS = [/\b(?:ERROR|FATAL|CRITICAL)\b/, /"level"\s*:\s*"?(?:error|fatal|critical|50|60)\b/i];
+const WARN_MARKERS = [/\bWARN(?:ING)?\b/, /"level"\s*:\s*"?(?:warn|warning|40)\b/i];
+let suppressed = 0;
+/**
+ * Runs `fn` with capture paused. The agent writes its own diagnostics through
+ * this, so a warning about delivery can't become an event that needs delivering.
+ */
+function withoutConsoleCapture(fn) {
+    suppressed += 1;
+    try {
+        return fn();
+    }
+    finally {
+        suppressed -= 1;
+    }
+}
+class ConsoleCapture {
+    constructor(onLine) {
+        this.onLine = onLine;
+        this.originals = new Map();
+        this.wrappers = new Map();
+        this.pending = {
+            stdout: { text: "", at: "", stale: false },
+            stderr: { text: "", at: "", stale: false },
+        };
+        this.busy = false;
+        this.stopped = false;
+    }
+    install() {
+        for (const stream of STREAMS) {
+            const target = process[stream];
+            const original = target.write;
+            const capture = this;
+            const wrapper = function (...args) {
+                const result = original.apply(this, args);
+                capture.take(stream, args[0], args[1]);
+                return result;
+            };
+            this.originals.set(stream, original);
+            this.wrappers.set(stream, wrapper);
+            target.write = wrapper;
+        }
+    }
+    /** Restores the streams. A wrapper installed on top of ours is left alone — ours just goes quiet underneath it. */
+    uninstall() {
+        this.stopped = true;
+        for (const stream of STREAMS) {
+            const wrapper = this.wrappers.get(stream);
+            if (wrapper && process[stream].write === wrapper) {
+                process[stream].write = this.originals.get(stream);
+            }
+        }
+        this.wrappers.clear();
+        this.originals.clear();
+    }
+    /**
+     * Emits lines still waiting for a newline. Without `force`, only the ones that
+     * were already unfinished at the previous call, so a line being written in
+     * pieces isn't cut in half by a timer tick.
+     */
+    flushPending(force = false) {
+        if (this.stopped || this.busy)
+            return;
+        this.busy = true;
+        try {
+            for (const stream of STREAMS) {
+                const pending = this.pending[stream];
+                if (!pending.text)
+                    continue;
+                if (force || pending.stale) {
+                    this.pending[stream] = { text: "", at: "", stale: false };
+                    this.emit(stream, pending.text, pending.at);
+                }
+                else {
+                    pending.stale = true;
+                }
+            }
+        }
+        catch {
+            // Best-effort, like the rest of capture.
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    take(stream, chunk, encoding) {
+        // `busy` also stops a loop if whatever handles a line prints something itself.
+        if (this.stopped || this.busy || suppressed > 0)
+            return;
+        this.busy = true;
+        try {
+            const text = decode(chunk, encoding);
+            if (!text)
+                return;
+            const now = new Date().toISOString();
+            const pending = this.pending[stream];
+            const lines = (pending.text + text).split("\n");
+            let rest = lines.pop() ?? "";
+            let at = pending.text ? pending.at : now;
+            for (const line of lines) {
+                this.emit(stream, line, at);
+                at = now;
+            }
+            if (rest.length > exports.MAX_LINE_CHARS) {
+                this.emit(stream, rest, at);
+                rest = "";
+            }
+            this.pending[stream] = { text: rest, at: rest ? at : "", stale: false };
+        }
+        catch {
+            // The write itself already happened; a line we couldn't read is just not sent.
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    emit(stream, raw, at) {
+        let text = raw.replace(ANSI_ESCAPE, "").replace(/\r$/, "");
+        // A carriage return redraws the line; what's left after the last one is what the terminal shows.
+        text = text.slice(text.lastIndexOf("\r") + 1);
+        if (!text.trim())
+            return;
+        if (text.length > exports.MAX_LINE_CHARS)
+            text = text.slice(0, exports.MAX_LINE_CHARS);
+        this.onLine({ stream, text, level: levelOf(stream, text), timestamp: at });
+    }
+}
+exports.ConsoleCapture = ConsoleCapture;
+/** Nest, most JSON loggers and console.warn/error leave enough behind to tell a failure from chatter. */
+function levelOf(stream, text) {
+    const head = text.slice(0, 256);
+    if (ERROR_MARKERS.some((pattern) => pattern.test(head)))
+        return "error";
+    if (WARN_MARKERS.some((pattern) => pattern.test(head)))
+        return "warn";
+    return stream === "stderr" ? "warn" : "info";
+}
+function decode(chunk, encoding) {
+    if (typeof chunk === "string") {
+        return typeof encoding === "string" && !/^utf-?8$/i.test(encoding) && Buffer.isEncoding(encoding)
+            ? Buffer.from(chunk, encoding).toString("utf8")
+            : chunk;
+    }
+    if (chunk instanceof Uint8Array) {
+        return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString("utf8");
+    }
+    return "";
+}