repoburg 1.3.254 → 1.3.256

package/daemon/dist/tabtape/query/types.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * TypeScript mirrors of the record payloads in tabtape/shared/events.ts, with
+ * decoders that keep only fields of the expected type. Fields that the
+ * server does not use are left out. Value fields default to their zero value
+ * (like Go structs); fields whose absence matters are optional.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsset = exports.isWebSocket = void 0;
+exports.isObj = isObj;
+exports.decodeTiming = decodeTiming;
+exports.decodeNetwork = decodeNetwork;
+exports.decodeWS = decodeWS;
+exports.decodeState = decodeState;
+exports.decodeConsole = decodeConsole;
+exports.decodeTarget = decodeTarget;
+exports.decodeEvent = decodeEvent;
+exports.decodePerf = decodePerf;
+exports.failed = failed;
+exports.sizeOf = sizeOf;
+exports.recorded = recorded;
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+const asObj = (v) => (isObj(v) ? v : {});
+const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+const int = (v) => Math.trunc(num(v));
+const bool = (v) => v === true;
+const optNum = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const optStr = (v) => (typeof v === 'string' ? v : undefined);
+function strMap(v) {
+    if (!isObj(v))
+        return undefined;
+    const out = {};
+    for (const [k, x] of Object.entries(v))
+        if (typeof x === 'string')
+            out[k] = x;
+    return out;
+}
+const optObj = (v) => (isObj(v) ? v : undefined);
+function strList(v) {
+    return Array.isArray(v) ? v.filter((x) => typeof x === 'string') : [];
+}
+function blockedCookies(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    return v.filter(isObj).map((c) => ({ name: str(c.name), reasons: strList(c.reasons), domain: str(c.domain), path: str(c.path) }));
+}
+function decodeTiming(v) {
+    if (!isObj(v))
+        return undefined;
+    return {
+        blocked: optNum(v.blocked),
+        dns: optNum(v.dns),
+        connect: optNum(v.connect),
+        ssl: optNum(v.ssl),
+        send: optNum(v.send),
+        wait: optNum(v.wait),
+        receive: optNum(v.receive),
+    };
+}
+function decodeNetwork(v) {
+    const d = asObj(v);
+    const cors = isObj(d.corsErrorStatus) ? { corsError: str(d.corsErrorStatus.corsError), failedParameter: str(d.corsErrorStatus.failedParameter) } : undefined;
+    const worker = isObj(d.worker) ? { type: str(d.worker.type), url: str(d.worker.url) } : undefined;
+    const frames = isObj(d.frames)
+        ? {
+            sent: int(d.frames.sent),
+            received: int(d.frames.received),
+            sentBytes: num(d.frames.sentBytes),
+            receivedBytes: num(d.frames.receivedBytes),
+            dropped: int(d.frames.dropped),
+            dataOmitted: int(d.frames.dataOmitted),
+        }
+        : undefined;
+    return {
+        id: str(d.id),
+        kind: str(d.kind),
+        method: str(d.method),
+        url: str(d.url),
+        status: int(d.status),
+        statusText: str(d.statusText),
+        duration: optNum(d.duration),
+        ttfb: optNum(d.ttfb),
+        reqHeaders: strMap(d.reqHeaders),
+        reqBody: optStr(d.reqBody),
+        reqBodyNote: str(d.reqBodyNote),
+        reqBodyTruncated: bool(d.reqBodyTruncated),
+        resHeaders: strMap(d.resHeaders),
+        resBody: optStr(d.resBody),
+        resBodyNote: str(d.resBodyNote),
+        resBodyTruncated: bool(d.resBodyTruncated),
+        resSize: optNum(d.resSize),
+        transferSize: optNum(d.transferSize),
+        mime: str(d.mime),
+        error: str(d.error),
+        pending: bool(d.pending),
+        initiator: str(d.initiator),
+        navType: str(d.navType),
+        source: str(d.source),
+        resourceType: str(d.resourceType),
+        timing: decodeTiming(d.timing),
+        protocol: str(d.protocol),
+        remoteAddress: str(d.remoteAddress),
+        cache: str(d.cache),
+        fromServiceWorker: bool(d.fromServiceWorker),
+        swSource: str(d.swSource),
+        blockedReason: str(d.blockedReason),
+        corsErrorStatus: cors,
+        blockedCookies: blockedCookies(d.blockedCookies),
+        blockedSetCookies: blockedCookies(d.blockedSetCookies),
+        worker,
+        closedAt: num(d.closedAt),
+        frames,
+    };
+}
+function decodeWS(v) {
+    const d = asObj(v);
+    return {
+        conn: str(d.conn),
+        dir: str(d.dir),
+        opcode: int(d.opcode),
+        size: num(d.size),
+        data: optStr(d.data),
+        truncated: bool(d.truncated),
+        dataOmitted: bool(d.dataOmitted),
+        dropped: int(d.dropped),
+        error: str(d.error),
+        dataRemoved: bool(d.dataRemoved),
+    };
+}
+function decodeState(v) {
+    const d = asObj(v);
+    const changes = Array.isArray(d.changes)
+        ? d.changes.filter(isObj).map((c) => {
+            const ch = { path: str(c.path), deleted: bool(c.deleted) };
+            if (c.value !== undefined)
+                ch.value = c.value;
+            return ch;
+        })
+        : undefined;
+    const out = {
+        store: str(d.store),
+        kind: str(d.kind),
+        action: str(d.action),
+        payload: optObj(d.payload),
+        payloadTruncated: bool(d.payloadTruncated),
+        changes,
+        truncated: bool(d.truncated),
+        burst: bool(d.burst),
+        reason: str(d.reason),
+    };
+    // Present even when null: the record still carries "the whole state".
+    if (d.state !== undefined)
+        out.state = d.state;
+    return out;
+}
+function decodeConsole(v) {
+    const d = asObj(v);
+    return {
+        level: str(d.level),
+        source: str(d.source),
+        text: str(d.text),
+        args: Array.isArray(d.args) ? d.args : undefined,
+        stack: str(d.stack),
+        url: str(d.url),
+        line: int(d.line),
+        col: int(d.col),
+    };
+}
+function decodeTarget(v) {
+    if (!isObj(v))
+        return undefined;
+    return {
+        tag: str(v.tag),
+        selector: str(v.selector),
+        text: str(v.text),
+        id: str(v.id),
+        classes: str(v.classes),
+        name: str(v.name),
+        type: str(v.type),
+        role: str(v.role),
+        ariaLabel: str(v.ariaLabel),
+        href: str(v.href),
+        testId: str(v.testId),
+        placeholder: str(v.placeholder),
+        title: str(v.title),
+        alt: str(v.alt),
+    };
+}
+function decodeEvent(v) {
+    const d = asObj(v);
+    return {
+        name: str(d.name),
+        kind: str(d.kind),
+        url: str(d.url),
+        title: str(d.title),
+        referrer: str(d.referrer),
+        viewport: isObj(d.viewport) ? { w: int(d.viewport.w), h: int(d.viewport.h) } : undefined,
+        target: decodeTarget(d.target),
+        x: int(d.x),
+        y: int(d.y),
+        count: int(d.count),
+        value: optStr(d.value),
+        masked: bool(d.masked),
+        action: str(d.action),
+        method: str(d.method),
+        label: str(d.label),
+        event: str(d.event),
+        props: optObj(d.props),
+        userId: str(d.userId),
+        traits: optObj(d.traits),
+        dropped: int(d.dropped),
+    };
+}
+function decodePerf(v) {
+    const d = asObj(v);
+    const a = d.attribution;
+    return {
+        kind: str(d.kind),
+        name: str(d.name),
+        value: num(d.value),
+        rating: str(d.rating),
+        id: str(d.id),
+        url: str(d.url),
+        attribution: isObj(a)
+            ? {
+                target: str(a.target),
+                time: num(a.time),
+                url: str(a.url),
+                largestShiftValue: num(a.largestShiftValue),
+                interactionType: str(a.interactionType),
+                inputDelay: num(a.inputDelay),
+                processingDuration: num(a.processingDuration),
+                presentationDelay: num(a.presentationDelay),
+            }
+            : undefined,
+        duration: num(d.duration),
+        blockingDuration: num(d.blockingDuration),
+        scripts: Array.isArray(d.scripts)
+            ? d.scripts.filter(isObj).map((s) => ({
+                url: str(s.url),
+                fn: str(s.fn),
+                invoker: str(s.invoker),
+                invokerType: str(s.invokerType),
+                duration: num(s.duration),
+            }))
+            : undefined,
+    };
+}
+// ---------- predicates ----------
+/** Whether the record is a WebSocket connection. */
+const isWebSocket = (n) => n.kind === 'websocket';
+exports.isWebSocket = isWebSocket;
+/** Whether the request failed: HTTP status >= 400, a transport error, or (deep mode) a CORS check or a block by Chrome. */
+function failed(n) {
+    return n.status >= 400 || n.error !== '' || n.corsErrorStatus !== undefined || n.blockedReason !== '';
+}
+/** Whether the request is a page asset seen through Resource Timing (scripts, images, CSS) rather than an API call or a document. */
+const isAsset = (n) => n.kind === 'resource';
+exports.isAsset = isAsset;
+/** The decoded response size when known, else the transfer size. */
+function sizeOf(n) {
+    if (n.resSize !== undefined)
+        return n.resSize;
+    if (n.transferSize !== undefined)
+        return n.transferSize;
+    return 0;
+}
+/** How a network record was captured. */
+function recorded(n) {
+    return n.source === 'cdp' ? 'deep mode (Chrome DevTools Protocol)' : 'in the page';
+}

package/daemon/dist/tabtape/redact.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * The list of sensitive HTTP headers that are hidden when recorded data
+ * leaves the replay UI: MCP tool results and exports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedactHeaders = exports.DEFAULT_REDACT_HEADERS = exports.REDACTED = void 0;
+/** Replaces the value of a sensitive header. */
+exports.REDACTED = '[redacted]';
+/** The built-in list of sensitive headers. */
+exports.DEFAULT_REDACT_HEADERS = 'authorization,cookie,set-cookie,x-api-key,proxy-authorization';
+/** A set of header names, compared case-insensitively. */
+class RedactHeaders {
+    constructor(list = exports.DEFAULT_REDACT_HEADERS) {
+        this.names = new Set(list
+            .split(',')
+            .map((name) => name.trim().toLowerCase())
+            .filter(Boolean));
+    }
+    /** Whether name is sensitive. */
+    has(name) {
+        return this.names.has(name.toLowerCase());
+    }
+    apply(m) {
+        if (!m)
+            return undefined;
+        const out = {};
+        for (const [k, v] of Object.entries(m))
+            out[k] = this.has(k) ? exports.REDACTED : v;
+        return out;
+    }
+    /** The header names, sorted. */
+    list() {
+        return [...this.names].sort();
+    }
+}
+exports.RedactHeaders = RedactHeaders;

package/daemon/dist/tabtape/repro/lang.js

@@ -0,0 +1,95 @@
+"use strict";
+/** The wording of reproduction steps, one table per language. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.langFor = langFor;
+function withProps(s, props) {
+    return props !== '' ? `${s} (${props})` : s;
+}
+function withScript(s, script) {
+    return script !== '' ? `${s} (${script})` : s;
+}
+function times(n) {
+    return n > 1 ? ` ×${n}` : '';
+}
+const en = {
+    env: 'Environment',
+    startURL: 'Start URL',
+    expected: 'Expected',
+    fillIn: 'fill in',
+    replay: 'Replay',
+    noSteps: '_No user actions in this range._',
+    failed: 'failed',
+    opened: (p) => 'Opened ' + p,
+    navigated: (p) => 'Navigated to ' + p,
+    link: (p) => 'link to ' + p,
+    clicked: (l, n) => 'Clicked ' + l + times(n),
+    typed: (f, v) => 'Typed ' + v + ' into ' + f,
+    selected: (f, v) => 'Selected ' + v + ' in ' + f,
+    file: (f, v) => 'Chose file ' + v + ' in ' + f,
+    cleared: (f) => 'Cleared ' + f,
+    masked: (f) => 'Filled ' + f + ' (masked)',
+    submitted: (f) => 'Submitted form ' + f,
+    checked: (f) => 'Checked ' + f,
+    unchecked: (f) => 'Unchecked ' + f,
+    consoleErr: (t) => 'Console error: ' + t,
+    tracked: (name, props, n) => withProps('Event ' + name, props) + times(n),
+    user: (id) => 'user ' + id,
+    poorVital: (metric, value, target) => {
+        let s = 'Poor ' + metric + ': ' + value;
+        if (target !== '')
+            s += ' on ' + target;
+        return s;
+    },
+    froze: (dur, script) => withScript('Page froze for ' + dur, script),
+    request: (req, status, dur, body) => {
+        let s = req + ' → **' + status + '**';
+        if (dur !== '')
+            s += ' in ' + dur;
+        if (body !== '')
+            s += ': ' + body;
+        return s;
+    },
+};
+const tr = {
+    env: 'Ortam',
+    startURL: "Başlangıç URL'si",
+    expected: 'Beklenen',
+    fillIn: 'doldurun',
+    replay: 'Replay',
+    noSteps: '_Bu aralıkta kullanıcı eylemi yok._',
+    failed: 'başarısız',
+    opened: (p) => p + ' açıldı',
+    navigated: (p) => p + ' sayfasına geçildi',
+    link: (p) => p + ' bağlantısı',
+    clicked: (l, n) => l + times(n) + ' tıklandı',
+    typed: (f, v) => f + ' alanına ' + v + ' yazıldı',
+    selected: (f, v) => f + ' alanında ' + v + ' seçildi',
+    file: (f, v) => f + ' alanında ' + v + ' dosyası seçildi',
+    cleared: (f) => f + ' alanı temizlendi',
+    masked: (f) => f + ' dolduruldu (maskeli)',
+    submitted: (f) => f + ' formu gönderildi',
+    checked: (f) => f + ' işaretlendi',
+    unchecked: (f) => f + ' işareti kaldırıldı',
+    consoleErr: (t) => 'Console hatası: ' + t,
+    tracked: (name, props, n) => withProps(name + ' olayı', props) + times(n),
+    user: (id) => 'kullanıcı ' + id,
+    poorVital: (metric, value, target) => {
+        let s = 'Kötü ' + metric + ': ' + value;
+        if (target !== '')
+            s += ', ' + target;
+        return s;
+    },
+    froze: (dur, script) => withScript('Sayfa ' + dur + ' dondu', script),
+    request: (req, status, dur, body) => {
+        let s = req + ' → **' + status + '**';
+        if (dur !== '')
+            s += ', ' + dur;
+        if (body !== '')
+            s += ': ' + body;
+        return s;
+    },
+};
+/** The wording for a language code: "tr", else English. */
+function langFor(code) {
+    return code === 'tr' ? tr : en;
+}