import { parseStrictPositiveInteger } from "../../infra/parse-finite-number.js";

import { parseTcpPort } from "../../infra/tcp-port.js";

// TCP/UDP ports are 16-bit, so 65535 is the max. `parseStrictPositiveInteger`

// only enforces positivity, so values like 99999 were returned as-is and

// reached gateway-cli / node-cli bind paths; the OS then surfaced the error

// instead of the CLI rejecting it cleanly at parse time. See #83900.

const MAX_TCP_PORT = 65_535;

export { MAX_TCP_PORT, parseTcpPort } from "../../infra/tcp-port.js";

export function parsePort(raw: unknown): number | null {

if (raw === undefined || raw === null) {

return null;

}

const parsed = parseStrictPositiveInteger(raw);

if (parsed === undefined || parsed > MAX_TCP_PORT) {

return null;

}

return parsed;

return parseTcpPort(raw);

}

expect(cleanStaleGatewayProcessesSync).toHaveBeenCalledWith(19001);

});

it("ignores invalid configured gateway ports for stale cleanup", async () => {

const env = {

...createDefaultLaunchdEnv(),

OPENCLAW_GATEWAY_PORT: "65536",

};

state.files.clear();

await restartLaunchAgent({

env,

stdout: new PassThrough(),

});

expect(cleanStaleGatewayProcessesSync).not.toHaveBeenCalled();

expect(inspectPortUsage).not.toHaveBeenCalled();

});

it("uses the stored LaunchAgent environment port for restart stale cleanup", async () => {

const env = createDefaultLaunchdEnv();

await installLaunchAgent({

expect(inspectPortUsage).toHaveBeenCalledWith(19007);

});

it("ignores invalid stored LaunchAgent environment ports for stale cleanup", async () => {

const env = createDefaultLaunchdEnv();

await installLaunchAgent({

env,

stdout: new PassThrough(),

programArguments: defaultProgramArguments,

environment: { OPENCLAW_GATEWAY_PORT: "65536" },

});

state.launchctlCalls.length = 0;

await restartLaunchAgent({

env,

stdout: new PassThrough(),

});

expect(cleanStaleGatewayProcessesSync).not.toHaveBeenCalled();

expect(inspectPortUsage).not.toHaveBeenCalled();

});

it("fails restart before kickstart when the configured gateway port remains busy", async () => {

const env = {

...createDefaultLaunchdEnv(),

import { parseStrictInteger, parseStrictPositiveInteger } from "../infra/parse-finite-number.js";

import { formatPortDiagnostics, inspectPortUsage } from "../infra/ports.js";

import { cleanStaleGatewayProcessesSync } from "../infra/restart-stale-pids.js";

import { parseTcpPort } from "../infra/tcp-port.js";

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

import { sanitizeForLog } from "../terminal/ansi.js";

import {

continue;

}

if (current === "--port") {

const next = parseStrictPositiveInteger(programArguments[index + 1] ?? "");

if (next !== undefined) {

const next = parseTcpPort(programArguments[index + 1] ?? "");

if (next !== null) {

return next;

}

continue;

}

if (current.startsWith("--port=")) {

const value = parseStrictPositiveInteger(current.slice("--port=".length));

if (value !== undefined) {

const value = parseTcpPort(current.slice("--port=".length));

if (value !== null) {

return value;

}

}

if (fromArgs !== null) {

return fromArgs;

}

const fromServiceEnv = parseStrictPositiveInteger(

command?.environment?.OPENCLAW_GATEWAY_PORT ?? "",

);

if (fromServiceEnv !== undefined) {

const fromServiceEnv = parseTcpPort(command?.environment?.OPENCLAW_GATEWAY_PORT ?? "");

if (fromServiceEnv !== null) {

return fromServiceEnv;

}

const fromEnv = parseStrictPositiveInteger(env.OPENCLAW_GATEWAY_PORT ?? "");

return fromEnv ?? null;

return parseTcpPort(env.OPENCLAW_GATEWAY_PORT ?? "");

}

function resolveGuiDomain(): string {

import path from "node:path";

import { isGatewayArgv } from "../infra/gateway-process-argv.js";

import { findVerifiedGatewayListenerPidsOnPortSync } from "../infra/gateway-processes.js";

import { parseStrictPositiveInteger } from "../infra/parse-finite-number.js";

import { inspectPortUsage } from "../infra/ports.js";

import { parseTcpPort } from "../infra/tcp-port.js";

import { getWindowsInstallRoots } from "../infra/windows-install-roots.js";

import { killProcessTree } from "../process/kill-tree.js";

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

}

function resolveConfiguredGatewayPort(env: GatewayServiceEnv): number | null {

const raw = env.OPENCLAW_GATEWAY_PORT?.trim();

if (!raw) {

return null;

}

return parseStrictPositiveInteger(raw) ?? null;

return parseTcpPort(env.OPENCLAW_GATEWAY_PORT);

}

function parsePositivePort(raw: string | undefined): number | null {

const value = raw?.trim();

if (!value) {

return null;

}

if (!/^\d+$/.test(value)) {

return null;

}

const parsed = parseStrictPositiveInteger(value);

return parsed !== undefined && parsed <= 65535 ? parsed : null;

return parseTcpPort(raw);

}

function parsePortFromProgramArguments(programArguments?: string[]): number | null {

expect(

readGatewayServiceCommandPort(["/usr/bin/node", "entry.js", "gateway", "--port=0"]),

).toBe(undefined);

expect(

readGatewayServiceCommandPort(["/usr/bin/node", "entry.js", "gateway", "--port=65536"]),

).toBe(undefined);

});

it("flags gateway service port drift from the expected config port", async () => {

});

});

it("flags explicit invalid gateway service ports", async () => {

const audit = await auditGatewayServiceConfig({

env: { HOME: "/tmp" },

platform: "win32",

expectedPort: 18888,

command: {

programArguments: ["/usr/bin/node", "entry.js", "gateway", "--port=65536"],

environment: {},

},

});

const issue = audit.issues.find(

(entry) => entry.code === SERVICE_AUDIT_CODES.gatewayPortMismatch,

);

expect(issue).toStrictEqual({

code: SERVICE_AUDIT_CODES.gatewayPortMismatch,

message: "Gateway service port does not match current gateway config.",

detail: "65536 -> 18888",

level: "recommended",

});

});

it("accepts gateway service ports that match the expected config port", async () => {

const audit = await auditGatewayServiceConfig({

env: { HOME: "/tmp" },

import fs from "node:fs/promises";

import path from "node:path";

import { normalizeEnvVarKey } from "../infra/host-env-security.js";

import { parseStrictPositiveInteger } from "../infra/parse-finite-number.js";

import { parseTcpPort } from "../infra/tcp-port.js";

import {

normalizeLowercaseStringOrEmpty,

normalizeOptionalString,

}

}

function parseGatewayPortArg(value: string | undefined): number | undefined {

const parsed = parseStrictPositiveInteger(value ?? "");

return parsed !== undefined && parsed <= 65535 ? parsed : undefined;

type GatewayServiceCommandPort =

| { kind: "missing" }

| { kind: "valid"; port: number }

| { kind: "invalid"; raw: string };

function parseGatewayPortArg(value: string | undefined): GatewayServiceCommandPort {

const raw = value?.trim() ?? "";

const port = parseTcpPort(raw);

if (port !== null) {

return { kind: "valid", port };

}

return raw ? { kind: "invalid", raw } : { kind: "missing" };

}

export function readGatewayServiceCommandPort(programArguments?: string[]): number | undefined {

function readGatewayServiceCommandPortState(

programArguments?: string[],

): GatewayServiceCommandPort {

if (!programArguments || programArguments.length === 0) {

return undefined;

return { kind: "missing" };

}

for (let index = 0; index < programArguments.length; index += 1) {

const arg = programArguments[index];

return parseGatewayPortArg(arg.slice("--port=".length));

}

}

return undefined;

return { kind: "missing" };

}

export function readGatewayServiceCommandPort(programArguments?: string[]): number | undefined {

const servicePort = readGatewayServiceCommandPortState(programArguments);

return servicePort.kind === "valid" ? servicePort.port : undefined;

}

function auditGatewayServicePort(params: {

) {

return;

}

const servicePort = readGatewayServiceCommandPort(params.programArguments);

if (servicePort === undefined || servicePort === params.expectedPort) {

const servicePort = readGatewayServiceCommandPortState(params.programArguments);

if (servicePort.kind === "missing") {

return;

}

if (servicePort.kind === "valid" && servicePort.port === params.expectedPort) {

return;

}

const detail =

servicePort.kind === "valid"

? `${servicePort.port} -> ${params.expectedPort}`

: `${servicePort.raw} -> ${params.expectedPort}`;

params.issues.push({

code: SERVICE_AUDIT_CODES.gatewayPortMismatch,

message: "Gateway service port does not match current gateway config.",

detail: `${servicePort} -> ${params.expectedPort}`,

detail,

level: "recommended",

});

}

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

import { parseTcpPort } from "./tcp-port.js";

describe("parseTcpPort", () => {

it("accepts valid TCP port values", () => {

expect(parseTcpPort(1)).toBe(1);

expect(parseTcpPort("8080")).toBe(8080);

expect(parseTcpPort(" 65535 ")).toBe(65_535);

});

it("rejects invalid TCP port values", () => {

expect(parseTcpPort(undefined)).toBeNull();

expect(parseTcpPort(null)).toBeNull();

expect(parseTcpPort(0)).toBeNull();

expect(parseTcpPort(-1)).toBeNull();

expect(parseTcpPort(65_536)).toBeNull();

expect(parseTcpPort("100000")).toBeNull();

expect(parseTcpPort("8080ms")).toBeNull();

expect(parseTcpPort("1.5")).toBeNull();

});

});

import { parseStrictPositiveInteger } from "./parse-finite-number.js";

export const MAX_TCP_PORT = 65_535;

export function parseTcpPort(raw: unknown): number | null {

if (raw === undefined || raw === null) {

return null;

}

const parsed = parseStrictPositiveInteger(raw);

if (parsed === undefined || parsed > MAX_TCP_PORT) {

return null;

}

return parsed;

}