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

import { probeLocalCommand } from "./probes.js";

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

import { probeGatewayUrl, probeLocalCommand } from "./probes.js";

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

describe("crestodian probes", () => {

afterEach(() => {

vi.restoreAllMocks();

});

it("bounds noisy local command probe output", async () => {

const result = await probeLocalCommand(

process.execPath,

expect(Date.now() - startedAt).toBeLessThan(2_000);

},

);

it("caps oversized gateway probe timeouts before scheduling", async () => {

const timeoutSpy = vi

.spyOn(globalThis, "setTimeout")

.mockReturnValue(1 as unknown as ReturnType<typeof setTimeout>);

vi.spyOn(globalThis, "clearTimeout").mockImplementation(() => undefined);

vi.stubGlobal(

"fetch",

vi.fn(async () => new Response("ok", { status: 200 })),

);

await expect(

probeGatewayUrl("ws://127.0.0.1:1234", { timeoutMs: MAX_TIMER_TIMEOUT_MS + 1_000_000 }),

).resolves.toMatchObject({ reachable: true });

expect(timeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

});

});

import { spawn } from "node:child_process";

import { resolveTimerTimeoutMs } from "../shared/number-coercion.js";

export type LocalCommandProbe = {

command: string;

args: string[] = ["--version"],

opts: { outputLimit?: number; timeoutKillGraceMs?: number; timeoutMs?: number } = {},

): Promise<LocalCommandProbe> {

const timeoutMs = opts.timeoutMs ?? 1_500;

const timeoutMs = resolveTimerTimeoutMs(opts.timeoutMs, 1_500);

const outputLimit = opts.outputLimit ?? LOCAL_COMMAND_PROBE_OUTPUT_MAX_CHARS;

const timeoutKillGraceMs = opts.timeoutKillGraceMs ?? LOCAL_COMMAND_PROBE_KILL_GRACE_MS;

const timeoutKillGraceMs = resolveTimerTimeoutMs(

opts.timeoutKillGraceMs,

LOCAL_COMMAND_PROBE_KILL_GRACE_MS,

0,

);

return await new Promise((resolve) => {

let stdout = "";

let stderr = "";

const timer = setTimeout(() => {

timedOut = true;

child.kill("SIGTERM");

killTimer = setTimeout(

() => {

child.kill("SIGKILL");

child.stdout.destroy();

child.stderr.destroy();

finish(timeoutResult());

},

Math.max(0, timeoutKillGraceMs),

);

killTimer = setTimeout(() => {

child.kill("SIGKILL");

child.stdout.destroy();

child.stderr.destroy();

finish(timeoutResult());

}, timeoutKillGraceMs);

killTimer.unref?.();

}, timeoutMs);

child.stdout.setEncoding("utf8");

): Promise<{ reachable: boolean; url: string; error?: string }> {

const httpUrl = url.replace(/^ws:/, "http:").replace(/^wss:/, "https:");

const healthUrl = new URL("/healthz", httpUrl).toString();

const timeoutMs = resolveTimerTimeoutMs(opts.timeoutMs, 900);

const controller = new AbortController();

const timeout = setTimeout(() => controller.abort(), opts.timeoutMs ?? 900);

const timeout = setTimeout(() => controller.abort(), timeoutMs);

try {

const response = await fetch(healthUrl, {

method: "GET",