@jsonstudio/rcc 0.89.1968 → 0.89.2195

package/dist/scripts/camoufox/launch-auth.mjs

@@ -104,6 +104,14 @@ function buildFirefoxUserPrefs() {
     'javascript.use_us_english_locale': true,
     'intl.charset.fallback.override': 'UTF-8',
     'gfx.downloadable_fonts.enabled': true,
+    'browser.startup.page': 0,
+    'browser.sessionstore.resume_from_crash': false,
+    'browser.sessionstore.resume_session_once': false,
+    'browser.sessionstore.max_resumed_crashes': 0,
+    'layers.acceleration.disabled': true,
+    'gfx.webrender.all': false,
+    'gfx.webrender.software': true,
+    'media.hardware-video-decoding.enabled': false,
     'font.default.x-western': 'sans-serif',
     'font.name.sans-serif.x-western': 'Arial',
     'font.name.serif.x-western': 'Times New Roman',
@@ -270,6 +278,92 @@ function cleanupExistingCamoufox(profileDir) {
       // ignore lock cleanup failure
     }
   }
+  const volatileStatePaths = [
+    'sessionstore.jsonlz4',
+    'sessionstore-backups',
+    'recovery.jsonlz4',
+    'recovery.baklz4',
+    'previous.jsonlz4',
+    'sessionCheckpoints.json',
+    'startupCache'
+  ];
+  for (const rel of volatileStatePaths) {
+    const target = path.join(profileDir, rel);
+    try {
+      if (fs.existsSync(target)) {
+        fs.rmSync(target, { recursive: true, force: true });
+      }
+    } catch {
+      // ignore volatile state cleanup failure
+    }
+  }
+}
+
+function hasRunningCamoufoxForProfile(profileDir) {
+  if (!profileDir) {
+    return false;
+  }
+  try {
+    const running = listRunningCamoufoxProcesses();
+    return running.some((proc) => String(proc.command || '').includes(profileDir));
+  } catch {
+    return false;
+  }
+}
+
+function hasAnyRunningCamoufox() {
+  try {
+    return listRunningCamoufoxProcesses().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function listRunningCamoufoxProcesses() {
+  const probe = spawnSync('pgrep', ['-fal', 'camoufox'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  });
+  if (!probe || probe.status !== 0) {
+    return [];
+  }
+
+  const selfPid = process.pid;
+  const lines = String(probe.stdout || '')
+    .split(/\r?\n/)
+    .map((line) => String(line || '').trim())
+    .filter(Boolean);
+
+  const result = [];
+  for (const line of lines) {
+    const spaceIdx = line.indexOf(' ');
+    if (spaceIdx <= 0) {
+      continue;
+    }
+    const pid = Number(line.slice(0, spaceIdx));
+    const command = line.slice(spaceIdx + 1).trim();
+    if (!Number.isFinite(pid) || pid <= 0 || pid === selfPid) {
+      continue;
+    }
+    const cmd = command.toLowerCase();
+    if (!cmd) {
+      continue;
+    }
+    if (cmd.includes('launch-auth.mjs')) {
+      continue;
+    }
+    if (cmd.includes('pgrep -fal camoufox')) {
+      continue;
+    }
+    const looksLikeCamoufox =
+      cmd.includes('camoufox.app/contents/macos/camoufox') ||
+      /(^|\/)camoufox(\s|$)/.test(cmd);
+    if (!looksLikeCamoufox) {
+      continue;
+    }
+    result.push({ pid, command });
+  }
+  return result;
 }
 
 async function main() {
@@ -413,6 +507,16 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
   console.log(`[camoufox-launch-auth] binary=${camoufoxBinary}`);
   console.log(`[camoufox-launch-auth] profileDir=${profileDir}`);
   console.log(`[camoufox-launch-auth] url=${url}`);
+  if (hasRunningCamoufoxForProfile(profileDir)) {
+    console.log(
+      '[camoufox-launch-auth] Same OAuth profile is already running; cleaning stale session state and relaunching isolated instance.'
+    );
+    cleanupExistingCamoufox(profileDir);
+  } else if (hasAnyRunningCamoufox()) {
+    console.log(
+      '[camoufox-launch-auth] Detected other Camoufox instances with different profiles; launching isolated OAuth instance with -no-remote.'
+    );
+  }
   let browserExitCode = 0;
   let browser = null;
   const shutdownBrowser = (signal = 'SIGTERM') => {
@@ -430,7 +534,7 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
   });
 
   try {
-    browser = spawn(camoufoxBinary, ['-profile', profileDir, url], {
+    browser = spawn(camoufoxBinary, ['-no-remote', '-profile', profileDir, url], {
       detached: false,
       stdio: 'ignore',
       env: buildCamoufoxLaunchEnv()
@@ -453,8 +557,18 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
 
 async function launchCamoufoxDetached({ camoufoxBinary, profileDir, url }) {
   console.log('[camoufox-launch-auth] Launching Camoufox (detached) ...');
+  if (hasRunningCamoufoxForProfile(profileDir)) {
+    console.log(
+      '[camoufox-launch-auth] Same OAuth profile is already running; cleaning stale session state and relaunching isolated instance.'
+    );
+    cleanupExistingCamoufox(profileDir);
+  } else if (hasAnyRunningCamoufox()) {
+    console.log(
+      '[camoufox-launch-auth] Detected other Camoufox instances with different profiles; launching isolated OAuth instance with -no-remote.'
+    );
+  }
   try {
-    const child = spawn(camoufoxBinary, ['-profile', profileDir, url], {
+    const child = spawn(camoufoxBinary, ['-no-remote', '-profile', profileDir, url], {
       detached: true,
       stdio: 'ignore',
       env: buildCamoufoxLaunchEnv()
@@ -474,9 +588,14 @@ function isSelectorOrTimeoutError(error) {
   return (
     /timeout/i.test(message) ||
     /waiting for selector/i.test(message) ||
+    /selector[^.\n]*not detected/i.test(message) ||
+    /page\/account selector not detected/i.test(message) ||
+    /not detected/i.test(message) ||
     /strict mode violation/i.test(message) ||
+    /target page, context or browser has been closed/i.test(message) ||
     message.includes('未能定位') ||
-    message.includes('无法定位')
+    message.includes('无法定位') ||
+    message.includes('未检测到')
   );
 }
 
@@ -636,6 +755,7 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
   }
 
   const headless = !devMode;
+  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_IFLOW_TIMEOUT_MS || 300_000);
   console.log(`[camoufox-launch-auth] Launching Camoufox in ${headless ? 'headless' : 'headed'} mode...`);
   cleanupExistingCamoufox(profileDir);
   const context = await firefox.launchPersistentContext(profileDir, {
@@ -668,7 +788,7 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
     await button.click();
     console.log('[camoufox-launch-auth] Continue button clicked, waiting for iFlow window...');
     const popup = await popupPromise;
-    const iflowPage = popup ?? page;
+    let iflowPage = popup ?? page;
     const selectors = [
       'span.accountName--ZKlffRBc',
       'span[class^="accountName--"]',
@@ -678,16 +798,44 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
     ];
     const selectorQuery = selectors.join(', ');
     console.log('[camoufox-launch-auth] Waiting for iFlow OAuth URL or account DOM to load...');
+    const waitForCallbackPromise = waitForCallback(context, iflowPage, 60000)
+      .then((callbackPage) => ({ kind: 'callback', callbackPage }))
+      .catch((error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn('[camoufox-launch-auth] waitForCallback did not settle:', msg);
+        return null;
+      });
     const waitForUrlPromise = iflowPage
       .waitForURL((current) => typeof current === 'string' && current.includes('iflow.cn'), { timeout: 60000 })
-      .then(() => 'url');
+      .then(() => ({ kind: 'url' }))
+      .catch((error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn('[camoufox-launch-auth] waitForURL did not settle:', msg);
+        return null;
+      });
     const waitForDomPromise = iflowPage
       .waitForSelector(selectorQuery, { timeout: 60000 })
-      .then(() => 'dom');
-    const raceResult = await Promise.race([waitForUrlPromise, waitForDomPromise]);
-    waitForUrlPromise.catch(() => {});
-    waitForDomPromise.catch(() => {});
-    if (raceResult === 'url') {
+      .then(() => ({ kind: 'dom' }))
+      .catch((error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn('[camoufox-launch-auth] waitForSelector did not settle:', msg);
+        return null;
+      });
+    const raceResult = await Promise.race([waitForUrlPromise, waitForDomPromise, waitForCallbackPromise]);
+    if (!raceResult) {
+      const fallback = await waitForAnyElementInPages(context, selectors, 60000);
+      if (fallback?.page) {
+        iflowPage = fallback.page;
+        console.log('[camoufox-launch-auth] Fallback page with account DOM detected, continuing...');
+      } else {
+        throw new Error('iFlow OAuth page/account selector not detected');
+      }
+    } else if (raceResult.kind === 'callback') {
+      callbackObserved = true;
+      await raceResult.callbackPage.waitForLoadState('load', { timeout: timeoutMs }).catch(() => {});
+      console.log('[camoufox-launch-auth] OAuth callback detected before account selection, automation complete.');
+      return;
+    } else if (raceResult.kind === 'url') {
       console.log(`[camoufox-launch-auth] iFlow URL detected: ${await iflowPage.url()}`);
       await iflowPage.waitForSelector(selectorQuery, { timeout: 60000 });
     } else {

package/dist/server/handlers/handler-response-utils.d.ts

@@ -0,0 +1,13 @@
+import type { Response } from 'express';
+import type { PipelineExecutionResult } from './types.js';
+interface DispatchOptions {
+    forceSSE?: boolean;
+    entryEndpoint?: string;
+}
+export interface SsePayloadShape {
+    __sse_responses?: unknown;
+}
+export declare function hasSsePayload(body: unknown): body is SsePayloadShape;
+export declare function isAnalysisModeEnabled(): boolean;
+export declare function sendPipelineResponse(res: Response, result: PipelineExecutionResult, requestId?: string, options?: DispatchOptions): void;
+export {};

package/dist/server/handlers/handler-response-utils.js

@@ -0,0 +1,427 @@
+import { Readable, PassThrough } from 'node:stream';
+import { logPipelineStage } from '../utils/stage-logger.js';
+import { DEFAULT_TIMEOUTS } from '../../constants/index.js';
+import { stripInternalKeysDeep } from '../../utils/strip-internal-keys.js';
+import { writeServerSnapshot } from '../../utils/snapshot-writer.js';
+import { resolveEffectiveRequestId } from '../utils/request-id-manager.js';
+const BLOCKED_HEADERS = new Set(['content-length', 'transfer-encoding', 'connection', 'content-encoding']);
+function formatRequestId(value) {
+    return resolveEffectiveRequestId(value);
+}
+export function hasSsePayload(body) {
+    return Boolean(body && typeof body === 'object' && '__sse_responses' in body);
+}
+export function isAnalysisModeEnabled() {
+    const mode = String(process.env.ROUTECODEX_MODE || process.env.RCC_MODE || '').trim().toLowerCase();
+    if (mode === 'analysis') {
+        return true;
+    }
+    const flag = String(process.env.ROUTECODEX_ANALYSIS || process.env.RCC_ANALYSIS || '').trim().toLowerCase();
+    if (flag === '1' || flag === 'true') {
+        return true;
+    }
+    return false;
+}
+export function sendPipelineResponse(res, result, requestId, options) {
+    const status = typeof result.status === 'number' ? result.status : 200;
+    const body = result.body;
+    const requestLabel = formatRequestId(requestId);
+    const forceSSE = options?.forceSSE === true;
+    const expectsStream = hasSsePayload(body);
+    const entryEndpoint = typeof options?.entryEndpoint === 'string' && options.entryEndpoint.trim()
+        ? options.entryEndpoint.trim()
+        : undefined;
+    const captureClientResponse = isAnalysisModeEnabled();
+    if (forceSSE && !expectsStream) {
+        logPipelineStage('response.sse.missing', requestLabel, { status });
+        if (captureClientResponse) {
+            void writeServerSnapshot({
+                phase: 'client-response.error',
+                requestId: requestLabel,
+                entryEndpoint,
+                data: { status: 502, error: { message: 'SSE stream missing from pipeline result', code: 'sse_bridge_error' } }
+            }).catch(() => { });
+        }
+        res.status(502).json({ error: { message: 'SSE stream missing from pipeline result', code: 'sse_bridge_error' } });
+        return;
+    }
+    logPipelineStage('response.dispatch.start', requestLabel, { status, stream: expectsStream, forced: forceSSE });
+    if (expectsStream) {
+        const streamSource = body.__sse_responses;
+        const stream = toNodeReadable(streamSource);
+        if (!stream) {
+            logPipelineStage('response.sse.missing', requestLabel, {});
+            if (captureClientResponse) {
+                void writeServerSnapshot({
+                    phase: 'client-response.error',
+                    requestId: requestLabel,
+                    entryEndpoint,
+                    data: { status: 502, error: { message: 'SSE stream missing from pipeline result', code: 'sse_bridge_error' } }
+                }).catch(() => { });
+            }
+            res.status(502).json({ error: { message: 'SSE stream missing from pipeline result', code: 'sse_bridge_error' } });
+            return;
+        }
+        const outboundStream = captureClientResponse
+            ? maybeAttachClientSseSnapshotStream(stream, {
+                requestId: requestLabel,
+                entryEndpoint,
+                status,
+                headers: result.headers
+            })
+            : stream;
+        applyHeaders(res, result.headers, true);
+        res.status(status);
+        res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+        res.setHeader('Cache-Control', 'no-cache, no-transform');
+        res.setHeader('Connection', 'keep-alive');
+        const flushable = res;
+        if (typeof flushable.flushHeaders === 'function') {
+            flushable.flushHeaders();
+        }
+        else if (typeof flushable.flush === 'function') {
+            flushable.flush();
+        }
+        logPipelineStage('response.sse.stream.start', requestLabel, { status });
+        let eventCount = 0;
+        let ended = false;
+        let idleTimer = null;
+        let totalTimer = null;
+        let keepaliveTimer = null;
+        const readTimeoutMs = (names, fallback) => {
+            for (const name of names) {
+                const raw = String(process.env[name] || '').trim();
+                if (!raw) {
+                    continue;
+                }
+                const parsed = Number(raw);
+                if (Number.isFinite(parsed) && parsed > 0) {
+                    return parsed;
+                }
+            }
+            return fallback;
+        };
+        const idleTimeoutMs = readTimeoutMs(['ROUTECODEX_HTTP_SSE_IDLE_TIMEOUT_MS', 'RCC_HTTP_SSE_IDLE_TIMEOUT_MS'], DEFAULT_TIMEOUTS.HTTP_SSE_IDLE_MS);
+        const totalTimeoutMs = readTimeoutMs(['ROUTECODEX_HTTP_SSE_TIMEOUT_MS', 'RCC_HTTP_SSE_TIMEOUT_MS'], DEFAULT_TIMEOUTS.HTTP_SSE_TOTAL_MS);
+        const keepaliveMs = readTimeoutMs(['ROUTECODEX_HTTP_SSE_KEEPALIVE_MS', 'RCC_HTTP_SSE_KEEPALIVE_MS'], 15_000);
+        const clearTimers = () => {
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = null;
+            }
+            if (totalTimer) {
+                clearTimeout(totalTimer);
+                totalTimer = null;
+            }
+            if (keepaliveTimer) {
+                clearInterval(keepaliveTimer);
+                keepaliveTimer = null;
+            }
+        };
+        const endWithSseError = (code, message) => {
+            if (ended) {
+                return;
+            }
+            ended = true;
+            clearTimers();
+            logPipelineStage('response.sse.stream.timeout', requestLabel, { code, message });
+            try {
+                const payload = { type: 'error', status: 504, error: { message, code } };
+                res.write(`event: error\ndata: ${JSON.stringify(payload)}\n\n`);
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                res.end();
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                stream.destroy?.(Object.assign(new Error(message), { code }));
+            }
+            catch {
+                /* ignore */
+            }
+        };
+        const resetIdle = () => {
+            if (!Number.isFinite(idleTimeoutMs) || idleTimeoutMs <= 0) {
+                return;
+            }
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+            }
+            idleTimer = setTimeout(() => {
+                endWithSseError('HTTP_SSE_IDLE_TIMEOUT', `SSE idle timeout after ${idleTimeoutMs}ms`);
+            }, idleTimeoutMs);
+            idleTimer.unref?.();
+        };
+        if (Number.isFinite(totalTimeoutMs) && totalTimeoutMs > 0) {
+            totalTimer = setTimeout(() => {
+                endWithSseError('HTTP_SSE_TIMEOUT', `SSE timeout after ${totalTimeoutMs}ms`);
+            }, totalTimeoutMs);
+            totalTimer.unref?.();
+        }
+        resetIdle();
+        // Keep-alive: send SSE comments periodically so clients don't treat long servertool holds as a dead connection.
+        // Comment frames (": ...") are ignored by SSE parsers and safe across OpenAI/Anthropic streams.
+        if (Number.isFinite(keepaliveMs) && keepaliveMs > 0) {
+            keepaliveTimer = setInterval(() => {
+                if (ended) {
+                    return;
+                }
+                try {
+                    res.write(`: keepalive\n\n`);
+                    resetIdle();
+                }
+                catch {
+                    // ignore write failures; close handler will clean up
+                }
+            }, keepaliveMs);
+            keepaliveTimer.unref?.();
+        }
+        const cleanup = () => {
+            clearTimers();
+            try {
+                stream.destroy?.();
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+            logPipelineStage('response.sse.stream.end', requestLabel, { events: eventCount, status });
+        };
+        stream.on('error', (error) => {
+            ended = true;
+            clearTimers();
+            logPipelineStage('response.sse.stream.error', requestLabel, { message: error.message });
+            try {
+                const payload = {
+                    type: 'error',
+                    status: 500,
+                    error: {
+                        message: error.message,
+                        code: 'sse_stream_error',
+                        request_id: requestLabel
+                    }
+                };
+                res.write(`event: error\ndata: ${JSON.stringify(payload)}\n\n`);
+            }
+            catch {
+                /* ignore write errors */
+            }
+            try {
+                res.end();
+            }
+            catch {
+                /* ignore end errors */
+            }
+        });
+        stream.on('data', () => {
+            eventCount++;
+            resetIdle();
+        });
+        res.on('close', cleanup);
+        res.on('finish', cleanup);
+        outboundStream.pipe(res);
+        return;
+    }
+    applyHeaders(res, result.headers, false);
+    if (body === undefined || body === null) {
+        logPipelineStage('response.json.empty', requestLabel, { status });
+        if (captureClientResponse) {
+            void writeServerSnapshot({
+                phase: 'client-response',
+                requestId: requestLabel,
+                entryEndpoint,
+                data: { status, headers: result.headers, body: null }
+            }).catch(() => { });
+        }
+        res.status(status).end();
+        logPipelineStage('response.json.completed', requestLabel, { status });
+        return;
+    }
+    logPipelineStage('response.json.write', requestLabel, { status });
+    // E1 boundary rule: internal env variables use "__*" and must never reach client payloads.
+    // Preserve the SSE carrier key (it is handled above and never JSON-encoded).
+    const sanitized = stripInternalKeysDeep(body, { preserveKeys: new Set(['__sse_responses']) });
+    if (captureClientResponse) {
+        void writeServerSnapshot({
+            phase: 'client-response',
+            requestId: requestLabel,
+            entryEndpoint,
+            data: { status, headers: result.headers, body: sanitized }
+        }).catch(() => { });
+    }
+    res.status(status).json(sanitized);
+    logPipelineStage('response.json.completed', requestLabel, { status });
+}
+function applyHeaders(res, headers, omitContentType) {
+    if (!headers) {
+        return;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value !== 'string') {
+            continue;
+        }
+        const normalized = key.toLowerCase();
+        if (BLOCKED_HEADERS.has(normalized)) {
+            continue;
+        }
+        if (omitContentType && normalized === 'content-type') {
+            continue;
+        }
+        res.setHeader(key, value);
+    }
+}
+function toNodeReadable(streamLike) {
+    if (!streamLike) {
+        return null;
+    }
+    if (streamLike instanceof Readable) {
+        return streamLike;
+    }
+    const pipeCandidate = streamLike;
+    if (pipeCandidate && typeof pipeCandidate.pipe === 'function') {
+        return streamLike;
+    }
+    const webCandidate = streamLike;
+    if (webCandidate && typeof webCandidate.getReader === 'function') {
+        try {
+            return Readable.fromWeb(streamLike);
+        }
+        catch {
+            return null;
+        }
+    }
+    const asyncIterable = streamLike;
+    if (asyncIterable && typeof asyncIterable[Symbol.asyncIterator] === 'function') {
+        return Readable.from(streamLike);
+    }
+    return null;
+}
+function shouldCaptureClientStreamSnapshots() {
+    if (!isAnalysisModeEnabled()) {
+        return false;
+    }
+    const flag = String(process.env.ROUTECODEX_CAPTURE_STREAM_SNAPSHOTS || '').trim().toLowerCase();
+    if (flag === '1' || flag === 'true') {
+        return true;
+    }
+    if (flag === '0' || flag === 'false') {
+        return false;
+    }
+    return false;
+}
+function resolveClientStreamSnapshotMaxBytes() {
+    const raw = String(process.env.ROUTECODEX_CLIENT_STREAM_SNAPSHOT_MAX_BYTES ||
+        process.env.RCC_CLIENT_STREAM_SNAPSHOT_MAX_BYTES ||
+        '2000000').trim();
+    const parsed = Number(raw);
+    if (!raw) {
+        return 2_000_000;
+    }
+    if (Number.isFinite(parsed) && parsed >= 0) {
+        return Math.floor(parsed);
+    }
+    return 2_000_000;
+}
+function maybeAttachClientSseSnapshotStream(stream, options) {
+    if (!shouldCaptureClientStreamSnapshots()) {
+        return stream;
+    }
+    const maxBytes = resolveClientStreamSnapshotMaxBytes();
+    if (maxBytes <= 0) {
+        return stream;
+    }
+    const tee = new PassThrough();
+    const capture = new PassThrough();
+    stream.pipe(tee);
+    stream.pipe(capture);
+    const chunks = [];
+    let size = 0;
+    let truncated = false;
+    let flushed = false;
+    const toBuffer = (chunk) => {
+        if (Buffer.isBuffer(chunk)) {
+            return chunk;
+        }
+        if (chunk instanceof Uint8Array) {
+            return Buffer.from(chunk);
+        }
+        if (typeof chunk === 'string') {
+            return Buffer.from(chunk, 'utf8');
+        }
+        if (chunk === undefined || chunk === null) {
+            return Buffer.alloc(0);
+        }
+        return Buffer.from(String(chunk), 'utf8');
+    };
+    const flushSnapshot = (error) => {
+        if (flushed) {
+            return;
+        }
+        flushed = true;
+        try {
+            stream.unpipe(capture);
+        }
+        catch {
+            /* ignore */
+        }
+        capture.removeAllListeners();
+        const raw = chunks.length ? Buffer.concat(chunks).toString('utf8') : '';
+        const payload = {
+            mode: 'sse',
+            status: options.status,
+            headers: options.headers,
+            raw: raw || undefined,
+            truncated: truncated || undefined,
+            maxBytes
+        };
+        if (error) {
+            payload.error = error instanceof Error ? error.message : String(error);
+        }
+        void writeServerSnapshot({
+            phase: 'client-response',
+            requestId: options.requestId,
+            entryEndpoint: options.entryEndpoint,
+            data: payload
+        }).catch(() => { });
+    };
+    capture.on('data', (chunk) => {
+        const buf = toBuffer(chunk);
+        if (buf.length === 0) {
+            return;
+        }
+        if (truncated || size >= maxBytes) {
+            truncated = true;
+            return;
+        }
+        const remaining = maxBytes - size;
+        if (buf.length <= remaining) {
+            chunks.push(buf);
+            size += buf.length;
+            return;
+        }
+        if (remaining > 0) {
+            chunks.push(buf.slice(0, remaining));
+            size += remaining;
+        }
+        truncated = true;
+    });
+    capture.on('end', () => flushSnapshot());
+    capture.on('close', () => flushSnapshot());
+    capture.on('error', (error) => flushSnapshot(error));
+    stream.on('error', (error) => {
+        flushSnapshot(error);
+        try {
+            tee.destroy(error);
+        }
+        catch {
+            tee.destroy();
+        }
+    });
+    tee.on('error', (error) => flushSnapshot(error));
+    return tee;
+}
+//# sourceMappingURL=handler-response-utils.js.map