...(abortPromise ? [abortPromise] : []),

]);

const text = await Promise.race([

readBoundedResponseText(response, maxBodyBytes),

readBoundedResponseText(response, maxBodyBytes, timeoutPromise),

timeoutPromise,

...(abortPromise ? [abortPromise] : []),

]);

throw toLintErrorObject(lastError ?? new Error(`fetch ${url} failed`), "Non-Error thrown");

}

export async function readBoundedResponseText(

response,

byteLimit = resolveKitchenSinkRpcConfig().fetchBodyMaxBytes,

) {

export async function readBoundedResponseText(response, byteLimit, timeoutPromise) {

const resolvedByteLimit = byteLimit ?? resolveKitchenSinkRpcConfig().fetchBodyMaxBytes;

const contentLength = response.headers?.get?.("content-length");

if (contentLength && /^\d+$/u.test(contentLength)) {

const parsedContentLength = Number(contentLength);

if (Number.isSafeInteger(parsedContentLength) && parsedContentLength > byteLimit) {

if (Number.isSafeInteger(parsedContentLength) && parsedContentLength > resolvedByteLimit) {

await response.body?.cancel?.().catch(() => undefined);

throw createFetchBodyTooLargeError(byteLimit);

throw createFetchBodyTooLargeError(resolvedByteLimit);

}

}

const reader = response.body?.getReader?.();

if (!reader) {

const text = await response.text();

if (Buffer.byteLength(text, "utf8") > byteLimit) {

throw createFetchBodyTooLargeError(byteLimit);

const text = await withOptionalTimeout(response.text(), timeoutPromise);

if (Buffer.byteLength(text, "utf8") > resolvedByteLimit) {

throw createFetchBodyTooLargeError(resolvedByteLimit);

}

return text;

}

const chunks = [];

let totalBytes = 0;

for (;;) {

const { done, value } = await reader.read();

const read = reader.read();

const { done, value } = await withOptionalTimeout(

read,

timeoutPromise?.catch((error) => {

cancelReaderSoon(reader);

throw error;

}),

);

if (done) {

break;

}

const chunk = Buffer.from(value);

totalBytes += chunk.byteLength;

if (totalBytes > byteLimit) {

if (totalBytes > resolvedByteLimit) {

await reader.cancel().catch(() => undefined);

throw createFetchBodyTooLargeError(byteLimit);

throw createFetchBodyTooLargeError(resolvedByteLimit);

}

chunks.push(chunk);

}

});

}

async function withOptionalTimeout(promise, timeoutPromise) {

if (!timeoutPromise) {

return await promise;

}

return await Promise.race([promise, timeoutPromise]);

}

function cancelReaderSoon(reader) {

void Promise.resolve()

.then(() => reader.cancel())

.catch(() => undefined);

}

function configureKitchenSink(env, port) {

const configPath = env.OPENCLAW_CONFIG_PATH;

const config = fs.existsSync(configPath) ? readJson(configPath) : {};