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

import { createConfigReloadLogScanner } from "./log-scanner.mjs";

const logPath = process.env.OPENCLAW_CONFIG_RELOAD_LOG_PATH ?? "/tmp/config-reload-e2e.log";

const deadlineMs = Date.now() + Number(process.env.OPENCLAW_CONFIG_RELOAD_LOG_TIMEOUT_MS ?? 30_000);

const maxReadBytes = Number.parseInt(

process.env.OPENCLAW_CONFIG_RELOAD_LOG_MAX_READ_BYTES ?? `${256 * 1024}`,

10,

);

const deadlineMs = Date.now() + readPositiveIntEnv("OPENCLAW_CONFIG_RELOAD_LOG_TIMEOUT_MS", 30_000);

const maxReadBytes = readPositiveIntEnv("OPENCLAW_CONFIG_RELOAD_LOG_MAX_READ_BYTES", 256 * 1024);

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const scanner = createConfigReloadLogScanner(logPath, {

maxReadBytes: Number.isSafeInteger(maxReadBytes) && maxReadBytes > 0 ? maxReadBytes : 256 * 1024,

maxReadBytes,

tailLineLimit: 160,

});

let result = { reloadLines: [], restartLines: [], tailLines: [] };

import fs from "node:fs";

import http from "node:http";

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

const port = Number(process.env.MOCK_PORT);

const port = readPositiveIntEnv("MOCK_PORT");

const requestLog = process.env.MOCK_REQUEST_LOG;

const successMarker = process.env.SUCCESS_MARKER;

const rawSchemaError = process.env.RAW_SCHEMA_ERROR;

import fs from "node:fs";

import http from "node:http";

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

const port = Number(process.env.MOCK_PORT ?? process.env.OPENCLAW_MOCK_OPENAI_PORT);

const port =

process.env.MOCK_PORT != null

? readPositiveIntEnv("MOCK_PORT")

: readPositiveIntEnv("OPENCLAW_MOCK_OPENAI_PORT");

const successMarker = process.env.SUCCESS_MARKER ?? "OPENCLAW_E2E_OK";

const requestLog = process.env.MOCK_REQUEST_LOG;

if (!Number.isInteger(port) || port <= 0) {

throw new Error("missing valid MOCK_PORT or OPENCLAW_MOCK_OPENAI_PORT");

}

function readBody(req) {

return new Promise((resolve, reject) => {

let body = "";

import { spawnSync } from "node:child_process";

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

const mockOpenAiPath = "scripts/e2e/mock-openai-server.mjs";

const webSearchMockPath = "scripts/e2e/lib/openai-web-search-minimal/mock-server.mjs";

const configReloadAssertPath = "scripts/e2e/lib/config-reload/assert-log.mjs";

const scrubbedEnvKeys = [

"MOCK_PORT",

"MOCK_REQUEST_LOG",

"OPENCLAW_CONFIG_RELOAD_LOG_MAX_READ_BYTES",

"OPENCLAW_CONFIG_RELOAD_LOG_PATH",

"OPENCLAW_CONFIG_RELOAD_LOG_TIMEOUT_MS",

"OPENCLAW_MOCK_OPENAI_PORT",

"RAW_SCHEMA_ERROR",

"SUCCESS_MARKER",

];

function runScript(scriptPath: string, env: Record<string, string>) {

const childEnv = { ...process.env };

for (const key of scrubbedEnvKeys) {

delete childEnv[key];

}

return spawnSync(process.execPath, [scriptPath], {

encoding: "utf8",

env: { ...childEnv, ...env },

killSignal: "SIGKILL",

timeout: 3_000,

});

}

describe("e2e mock and config helper numeric limits", () => {

it("rejects loose mock OpenAI port env values", () => {

const mockPort = runScript(mockOpenAiPath, { MOCK_PORT: "44080tcp" });

expect(mockPort.status).not.toBe(0);

expect(mockPort.stderr).toContain("invalid MOCK_PORT: 44080tcp");

const fallbackPort = runScript(mockOpenAiPath, {

OPENCLAW_MOCK_OPENAI_PORT: "44080http",

});

expect(fallbackPort.status).not.toBe(0);

expect(fallbackPort.stderr).toContain("invalid OPENCLAW_MOCK_OPENAI_PORT: 44080http");

});

it("rejects loose OpenAI web-search mock port env values", () => {

const result = runScript(webSearchMockPath, { MOCK_PORT: "80http" });

expect(result.status).not.toBe(0);

expect(result.stderr).toContain("invalid MOCK_PORT: 80http");

});

it("rejects loose config-reload log timeout env values", () => {

const result = runScript(configReloadAssertPath, {

OPENCLAW_CONFIG_RELOAD_LOG_TIMEOUT_MS: "30000ms",

});

expect(result.status).not.toBe(0);

expect(result.stderr).toContain("invalid OPENCLAW_CONFIG_RELOAD_LOG_TIMEOUT_MS: 30000ms");

});

it("rejects loose config-reload log read caps", () => {

const result = runScript(configReloadAssertPath, {

OPENCLAW_CONFIG_RELOAD_LOG_MAX_READ_BYTES: "256kb",

});

expect(result.status).not.toBe(0);

expect(result.stderr).toContain("invalid OPENCLAW_CONFIG_RELOAD_LOG_MAX_READ_BYTES: 256kb");

});

});