registerManagedProxyBrowserCdpBypass: registerManagedProxyBrowserCdpBypassMock,

}));

const ensurePortAvailableMock = vi.hoisted(() => vi.fn(async () => {}));

const ensurePortAvailableMock = vi.hoisted(() =>

vi.fn<(port: number, host?: string) => Promise<void>>(async () => {}),

);

vi.mock("../infra/ports.js", () => ({

ensurePortAvailable: ensurePortAvailableMock,

color: "#FF4500",

cdpPort,

cdpUrl: `http://127.0.0.1:${cdpPort}`,

cdpHost: "127.0.0.1",

cdpIsLoopback: true,

}) as unknown as ResolvedBrowserProfile;

await expect(launchOpenClawChrome(makeResolved(), profile)).rejects.toThrow(

/No supported browser found/,

);

expect(ensurePortAvailableMock).toHaveBeenCalledWith(51111, "127.0.0.1");

});

it.each([

{ cdpUrl: "http://[::1]:51111", configuredProbeHost: "::1" },

{ cdpUrl: "http://localhost:51111", configuredProbeHost: "localhost" },

])(

"checks Chrome's IPv4 bind and the configured $configuredProbeHost endpoint",

async ({ cdpUrl, configuredProbeHost }) => {

vi.spyOn(fs, "existsSync").mockReturnValue(false);

const portBusy = new Error("Port is already in use.");

portBusy.name = "PortInUseError";

ensurePortAvailableMock.mockImplementation(async (_port, host) => {

if (host === configuredProbeHost) {

throw portBusy;

}

});

const profile = { ...makeProfile(51111), cdpUrl };

await expect(launchOpenClawChrome(makeResolved(), profile)).rejects.toThrow(portBusy);

expect(ensurePortAvailableMock.mock.calls).toEqual([

[51111, "127.0.0.1"],

[51111, configuredProbeHost],

]);

},

);

it("completes successfully when Chrome reports /json/version and CDP is reachable", async () => {

// Mock executable discovery to a truthy path.

vi.spyOn(fs, "existsSync").mockImplementation((p) => {

profile: ResolvedBrowserProfile,

userDataDir: string,

): Promise<void> {

const configuredHost = new URL(profile.cdpUrl).hostname.replace(/^\[|\]$/g, "");

const probeHosts =

configuredHost === "127.0.0.1" ? [configuredHost] : ["127.0.0.1", configuredHost];

const ensureProbeHostsAvailable = async () => {

for (const host of probeHosts) {

await ensurePortAvailable(profile.cdpPort, host);

}

};

// Chromium tries IPv4 loopback first, while OpenClaw polls the configured endpoint.

// Probe both so neither Chrome's bind nor the later readiness check can be captured.

try {

await ensurePortAvailable(profile.cdpPort);

await ensureProbeHostsAvailable();

return;

} catch (err) {

const exe = resolveBrowserExecutable(resolved, profile);

throw err;

}

}

await ensurePortAvailable(profile.cdpPort);

await ensureProbeHostsAvailable();

}

function chromeLaunchHints(params: {

});

});

it("ensurePortAvailable rejects when an explicitly scoped IPv4 loopback is busy", async () => {

const server = net.createServer();

const address = await listenServer(server, 0, "127.0.0.1");

if (!address) {

return;

}

const port = address.port;

await expect(ensurePortAvailable(port, "127.0.0.1")).rejects.toBeInstanceOf(PortInUseError);

await new Promise<void>((resolve) => {

server.close(() => resolve());

});

});

it("handlePortError exits nicely on EADDRINUSE", async () => {

const runtime = {

error: vi.fn(),

return formatPortDiagnostics(diagnostics).join("\n");

}

export async function ensurePortAvailable(port: number): Promise<void> {

/** Probes Node's wildcard bind by default; callers may scope checks to their owned interface. */

export async function ensurePortAvailable(port: number, host?: string): Promise<void> {

// Detect EADDRINUSE early with a friendly message.

try {

await tryListenOnPort({ port });

const probe = host ? { port, host } : { port };

await tryListenOnPort(probe);

} catch (err) {

if (isErrno(err) && err.code === "EADDRINUSE") {

throw new PortInUseError(port);