const GATEWAY_CONNECT_STATUS_TIMEOUT_MS = 10_000;

const GATEWAY_NODE_STATUS_TIMEOUT_MS = 15_000;

const GATEWAY_NODE_STATUS_POLL_MS = 20;

const POST_JSON_TIMEOUT_MS = 15_000;

const POST_JSON_MAX_RESPONSE_BYTES = 1024 * 1024;

export type PostJsonOptions = {

maxResponseBytes?: number;

timeoutMs?: number;

};

export async function spawnGatewayInstance(name: string): Promise<GatewayInstance> {

const inst = await createOpenClawTestInstance({ name });

url: string,

body: unknown,

headers?: Record<string, string>,

options: PostJsonOptions = {},

): Promise<{ status: number; json: unknown }> {

const payload = JSON.stringify(body);

const parsed = new URL(url);

const timeoutMs = options.timeoutMs ?? POST_JSON_TIMEOUT_MS;

const maxResponseBytes = options.maxResponseBytes ?? POST_JSON_MAX_RESPONSE_BYTES;

return await new Promise<{ status: number; json: unknown }>((resolve, reject) => {

let settled = false;

let responseBytes = 0;

let timeout: NodeJS.Timeout | undefined;

const finish = (result: { status: number; json: unknown } | { error: Error }) => {

if (settled) {

return;

}

settled = true;

if (timeout) {

clearTimeout(timeout);

}

if ("error" in result) {

reject(result.error);

return;

}

resolve(result);

};

const req = httpRequest(

{

method: "POST",

let data = "";

res.setEncoding("utf8");

res.on("data", (chunk) => {

responseBytes += Buffer.byteLength(chunk, "utf8");

if (responseBytes > maxResponseBytes) {

const error = new Error(`POST ${url} response exceeded ${maxResponseBytes} bytes`);

req.destroy(error);

res.destroy(error);

finish({ error });

return;

}

data += chunk;

});

res.on("end", () => {

json = data;

}

}

resolve({ status: res.statusCode ?? 0, json });

finish({ status: res.statusCode ?? 0, json });

});

res.on("error", (error) => finish({ error }));

},

);

req.on("error", reject);

timeout = setTimeout(() => {

req.destroy(new Error(`POST ${url} timed out after ${timeoutMs}ms`));

}, timeoutMs);

timeout.unref?.();

req.on("error", (error) => finish({ error }));

req.write(payload);

req.end();

});