MIN_CLIENT_PROTOCOL_VERSION,

PROTOCOL_VERSION,

} from "../../packages/gateway-protocol/src/version.js";

import { createArgReader, createGatewayWsClient, resolveGatewayUrl } from "./gateway-ws-client.ts";

function writeStdoutLine(message = ""): void {

process.stdout.write(`${message}\n`);

process.stderr.write(`${message}\n`);

}

const argv = process.argv.slice(2);

const getArg = (flag: string) => {

const index = argv.indexOf(flag);

return index === -1 ? undefined : argv[index + 1];

};

const hasFlag = (flag: string) => argv.includes(flag);

type NodeListPayload = {

ts?: number;

nodes?: Array<{

type NodeListNode = NonNullable<NodeListPayload["nodes"]>[number];

const { get: getArg, has: hasFlag } = createArgReader();

const urlRaw = getArg("--url") ?? process.env.OPENCLAW_GATEWAY_URL;

const token = getArg("--token") ?? process.env.OPENCLAW_GATEWAY_TOKEN;

const nodeHint = getArg("--node");

process.exit(1);

}

const waitSeconds = parseWaitSeconds(getArg("--wait-seconds"));

const { createGatewayWsClient, resolveGatewayUrl } = await import("./gateway-ws-client.ts");

const url = resolveGatewayUrl(urlRaw);

const isoNow = () => new Date().toISOString();

}

}

function parseWaitSeconds(raw: string | undefined): number {

const value = raw ?? "25";

const text = value.trim();

if (!/^[1-9]\d*$/u.test(text)) {

writeStderrLine(`--wait-seconds must be a positive integer; got: ${value}`);

process.exit(1);

}

const parsed = Number(text);

if (!Number.isSafeInteger(parsed)) {

writeStderrLine(`--wait-seconds must be a safe positive integer; got: ${value}`);

process.exit(1);

}

return parsed;

}

function isRecord(value: unknown): value is Record<string, unknown> {

return Boolean(value && typeof value === "object" && !Array.isArray(value));

}

const listPayload = (nodesRes.payload ?? {}) as NodeListPayload;

let node = pickIosNode(listPayload, nodeHint);

if (!node) {

const waitSeconds = Number.parseInt(getArg("--wait-seconds") ?? "25", 10);

const deadline = Date.now() + Math.max(1, waitSeconds) * 1000;

while (!node && Date.now() < deadline) {

await new Promise((r) => {

return `ws://127.0.0.1:${address.port}`;

}

function runScript(url: string): Promise<ScriptResult> {

function runScript(url: string, extraArgs: readonly string[] = []): Promise<ScriptResult> {

return new Promise((resolve) => {

const child = spawn(

process.execPath,

"--token",

"token",

"--json",

...extraArgs,

],

{ stdio: "pipe" },

);

}

describe("ios-node-e2e", () => {

it("rejects malformed wait seconds before connecting", async () => {

const result = await runScript("ws://127.0.0.1:9", ["--wait-seconds", "1e3"]);

expect(result).toMatchObject({ signal: null, status: 1, timedOut: false });

expect(result.stderr).toContain("--wait-seconds must be a positive integer; got: 1e3");

expect(result.stdout).toBe("");

});

it("fails empty node invoke payloads instead of counting them as proof", async () => {

const invokeParams: Array<{ command?: string; idempotencyKey?: string }> = [];

const url = await listenGateway({ mode: "empty", invokeParams });