redactForDevToolLog,

redactHomePath,

} from "../lib/dev-tooling-safety.ts";

import { readBoundedResponseText } from "../lib/bounded-response.ts";

function writeStdoutLine(message: string): void {

process.stdout.write(`${message}\n`);

const DISCORD_API_BASE = "https://discord.com/api/v10";

const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;

const DEFAULT_OPENCLAW_CLI_TIMEOUT_MS = 60_000;

const DISCORD_RESPONSE_BODY_MAX_BYTES = 1024 * 1024;

const WEBHOOK_CLEANUP_TIMEOUT_MS = 10_000;

function sleep(ms: number): Promise<void> {

return parseStrictIntegerOption({ fallback, label, min: 1, raw: value });

}

function createDiscordResponseTooLargeError(message: string): Error {

const error = new Error(message);

(error as NodeJS.ErrnoException).code = "ETOOBIG";

return error;

}

function isTooLargeError(error: unknown): boolean {

return (error as NodeJS.ErrnoException | undefined)?.code === "ETOOBIG";

}

async function readDiscordResponseText(params: {

response: Response;

label: string;

signal: AbortSignal;

maxBytes: number;

}): Promise<string> {

return await readBoundedResponseText(params.response, params.label, params.maxBytes, {

createTooLargeError: createDiscordResponseTooLargeError,

signal: params.signal,

});

}

async function readDiscordResponseJson(params: {

response: Response;

label: string;

signal: AbortSignal;

maxBytes: number;

}): Promise<unknown> {

const text = await readDiscordResponseText(params);

if (!text) {

return {};

}

return JSON.parse(text);

}

function resolveStateDir(): string {

const override = process.env.OPENCLAW_STATE_DIR?.trim();

if (override) {

retries?: number;

timeoutMs?: number;

errorPrefix: string;

responseBodyMaxBytes?: number;

fetchImpl?: typeof fetch;

sleepImpl?: (ms: number) => Promise<void>;

}): Promise<T> {

const retries = params.retries ?? 6;

const fetchImpl = params.fetchImpl ?? fetch;

const sleepImpl = params.sleepImpl ?? sleep;

const responseBodyMaxBytes = params.responseBodyMaxBytes ?? DISCORD_RESPONSE_BODY_MAX_BYTES;

const deadlineMs = Date.now() + (params.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);

const timeoutError = () =>

new Error(

if (response.status === 429) {

const bodyTimeoutMs = remainingTimeoutMs(deadlineMs);

const body = (await withTimeout({

operation: response.json().catch(() => ({})),

operation: readDiscordResponseJson({

response,

label: `${params.errorPrefix} ${params.method} ${redactDiscordApiPath(params.path)}`,

signal: controller.signal,

maxBytes: responseBodyMaxBytes,

}).catch((error) => {

if (isTooLargeError(error)) {

throw error;

}

return {};

}),

timeoutMs: bodyTimeoutMs,

timeoutError,

onTimeout: () => controller.abort(),

if (!response.ok) {

const bodyTimeoutMs = remainingTimeoutMs(deadlineMs);

const text = await withTimeout({

operation: response.text().catch(() => ""),

operation: readDiscordResponseText({

response,

label: `${params.errorPrefix} ${params.method} ${redactDiscordApiPath(params.path)}`,

signal: controller.signal,

maxBytes: responseBodyMaxBytes,

}),

timeoutMs: bodyTimeoutMs,

timeoutError,

onTimeout: () => controller.abort(),

const bodyTimeoutMs = remainingTimeoutMs(deadlineMs);

return (await withTimeout({

operation: response.json(),

operation: readDiscordResponseJson({

response,

label: `${params.errorPrefix} ${params.method} ${redactDiscordApiPath(params.path)}`,

signal: controller.signal,

maxBytes: responseBodyMaxBytes,

}),

timeoutMs: bodyTimeoutMs,

timeoutError,

onTimeout: () => controller.abort(),

export const testing = {

parseDriverMode,

parseNumber,

DISCORD_RESPONSE_BODY_MAX_BYTES,

redactDiscordApiPath,

readDiscordResponseText,

remainingTimeoutMs,

requestDiscordJson,

resolveStateDir,