import { readPositiveIntEnv } from "./lib/env-limits.mjs";

export type McpChannelLimits = {

connectTimeoutMs: number;

gatewayEventRetainLimit: number;

rawMessageRetainLimit: number;

};

export function readMcpChannelLimits(env: NodeJS.ProcessEnv = process.env): McpChannelLimits {

return {

connectTimeoutMs: readPositiveIntEnv("OPENCLAW_MCP_CHANNELS_CONNECT_TIMEOUT_MS", 60_000, env),

gatewayEventRetainLimit: readPositiveIntEnv(

"OPENCLAW_MCP_CHANNELS_GATEWAY_EVENT_RETAIN_LIMIT",

2_000,

env,

),

rawMessageRetainLimit: readPositiveIntEnv(

"OPENCLAW_MCP_CHANNELS_RAW_MESSAGE_RETAIN_LIMIT",

2_000,

env,

),

};

}

import { formatErrorMessage } from "../../dist/infra/errors.js";

import { rawDataToString } from "../../dist/infra/ws.js";

import { readStringValue } from "../../dist/shared/string-coerce.js";

import { readMcpChannelLimits } from "./mcp-channel-limits.ts";

import { connectMcpWithTimeout } from "./mcp-connect-timeout.ts";

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

const GATEWAY_RPC_TIMEOUT_MS = 60_000;

const GATEWAY_REQUEST_TIMEOUT_MS = 45_000;

const GATEWAY_CONNECT_RETRY_WINDOW_MS = 420_000;

const MCP_CONNECT_TIMEOUT_MS = readPositiveInt(

process.env.OPENCLAW_MCP_CHANNELS_CONNECT_TIMEOUT_MS,

60_000,

);

const GATEWAY_EVENT_RETAIN_LIMIT = readPositiveInt(

process.env.OPENCLAW_MCP_CHANNELS_GATEWAY_EVENT_RETAIN_LIMIT,

2_000,

);

const MCP_RAW_MESSAGE_RETAIN_LIMIT = readPositiveInt(

process.env.OPENCLAW_MCP_CHANNELS_RAW_MESSAGE_RETAIN_LIMIT,

2_000,

);

const MCP_CHANNEL_LIMITS = readMcpChannelLimits();

const MCP_CONNECT_TIMEOUT_MS = MCP_CHANNEL_LIMITS.connectTimeoutMs;

const GATEWAY_EVENT_RETAIN_LIMIT = MCP_CHANNEL_LIMITS.gatewayEventRetainLimit;

const MCP_RAW_MESSAGE_RETAIN_LIMIT = MCP_CHANNEL_LIMITS.rawMessageRetainLimit;

export function assert(condition: unknown, message: string): asserts condition {

if (!condition) {

throw new Error(message);

}

}

function readPositiveInt(raw: string | undefined, fallback: number) {

const parsed = Number.parseInt(raw ?? "", 10);

return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;

}

function pushBounded<T>(items: T[], item: T, limit: number): void {

items.push(item);

if (items.length > limit) {

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

import { readMcpChannelLimits } from "../../scripts/e2e/mcp-channel-limits.ts";

describe("MCP channel E2E limits", () => {

it("uses documented defaults when env overrides are absent", () => {

expect(readMcpChannelLimits({})).toEqual({

connectTimeoutMs: 60_000,

gatewayEventRetainLimit: 2_000,

rawMessageRetainLimit: 2_000,

});

});

it("accepts strict positive integer overrides", () => {

expect(

readMcpChannelLimits({

OPENCLAW_MCP_CHANNELS_CONNECT_TIMEOUT_MS: "120000",

OPENCLAW_MCP_CHANNELS_GATEWAY_EVENT_RETAIN_LIMIT: "500",

OPENCLAW_MCP_CHANNELS_RAW_MESSAGE_RETAIN_LIMIT: "25",

}),

).toEqual({

connectTimeoutMs: 120_000,

gatewayEventRetainLimit: 500,

rawMessageRetainLimit: 25,

});

});

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

expect(() =>

readMcpChannelLimits({

OPENCLAW_MCP_CHANNELS_CONNECT_TIMEOUT_MS: "1e3",

}),

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

expect(() =>

readMcpChannelLimits({

OPENCLAW_MCP_CHANNELS_RAW_MESSAGE_RETAIN_LIMIT: "1000ms",

}),

).toThrow("invalid OPENCLAW_MCP_CHANNELS_RAW_MESSAGE_RETAIN_LIMIT: 1000ms");

});

});