import { WebSocket } from "ws";

import { PROTOCOL_VERSION } from "../../../../dist/gateway/protocol/index.js";

import { readGatewayNetworkClientConnectTimeoutMs } from "./limits.mjs";

import { waitForWebSocketOpen } from "./open-websocket.mjs";

const url = process.env.GW_URL;

throw new Error("missing GW_URL/GW_TOKEN");

}

const deadlineMs = Number.parseInt(

process.env.OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS ??

process.env.OPENCLAW_GATEWAY_NETWORK_CONNECT_READY_TIMEOUT_MS ??

"80000",

10,

);

if (!Number.isFinite(deadlineMs) || deadlineMs < 0) {

throw new Error(`invalid gateway network client timeout: ${String(deadlineMs)}`);

}

const deadline = Date.now() + Math.max(1_000, deadlineMs);

const deadline = Date.now() + readGatewayNetworkClientConnectTimeoutMs();

function delay(ms) {

return new Promise((resolve) => setTimeout(resolve, ms));

function readPositiveIntEnv(name, fallback, env) {

const text = String(env[name] ?? fallback).trim();

if (!/^\d+$/u.test(text)) {

throw new Error(`invalid ${name}: ${text}`);

}

const value = Number(text);

if (!Number.isSafeInteger(value) || value <= 0) {

throw new Error(`invalid ${name}: ${text}`);

}

return value;

}

export function readGatewayNetworkClientConnectTimeoutMs(env = process.env) {

if (env.OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS != null) {

return readPositiveIntEnv("OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS", 80000, env);

}

return readPositiveIntEnv("OPENCLAW_GATEWAY_NETWORK_CONNECT_READY_TIMEOUT_MS", 80000, env);

}

import { EventEmitter } from "node:events";

import { describe, expect, it } from "vitest";

import { readGatewayNetworkClientConnectTimeoutMs } from "../../scripts/e2e/lib/gateway-network/limits.mjs";

import { waitForWebSocketOpen } from "../../scripts/e2e/lib/gateway-network/open-websocket.mjs";

class FakeWebSocket extends EventEmitter {

}

describe("gateway network WebSocket open guard", () => {

it("rejects loose client timeout env values instead of parsing prefixes", () => {

expect(() =>

readGatewayNetworkClientConnectTimeoutMs({

OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS: "100ms",

}),

).toThrow("invalid OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS: 100ms");

expect(() =>

readGatewayNetworkClientConnectTimeoutMs({

OPENCLAW_GATEWAY_NETWORK_CONNECT_READY_TIMEOUT_MS: "1e3",

}),

).toThrow("invalid OPENCLAW_GATEWAY_NETWORK_CONNECT_READY_TIMEOUT_MS: 1e3");

expect(() =>

readGatewayNetworkClientConnectTimeoutMs({

OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS: "0",

}),

).toThrow("invalid OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS: 0");

});

it("prefers the explicit client timeout over the connect-ready fallback", () => {

expect(

readGatewayNetworkClientConnectTimeoutMs({

OPENCLAW_GATEWAY_NETWORK_CLIENT_CONNECT_TIMEOUT_MS: "5000",

OPENCLAW_GATEWAY_NETWORK_CONNECT_READY_TIMEOUT_MS: "1000",

}),

).toBe(5000);

expect(

readGatewayNetworkClientConnectTimeoutMs({

OPENCLAW_GATEWAY_NETWORK_CONNECT_READY_TIMEOUT_MS: "3000",

}),

).toBe(3000);

});

it("consumes abort errors after open timeouts", async () => {

const ws = new FakeWebSocket();

const keepAlive = setTimeout(() => {}, 100);