@reticlehq/server 2.14.0 → 3.2.0

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

@@ -1,47 +0,0 @@
-import { type ImpactCounts, type ImpactDefect, type AccountState, type ImpactScope, type ImpactSnapshot } from '@reticlehq/core';
-/** Read a scope, tolerating absence and corruption: a broken file starts over rather than throwing. */
-export declare function readScope(path: string, now: number): ImpactScope;
-/** YYYY-MM-DD in local time - the day boundary a person recognises, not UTC's. */
-export declare function isoDay(now: number): string;
-/**
- * What a fold knows beyond the counters.
- *
- * `runMs` is a SESSION's lifetime, and it only ever feeds the "longest run" record. It is not a
- * counter: adding it to a total would answer a question nobody asked, and the record used to be fed
- * a single tool call's duration instead, which made the report's superlative a number of
- * milliseconds that never grew past one click.
- */
-export interface ImpactFoldMeta {
-    runMs?: number;
-    /**
-     * The defect this call caught, when it caught one. Carried beside the counters rather than in
-     * them because it is not a tally: `counts.failed` says how many, this says which.
-     */
-    defect?: ImpactDefect;
-}
-/** Fold one delta into a scope: totals, today's bucket, records and streak. Pure. */
-export declare function applyDelta(scope: ImpactScope, delta: Partial<ImpactCounts>, now: number, meta?: ImpactFoldMeta): ImpactScope;
-/**
- * The live impact record for one project.
- *
- * Holds both scopes in memory, folds deltas in synchronously (so a reader always sees the truth),
- * and flushes to disk on a debounce.
- */
-export declare class ImpactStore {
-    #private;
-    constructor(opts: {
-        reticleRoot: string;
-        projectName?: string;
-        now?: () => number;
-        /** Where `~/.reticle` lives. Defaults to the real home; overridden so the shared scope is testable. */
-        globalRoot?: string;
-        /** Reads whether this machine is signed in. Injected so the store stays testable and pure-ish. */
-        account?: () => AccountState;
-    });
-    /** Notified after every fold, so the HUD can be pushed a fresh snapshot. */
-    onChange(fn: () => void): void;
-    record(delta: Partial<ImpactCounts>, meta?: ImpactFoldMeta): void;
-    snapshot(): ImpactSnapshot;
-    /** Write now (process exit, tests). */
-    flush(): void;
-}

package/dist/impact/impact-store.js

@@ -1,255 +0,0 @@
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { homedir } from 'node:os';
-import { readAccountState } from '../cloud/account-state.js';
-import { ReticleDir, IMPACT_DAILY_BUCKETS, IMPACT_DEFECT_LIMIT, IMPACT_SCHEMA_VERSION, ImpactScopeSchema, addImpactCounts, emptyImpactCounts, emptyImpactRecords, estimateImpactSavings, } from '@reticlehq/core';
-/**
- * Where Reticle keeps the record of what it has done for you.
- *
- * Two scopes, two files, both local and never uploaded: the project's own `.reticle/impact.json`,
- * and a machine-wide `~/.reticle/impact.json` that answers "what has Reticle done for me overall"
- * across every app you have instrumented.
- *
- * This is NOT telemetry. Telemetry answers our questions about the product and leaves the machine;
- * this answers the user's question about their own work and never does.
- */
-/** Writes are debounced: a verification loop is 50-200 calls, and each one is a counter bump. */
-const WRITE_DEBOUNCE_MS = 800;
-/** The project's cloud binding, written by `reticle link`. Absent for an unlinked project. */
-const CLOUD_LINK_FILE = 'cloud.json';
-/**
- * `reticleRoot` is the project's own `.reticle` directory (what every other store here is handed);
- * the global scope lives beside the daemon's own state in `~/.reticle`.
- *
- * `globalRoot` defaults to the home directory and exists to be overridden. Reaching for `homedir()`
- * implicitly made the machine-wide scope untestable — the one scope with a concurrency bug in it —
- * so the seam is the fix's precondition, not a test affordance.
- */
-function impactPaths(reticleRoot, globalRoot) {
-    return {
-        project: join(reticleRoot, ReticleDir.IMPACT_FILE),
-        global: join(globalRoot, ReticleDir.ROOT, ReticleDir.IMPACT_FILE),
-    };
-}
-/**
- * Where this project's dashboard lives, if `reticle link` recorded one.
- *
- * Read from the link file rather than derived from the API url, because the API origin and the
- * console origin are different hosts in every deployment that is not a laptop. Synchronous and
- * best-effort, like every other read in this file: a missing or malformed link file means no link
- * in the HUD, never a failed tool call.
- */
-function readDashboardUrl(reticleRoot) {
-    try {
-        const raw = JSON.parse(readFileSync(join(reticleRoot, CLOUD_LINK_FILE), 'utf8'));
-        if ('object' !== typeof raw || null === raw)
-            return undefined;
-        const value = raw['dashboardUrl'];
-        return 'string' === typeof value && value.length > 0 ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function emptyScope(now) {
-    const counts = emptyImpactCounts();
-    return {
-        counts,
-        days: [],
-        records: emptyImpactRecords(),
-        savings: estimateImpactSavings(counts),
-        since: now,
-        defects: [],
-    };
-}
-/** Read a scope, tolerating absence and corruption: a broken file starts over rather than throwing. */
-export function readScope(path, now) {
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        const result = ImpactScopeSchema.safeParse(parsed);
-        return result.success ? result.data : emptyScope(now);
-    }
-    catch {
-        return emptyScope(now);
-    }
-}
-/**
- * Write a scope atomically.
- *
- * tmp + rename, because two daemons can serve two apps in the same repo at once and a half-written
- * counters file is one the next read discards - silently losing the whole history.
- */
-function writeScope(path, scope) {
-    try {
-        mkdirSync(dirname(path), { recursive: true });
-        const tmp = `${path}.${String(process.pid)}.tmp`;
-        writeFileSync(tmp, JSON.stringify(scope, null, 2), 'utf8');
-        renameSync(tmp, path);
-    }
-    catch {
-        // A stats file that cannot be written must never break a tool call. The counters stay in
-        // memory and the next write attempt carries them.
-    }
-}
-/** YYYY-MM-DD in local time - the day boundary a person recognises, not UTC's. */
-export function isoDay(now) {
-    const d = new Date(now);
-    const month = String(d.getMonth() + 1).padStart(2, '0');
-    const day = String(d.getDate()).padStart(2, '0');
-    return `${String(d.getFullYear())}-${month}-${day}`;
-}
-/** Whether `b` is the calendar day right after `a` - the streak rule. */
-function isNextDay(a, b) {
-    const prev = new Date(`${a}T00:00:00`);
-    const next = new Date(`${b}T00:00:00`);
-    return 1 === Math.round((next.getTime() - prev.getTime()) / 86_400_000);
-}
-/** Fold one delta into a scope: totals, today's bucket, records and streak. Pure. */
-export function applyDelta(scope, delta, now, meta = {}) {
-    const today = isoDay(now);
-    const counts = addImpactCounts(scope.counts, delta);
-    const days = scope.days.slice();
-    const last = days[days.length - 1];
-    if (last !== undefined && last.date === today) {
-        days[days.length - 1] = { date: today, counts: addImpactCounts(last.counts, delta) };
-    }
-    else {
-        days.push({ date: today, counts: addImpactCounts(emptyImpactCounts(), delta) });
-    }
-    while (days.length > IMPACT_DAILY_BUCKETS)
-        days.shift();
-    const todayCounts = days[days.length - 1]?.counts ?? emptyImpactCounts();
-    const previousDay = days[days.length - 2];
-    const records = { ...scope.records };
-    records.bestVerdictDay = Math.max(records.bestVerdictDay, todayCounts.verdicts);
-    records.bestDefectDay = Math.max(records.bestDefectDay, todayCounts.failed);
-    if (last === undefined || last.date !== today) {
-        // A new day joins the streak only if it follows yesterday; otherwise it starts a new one.
-        records.streakDays =
-            previousDay !== undefined && isNextDay(previousDay.date, today) ? records.streakDays + 1 : 1;
-    }
-    else if (0 === records.streakDays) {
-        records.streakDays = 1;
-    }
-    records.bestStreakDays = Math.max(records.bestStreakDays, records.streakDays);
-    records.longestRunMs = Math.max(records.longestRunMs, meta.runMs ?? 0);
-    /*
-     * Newest first, capped. Prepending is what makes the HUD's short list the CURRENT breakage rather
-     * than the first ten things that ever broke — which, after a week, is a list about the past.
-     */
-    const defects = meta.defect === undefined
-        ? scope.defects
-        : [meta.defect, ...scope.defects].slice(0, IMPACT_DEFECT_LIMIT);
-    return {
-        counts,
-        days,
-        records,
-        savings: estimateImpactSavings(counts),
-        since: scope.since,
-        defects,
-    };
-}
-/**
- * The live impact record for one project.
- *
- * Holds both scopes in memory, folds deltas in synchronously (so a reader always sees the truth),
- * and flushes to disk on a debounce.
- */
-export class ImpactStore {
-    #paths;
-    #now;
-    #projectName;
-    #dashboardUrl;
-    #project;
-    #global;
-    /**
-     * Deltas folded since the last machine-wide write, kept so the write can be a MERGE.
-     *
-     * The project scope has one writer and can be written wholesale. The machine-wide file is shared
-     * by every daemon on the box, so writing an in-memory copy taken at construction erases whatever a
-     * sibling wrote in between — which is what made the machine streak read LOWER than a single
-     * project's. Replaying these onto whatever is on disk at flush time is what makes the write additive.
-     */
-    #pendingGlobal = [];
-    #timer;
-    #onChange;
-    #account;
-    constructor(opts) {
-        this.#paths = impactPaths(opts.reticleRoot, opts.globalRoot ?? homedir());
-        // Resolved per snapshot, not cached: a user who runs `reticle login` in another terminal must
-        // see the HUD change without restarting the daemon that is watching their app.
-        this.#account = opts.account ?? (() => readAccountState(homedir(), process.env));
-        this.#now = opts.now ?? (() => Date.now());
-        this.#projectName = opts.projectName;
-        this.#dashboardUrl = readDashboardUrl(opts.reticleRoot);
-        const now = this.#now();
-        this.#project = readScope(this.#paths.project, now);
-        this.#global = readScope(this.#paths.global, now);
-    }
-    /** Notified after every fold, so the HUD can be pushed a fresh snapshot. */
-    onChange(fn) {
-        this.#onChange = fn;
-    }
-    record(delta, meta = {}) {
-        const now = this.#now();
-        this.#project = applyDelta(this.#project, delta, now, meta);
-        // Folded in memory so a reader sees it immediately, AND buffered so the durable write can replay
-        // it onto a file a sibling may have moved on since. The in-memory copy is rebased at flush.
-        this.#global = applyDelta(this.#global, delta, now, meta);
-        this.#pendingGlobal.push({ delta, now, meta });
-        this.#scheduleFlush();
-        this.#onChange?.();
-    }
-    snapshot() {
-        const snap = {
-            schemaVersion: IMPACT_SCHEMA_VERSION,
-            project: this.#project,
-            global: this.#global,
-        };
-        if (this.#projectName !== undefined)
-            snap.projectName = this.#projectName;
-        if (this.#dashboardUrl !== undefined)
-            snap.dashboardUrl = this.#dashboardUrl;
-        snap.account = this.#account();
-        return snap;
-    }
-    /** Write now (process exit, tests). */
-    flush() {
-        if (this.#timer !== undefined) {
-            clearTimeout(this.#timer);
-            this.#timer = undefined;
-        }
-        // One writer: the in-memory copy IS the truth.
-        writeScope(this.#paths.project, this.#project);
-        this.#flushGlobal();
-    }
-    /**
-     * Publish this store's contribution to the machine-wide scope WITHOUT discarding anyone else's.
-     *
-     * Re-reads what is on disk and replays only the deltas recorded since the last write, so a sibling
-     * daemon's day survives. The merged result is adopted in memory too, which is what keeps the HUD's
-     * "everything on this machine" honest rather than showing this process's private view forever.
-     *
-     * ponytail: read-modify-write, not locked. Two daemons flushing inside the same read→rename window
-     * can still drop one batch — far rarer than the every-second-flush loss this replaces, and it costs
-     * one debounce window rather than a whole history. Upgrade to a lock file (exclusive `wx` create
-     * plus a stale timeout) if the counters are ever load-bearing for anything but the HUD.
-     */
-    #flushGlobal() {
-        if (0 === this.#pendingGlobal.length)
-            return;
-        const merged = this.#pendingGlobal.reduce((scope, p) => applyDelta(scope, p.delta, p.now, p.meta), readScope(this.#paths.global, this.#now()));
-        writeScope(this.#paths.global, merged);
-        this.#global = merged;
-        this.#pendingGlobal = [];
-    }
-    #scheduleFlush() {
-        if (this.#timer !== undefined)
-            return;
-        this.#timer = setTimeout(() => {
-            this.#timer = undefined;
-            this.flush();
-        }, WRITE_DEBOUNCE_MS);
-        this.#timer.unref?.();
-    }
-}

package/dist/input/network-detail.d.ts

@@ -1,104 +0,0 @@
-import { URL_RAW, type RedactionPolicy, type ReticleEvent } from '@reticlehq/core';
-/**
- * CDP-authoritative network detail. Wherever the daemon has a CDP connection — whether it launched
- * the browser or attached to one someone else started — `page.on('response')` sees the FULL response:
- * status, mime type, and every response header, including the ones the in-page fetch/XHR wrapper
- * structurally cannot read (CORS-opaque headers, redirects).
- * Capturing it as a NET_DETAIL event and merging it onto the matching in-page NET_REQUEST means the
- * driven view never loses fidelity to an outside-in tool. Pure builder + merge are unit-tested; the
- * `page.on` attachment is thin Playwright glue (exercised e2e, like the pool launcher).
- */
-export interface NetworkDetail {
-    /**
-     * The URL as the agent reads it, redacted by the same rule the in-page observer applies.
-     *
-     * It arrives raw from the driver, exactly like the headers and the request body below, and it
-     * carries credentials just as routinely: a presigned upload, an OAuth callback, a single-use reset
-     * link. Redacting the other two and not this one left the one field nobody had to parse to read.
-     */
-    url: string;
-    /**
-     * The URL before redaction, present only when redaction rewrote it.
-     *
-     * The grader-only match haystack, the same field and the same contract as on a NET_REQUEST: it is
-     * how `urlContains` still matches a public path segment the heuristic rewrote, and how the merge
-     * below pairs this detail with the request the SDK reported. `withoutUrlRaw` strips it before any
-     * event is rendered to an agent.
-     */
-    [URL_RAW]?: string;
-    method?: string;
-    status: number;
-    headers: Record<string, string>;
-    resourceType?: string;
-    /**
-     * The request body as the NETWORK STACK saw it — what actually left, not what the page handed to
-     * fetch. Redacted and bounded here because it arrives raw from the driver.
-     *
-     * This is the one thing in-page instrumentation structurally cannot get: Reticle reads `init.body`
-     * inside its own fetch wrapper, and whoever patches fetch last is outermost — app bootstrap
-     * decides that, not us. An interceptor initialised after connect(), or a service worker (no
-     * window.fetch frame at all), rewrites requests invisibly. Available on the DRIVE path only.
-     */
-    requestBody?: string;
-    /**
-     * Present, and only ever `true`, when the bound above cut the captured body short.
-     *
-     * The same field and the same contract the in-page observer already emits. A shortened body an
-     * agent cannot tell apart from a whole one is the false green this project exists to prevent: a
-     * `net` assertion over a payload that was cut reads as an absence of the thing that was cut off.
-     * Omitted when the whole body fits, so the caveat means something when it appears.
-     */
-    requestBodyTruncated?: boolean;
-    /**
-     * The document that ISSUED the request, which is what identifies the session it belongs to.
-     *
-     * Routing used to match the REQUEST's origin against the session's, falling back to the drive
-     * URL's. Both miss the ordinary case: an app on one origin calling an API on another produces a
-     * detail matching no session, so it was dropped silently — and on the CDP-attach path there is no
-     * drive URL, so the fallback matched nothing at all. Cross-origin API calls are most API calls.
-     */
-    pageUrl?: string;
-}
-/**
- * Shape a raw authoritative response into a NET_DETAIL payload (lower-cased headers).
- *
- * `policy` defaults to the built-in rule so this stays a PURE builder — the driven-path union is
- * resolved by `attachNetworkDetail`, at the glue layer, where reading process state is not a lie
- * about the function's inputs.
- */
-export declare function buildNetworkDetail(raw: {
-    url: string;
-    method?: string;
-    status: number;
-    headers: Record<string, string>;
-    resourceType?: string;
-    requestBody?: string;
-    pageUrl?: string;
-}, policy?: RedactionPolicy): NetworkDetail;
-/**
- * Fold each NET_DETAIL onto the matching in-page NET_REQUEST (by method+url), enriching it with the
- * authoritative headers/resourceType the page-side wrapper couldn't see — WITHOUT clobbering fields the
- * in-page event already carries. A NET_DETAIL with no matching request is kept as its own event (a
- * response the wrapper missed is signal, never silently dropped). Pure over the event list.
- */
-export declare function mergeNetworkDetail(events: readonly ReticleEvent[]): ReticleEvent[];
-/** The minimal Playwright surfaces this attachment reads — kept structural so it's fake-testable. */
-export interface ResponseLike {
-    url(): string;
-    status(): number;
-    headers(): Record<string, string> | Promise<Record<string, string>>;
-    request(): {
-        method(): string;
-        resourceType?(): string;
-        postData?(): string | null;
-    };
-}
-export interface PageLike {
-    url(): string;
-    on(event: 'response', handler: (response: ResponseLike) => void): void;
-}
-/**
- * Attach a response listener to a driven page: every response becomes a NET_DETAIL via `emit`. Thin glue
- * over Playwright's event surface — the daemon routes `emit` to the driven session's pushEvent.
- */
-export declare function attachNetworkDetail(page: PageLike, emit: (detail: NetworkDetail) => void): void;

package/dist/input/network-detail.js

@@ -1,211 +0,0 @@
-import { EventType, REDACTED_VALUE, URL_RAW, defaultIsSensitiveKey, netUrlFields, scrubKnownSecrets, urlForMatch, } from '@reticlehq/core';
-import { drivenRedactionPolicy } from './driven-redaction.js';
-/** Bound on a captured wire body — matches the in-page capture so the two are comparable. */
-const MAX_WIRE_BODY_CHARS = 8192;
-/**
- * The rule this module redacts by.
- *
- * `defaultIsSensitiveKey`, never the ambient `isSensitiveKey`: a daemon serves many sessions in one
- * process, so an ambient policy here would let one app's config decide another app's redaction.
- * Callers that have a session's declarations pass a policy explicitly; everything else gets the
- * built-in floor, which is exactly what this module did before the rule became configurable.
- */
-const DEFAULT_POLICY = { isSensitiveKey: defaultIsSensitiveKey };
-/**
- * Redact a sensitive key's value whatever its TYPE — string, number, array, or a nested object.
- *
- * This is the one payload in the system that reaches the journal without having passed through the
- * SDK's sanitizer (Playwright hands it over raw), so its redaction has to be as strong as the SDK's,
- * which is key-based over a parsed object — not string-shaped.
- */
-function redactByKey(value, policy) {
-    if (Array.isArray(value))
-        return value.map((v) => redactByKey(v, policy));
-    if (value !== null && 'object' === typeof value) {
-        const out = {};
-        for (const [k, v] of Object.entries(value)) {
-            out[k] = policy.isSensitiveKey(k) ? REDACTED_VALUE : redactByKey(v, policy);
-        }
-        return out;
-    }
-    return value;
-}
-/**
- * Redact and bound a captured wire body, returning the value AND whether the bound was reached.
- *
- * The report is the point. This body is taken raw off the network stack, it is capped, and the cap is
- * reached by ordinary payloads (a bulk save, a base64 attachment, a rich-text field). Returning the
- * shortened string alone let a partial capture be read as a whole one, which is the shape the
- * lossy-transform rule exists to forbid.
- */
-function projectWireBody(raw, policy) {
-    const truncated = raw.length > MAX_WIRE_BODY_CHARS;
-    const bounded = truncated ? raw.slice(0, MAX_WIRE_BODY_CHARS) : raw;
-    const byShape = scrubKnownSecrets(bounded);
-    // Prefer a STRUCTURAL pass. A sensitive key must be redacted regardless of its value type — a
-    // numeric PIN (`"password": 1234`), a token array, a nested credential object — and the old
-    // string-only sweep matched exclusively `"key":"string"`, so every non-string secret leaked
-    // straight to the agent's context and the on-disk journal. Parsing and walking redacts them by key
-    // whatever the shape.
-    try {
-        return { body: JSON.stringify(redactByKey(JSON.parse(byShape), policy)), truncated };
-    }
-    catch {
-        // Not JSON (a truncated capture, or a form-encoded body — the shape a login form actually POSTs).
-        // Two best-effort sweeps, because a password lives in both: the `"key":"string"` JSON fragment a
-        // truncated body still contains, and the `key=value` pair of `application/x-www-form-urlencoded`,
-        // which neither the JSON path nor the old regex ever touched — so `password=hunter2` leaked.
-        const body = byShape
-            .replace(/"([^"]+)"\s*:\s*"([^"]*)"/g, (whole, key) => policy.isSensitiveKey(key) ? `"${key}":"${REDACTED_VALUE}"` : whole)
-            .replace(/([^&?=\s]+)=([^&\s]*)/g, (whole, key) => policy.isSensitiveKey(key) ? `${key}=${REDACTED_VALUE}` : whole);
-        return { body, truncated };
-    }
-}
-/**
- * Header names are case-insensitive; normalize to lower-case so a merge/compare is stable — and
- * REDACT while we do it. On the CDP/drive path `page.on('response')` sees the full response headers,
- * including `set-cookie` (the session credential), and requests carry `cookie`/`authorization`. These
- * were the one wire payload that reached the journal (cleartext, on disk) and the agent's context
- * window unredacted — every other capture goes through the SDK sanitizer or projectWireBody. A
- * credential HEADER is redacted whole by key; any other header value is still swept for known secret
- * SHAPES (a JWT echoed in a custom header), matching how request bodies are handled.
- */
-function projectHeaders(headers, policy) {
-    const out = {};
-    for (const [k, v] of Object.entries(headers)) {
-        const key = k.toLowerCase();
-        out[key] = policy.isSensitiveKey(key) ? REDACTED_VALUE : scrubKnownSecrets(v);
-    }
-    return out;
-}
-/**
- * Shape a raw authoritative response into a NET_DETAIL payload (lower-cased headers).
- *
- * `policy` defaults to the built-in rule so this stays a PURE builder — the driven-path union is
- * resolved by `attachNetworkDetail`, at the glue layer, where reading process state is not a lie
- * about the function's inputs.
- */
-export function buildNetworkDetail(raw, policy = DEFAULT_POLICY) {
-    const wireBody = raw.requestBody === undefined || 0 === raw.requestBody.length
-        ? undefined
-        : projectWireBody(raw.requestBody, policy);
-    return {
-        ...netUrlFields(raw.url, policy.isSensitiveKey),
-        ...(raw.method === undefined ? {} : { method: raw.method }),
-        status: raw.status,
-        headers: projectHeaders(raw.headers, policy),
-        ...(raw.resourceType === undefined ? {} : { resourceType: raw.resourceType }),
-        ...(wireBody === undefined
-            ? {}
-            : {
-                requestBody: wireBody.body,
-                ...(wireBody.truncated ? { requestBodyTruncated: true } : {}),
-            }),
-        ...(raw.pageUrl === undefined || 0 === raw.pageUrl.length ? {} : { pageUrl: raw.pageUrl }),
-    };
-}
-/**
- * The merge key: method plus the RAW url when the observation kept one, else the displayed url.
- *
- * Never the displayed url alone. The two sides redact independently, the SDK under the page's own
- * policy and this module under the daemon's, so the one field they were being compared on is the one
- * field redaction is allowed to rewrite. Keying on `urlForMatch` compares what was actually
- * requested, which is identical on both sides by construction.
- */
-function keyOf(data) {
-    const method = data['method'];
-    const m = 'string' === typeof method ? method.toUpperCase() : '';
-    return `${m} ${urlForMatch(data)}`;
-}
-/**
- * Fold each NET_DETAIL onto the matching in-page NET_REQUEST (by method+url), enriching it with the
- * authoritative headers/resourceType the page-side wrapper couldn't see — WITHOUT clobbering fields the
- * in-page event already carries. A NET_DETAIL with no matching request is kept as its own event (a
- * response the wrapper missed is signal, never silently dropped). Pure over the event list.
- */
-export function mergeNetworkDetail(events) {
-    const requestByKey = new Map();
-    for (const e of events) {
-        if (e.type === EventType.NET_REQUEST)
-            requestByKey.set(keyOf(e.data), e);
-    }
-    const out = [];
-    const enriched = new Map();
-    for (const e of events) {
-        if (e.type === EventType.NET_DETAIL) {
-            const match = requestByKey.get(keyOf(e.data));
-            if (match === undefined) {
-                out.push(e); // unmatched detail survives on its own
-                continue;
-            }
-            const base = enriched.get(match) ?? match;
-            const data = { ...base.data };
-            if (data['headers'] === undefined && e.data['headers'] !== undefined) {
-                data['headers'] = e.data['headers'];
-            }
-            if (data['resourceType'] === undefined && e.data['resourceType'] !== undefined) {
-                data['resourceType'] = e.data['resourceType'];
-            }
-            // The ONLY field that overwrites rather than filling a gap. The in-page value is what the app
-            // INTENDED to send; this is what actually went. When they disagree, the disagreement is the
-            // finding — that is the whole reason for capturing it — so the authoritative one wins and the
-            // divergence is flagged rather than silently resolved.
-            const wireBody = e.data['requestBody'];
-            if ('string' === typeof wireBody) {
-                const pageBody = data['requestBody'];
-                if ('string' === typeof pageBody && pageBody !== wireBody) {
-                    data['requestBodyDivergedFromPage'] = true;
-                }
-                data['requestBody'] = wireBody;
-                // The caveat belongs to the body it describes, and this is the one field that REPLACES
-                // rather than fills a gap. Carried over when the wire body was cut, deleted when it was not:
-                // a stale `true` from the page capture would caveat a body that is now whole, and a missing
-                // one would let a cut body read as complete.
-                if (true === e.data['requestBodyTruncated'])
-                    data['requestBodyTruncated'] = true;
-                else
-                    delete data['requestBodyTruncated'];
-            }
-            enriched.set(match, { ...base, data });
-            continue; // the detail is absorbed into the request
-        }
-    }
-    for (const e of events) {
-        if (e.type === EventType.NET_DETAIL)
-            continue; // handled above
-        out.push(enriched.get(e) ?? e);
-    }
-    return out;
-}
-/**
- * Attach a response listener to a driven page: every response becomes a NET_DETAIL via `emit`. Thin glue
- * over Playwright's event surface — the daemon routes `emit` to the driven session's pushEvent.
- */
-export function attachNetworkDetail(page, emit) {
-    page.on('response', (response) => {
-        const detailPromise = Promise.resolve(response.headers()).then((headers) => {
-            const request = response.request();
-            const resourceType = request.resourceType?.();
-            // postData is null for GETs and for bodies the driver did not retain; both mean "nothing to say".
-            const postData = request.postData?.() ?? null;
-            emit(buildNetworkDetail({
-                url: response.url(),
-                method: request.method(),
-                status: response.status(),
-                headers,
-                ...(resourceType === undefined ? {} : { resourceType }),
-                ...(null === postData ? {} : { requestBody: postData }),
-                pageUrl: page.url(),
-            }, 
-            // Resolved per response, not per attachment: a session declaring extra keys can connect
-            // after the listener is attached, and capturing the policy once would leave every
-            // already-driven page redacting by the rule that was in force before the app said so.
-            drivenRedactionPolicy()));
-        });
-        // `response.headers()` REJECTS when the page/CDP session is closing — precisely when responses race
-        // teardown (navigation, tab close). Without this catch the rejection floats; on the daemon path a
-        // global unhandledRejection trap swallows it, but on the stdio `start()` path there is no trap, so
-        // one late response would crash the whole MCP server. A detail we can't read is simply dropped.
-        void detailPromise.catch(() => undefined);
-    });
-}

package/dist/input/network-mock-tools.d.ts

@@ -1,21 +0,0 @@
-import type { MockRule } from './network-mock.js';
-import type { ToolDef } from '../tools/tools.js';
-/**
- * Narrow the validated tool args into MockRule[], omitting undefined keys (exactOptionalPropertyTypes).
- *
- * THROWS on a malformed rule rather than falling back to `[]`, because `[]` is not a neutral value
- * here — it is the documented way to clear every active mock. A rule with a wrong field name used to
- * produce exactly the call that turns mocking OFF, and the handler then reported `applied: true`
- * with `count: 0`. For a tool whose entire job is forcing an error state, that means the agent
- * checks the app's failure handling against the real backend, sees the happy path, and reports that
- * the error state works.
- *
- * Same rule as the action arguments: an argument that could not be understood is refused by name,
- * never reinterpreted into a destructive default. A valueless `fill` used to wipe the field and
- * report ok; it throws now, for this reason.
- *
- * `undefined` and `[]` still mean "clear" — those are deliberate, documented requests, not failures
- * to parse.
- */
-export declare function toRules(value: unknown): MockRule[];
-export declare const NETWORK_MOCK_TOOLS: ToolDef[];