}

}

async function waitForReady(params) {

export async function waitForReady(params) {

const started = Date.now();

let lastError = "";

const readyLogSeen = createReadyLogScanner(params.logPath);

while (Date.now() - started < READY_TIMEOUT_MS) {

const remainingMs = Math.max(1, READY_TIMEOUT_MS - (Date.now() - started));

if (hasChildExited(params.child)) {

throw new Error(`gateway exited before ready\n${tailFile(params.logPath)}`);

}

try {

const res = await fetchHttpProbeStatus(params.port, "/readyz");

const res = await fetchHttpProbeStatus(params.port, "/readyz", {

timeoutMs: Math.min(HTTP_PROBE_TIMEOUT_MS, remainingMs),

});

if (res.ok) {

return;

}

lastError = `readyz status ${res.status}`;

} catch (error) {

lastError = error instanceof Error ? error.message : String(error);

}

if (readyLogSeen() && (await httpOk(params.port, "/healthz"))) {

const healthRemainingMs = Math.max(1, READY_TIMEOUT_MS - (Date.now() - started));

if (

readyLogSeen() &&

(await httpOk(params.port, "/healthz", {

timeoutMs: Math.min(HTTP_PROBE_TIMEOUT_MS, healthRemainingMs),

}))

) {

return;

}

await delay(250);

await delay(Math.min(250, Math.max(1, READY_TIMEOUT_MS - (Date.now() - started))));

}

throw new Error(`gateway did not become ready: ${lastError}\n${tailFile(params.logPath)}`);

}

}

});

it("keeps stalled runtime readiness probes inside the ready deadline", async () => {

const runtimeSmoke = await importRuntimeSmokeWithEnv({

OPENCLAW_BUNDLED_PLUGIN_RUNTIME_HTTP_MS: "1000",

OPENCLAW_BUNDLED_PLUGIN_RUNTIME_READY_MS: "50",

});

const sockets = new Set<Socket>();

const server = createNetServer((socket) => {

sockets.add(socket);

socket.on("close", () => {

sockets.delete(socket);

});

});

const root = makePackageRoot();

const logPath = path.join(root, "gateway.log");

fs.writeFileSync(logPath, "booting\n", "utf8");

try {

const port = await listenOnLoopback(server);

const startedAt = Date.now();

await expect(

runtimeSmoke.waitForReady({

child: { exitCode: null, signalCode: null },

logPath,

port,

}),

).rejects.toThrow("gateway did not become ready");

expect(Date.now() - startedAt).toBeLessThan(500);

} finally {

for (const socket of sockets) {

socket.destroy();

}

await closeServer(server);

}

});

it("creates runtime smoke state with OPENCLAW_HOME at the test home", async () => {

const runtimeSmoke = await import(pathToFileURL(runtimeSmokePath).href);

const env = runtimeSmoke.createIsolatedStateEnv("runtime-env");