@flrande/browserctl 0.4.0-dev.15.1 → 0.5.0-dev.19.1

package/apps/browserctl/src/commands/wait-element.ts

@@ -0,0 +1,76 @@
+import { callDaemonTool } from "../daemon-client";
+import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
+
+export type WaitElementCommandResult = Record<string, unknown>;
+
+function parsePositiveInteger(value: string, optionName: string): number {
+  const normalized = value.trim();
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    throw new Error(`${optionName} must be a positive integer.`);
+  }
+
+  return Number.parseInt(normalized, 10);
+}
+
+function parseWaitOptions(tokens: string[]): {
+  timeoutMs?: number;
+  pollMs?: number;
+} {
+  let timeoutMs: number | undefined;
+  let pollMs: number | undefined;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--timeout-ms") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --timeout-ms.");
+      }
+      timeoutMs = parsePositiveInteger(value, "--timeout-ms");
+      index += 1;
+      continue;
+    }
+
+    if (token === "--poll-ms") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --poll-ms.");
+      }
+      pollMs = parsePositiveInteger(value, "--poll-ms");
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith("--")) {
+      throw new Error(`Unknown wait-element option: ${token}`);
+    }
+
+    if (timeoutMs === undefined) {
+      timeoutMs = parsePositiveInteger(token, "timeoutMs");
+      continue;
+    }
+
+    throw new Error(`Unknown wait-element option: ${token}`);
+  }
+
+  return {
+    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    ...(pollMs !== undefined ? { pollMs } : {})
+  };
+}
+
+export async function runWaitElementCommand(args: string[]): Promise<WaitElementCommandResult> {
+  const context = parseCommandContext(args);
+  const targetId = requirePositionalArg(context, 0, "targetId");
+  const selector = requirePositionalArg(context, 1, "selector");
+  const options = parseWaitOptions(context.positional.slice(2));
+
+  return await callDaemonTool<WaitElementCommandResult>(
+    "browser.wait.element",
+    buildToolArguments(context, {
+      targetId,
+      selector,
+      ...options
+    })
+  );
+}

package/apps/browserctl/src/commands/wait-text.test.ts

@@ -0,0 +1,110 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { callDaemonToolMock } = vi.hoisted(() => ({
+  callDaemonToolMock: vi.fn()
+}));
+
+vi.mock("../daemon-client", () => ({
+  callDaemonTool: callDaemonToolMock
+}));
+
+import { runWaitTextCommand } from "./wait-text";
+
+afterEach(() => {
+  callDaemonToolMock.mockReset();
+});
+
+describe("runWaitTextCommand", () => {
+  it("supports selector and timeout options", async () => {
+    callDaemonToolMock.mockResolvedValue({ ok: true });
+
+    await runWaitTextCommand([
+      "target:1",
+      "Order Submitted",
+      "--selector",
+      "#status",
+      "--timeout-ms",
+      "4000",
+      "--poll-ms",
+      "50"
+    ]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.wait.text", {
+      sessionId: "cli:local",
+      targetId: "target:1",
+      text: "Order Submitted",
+      selector: "#status",
+      timeoutMs: 4000,
+      pollMs: 50
+    });
+  });
+
+  it("supports positional timeout shorthand", async () => {
+    callDaemonToolMock.mockResolvedValue({ ok: true });
+
+    await runWaitTextCommand(["target:1", "ready", "1500"]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.wait.text", {
+      sessionId: "cli:local",
+      targetId: "target:1",
+      text: "ready",
+      timeoutMs: 1500
+    });
+  });
+
+  it.each([
+    {
+      label: "--selector",
+      args: ["target:1", "ready", "--selector"],
+      message: "Missing value for --selector."
+    },
+    {
+      label: "--timeout-ms",
+      args: ["target:1", "ready", "--timeout-ms"],
+      message: "Missing value for --timeout-ms."
+    },
+    {
+      label: "--poll-ms",
+      args: ["target:1", "ready", "--poll-ms"],
+      message: "Missing value for --poll-ms."
+    }
+  ])("throws when $label is missing a value", async ({ args, message }) => {
+    await expect(runWaitTextCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    {
+      label: "selector empty",
+      args: ["target:1", "ready", "--selector", "  "],
+      message: "--selector must be a non-empty string."
+    },
+    {
+      label: "timeout <= 0",
+      args: ["target:1", "ready", "--timeout-ms", "0"],
+      message: "--timeout-ms must be a positive integer."
+    },
+    {
+      label: "poll <= 0",
+      args: ["target:1", "ready", "--poll-ms", "0"],
+      message: "--poll-ms must be a positive integer."
+    },
+    {
+      label: "non-strict timeout text",
+      args: ["target:1", "ready", "--timeout-ms", "1500abc"],
+      message: "--timeout-ms must be a positive integer."
+    }
+  ])("throws on invalid option value: $label", async ({ args, message }) => {
+    await expect(runWaitTextCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it("throws on unknown option token", async () => {
+    await expect(runWaitTextCommand(["target:1", "ready", "--unknown"]))
+      .rejects.toThrow("Unknown wait-text option: --unknown");
+
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+});

package/apps/browserctl/src/commands/wait-text.ts

@@ -0,0 +1,93 @@
+import { callDaemonTool } from "../daemon-client";
+import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
+
+export type WaitTextCommandResult = Record<string, unknown>;
+
+function parsePositiveInteger(value: string, optionName: string): number {
+  const normalized = value.trim();
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    throw new Error(`${optionName} must be a positive integer.`);
+  }
+
+  return Number.parseInt(normalized, 10);
+}
+
+function parseWaitOptions(tokens: string[]): {
+  selector?: string;
+  timeoutMs?: number;
+  pollMs?: number;
+} {
+  let selector: string | undefined;
+  let timeoutMs: number | undefined;
+  let pollMs: number | undefined;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--selector") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --selector.");
+      }
+      const trimmed = value.trim();
+      if (trimmed.length === 0) {
+        throw new Error("--selector must be a non-empty string.");
+      }
+      selector = trimmed;
+      index += 1;
+      continue;
+    }
+
+    if (token === "--timeout-ms") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --timeout-ms.");
+      }
+      timeoutMs = parsePositiveInteger(value, "--timeout-ms");
+      index += 1;
+      continue;
+    }
+
+    if (token === "--poll-ms") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --poll-ms.");
+      }
+      pollMs = parsePositiveInteger(value, "--poll-ms");
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith("--")) {
+      throw new Error(`Unknown wait-text option: ${token}`);
+    }
+
+    if (timeoutMs === undefined) {
+      timeoutMs = parsePositiveInteger(token, "timeoutMs");
+      continue;
+    }
+
+    throw new Error(`Unknown wait-text option: ${token}`);
+  }
+
+  return {
+    ...(selector !== undefined ? { selector } : {}),
+    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    ...(pollMs !== undefined ? { pollMs } : {})
+  };
+}
+
+export async function runWaitTextCommand(args: string[]): Promise<WaitTextCommandResult> {
+  const context = parseCommandContext(args);
+  const targetId = requirePositionalArg(context, 0, "targetId");
+  const text = requirePositionalArg(context, 1, "text");
+  const options = parseWaitOptions(context.positional.slice(2));
+
+  return await callDaemonTool<WaitTextCommandResult>(
+    "browser.wait.text",
+    buildToolArguments(context, {
+      targetId,
+      text,
+      ...options
+    })
+  );
+}

package/apps/browserctl/src/commands/wait-url.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { callDaemonToolMock } = vi.hoisted(() => ({
+  callDaemonToolMock: vi.fn()
+}));
+
+vi.mock("../daemon-client", () => ({
+  callDaemonTool: callDaemonToolMock
+}));
+
+import { runWaitUrlCommand } from "./wait-url";
+
+afterEach(() => {
+  callDaemonToolMock.mockReset();
+});
+
+describe("runWaitUrlCommand", () => {
+  it("supports positional timeout shorthand", async () => {
+    callDaemonToolMock.mockResolvedValue({ ok: true });
+
+    await runWaitUrlCommand(["target:1", "/dashboard", "2500"]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.wait.url", {
+      sessionId: "cli:local",
+      targetId: "target:1",
+      urlPattern: "/dashboard",
+      timeoutMs: 2500
+    });
+  });
+
+  it.each([
+    {
+      label: "--timeout-ms",
+      args: ["target:1", "/dashboard", "--timeout-ms"],
+      message: "Missing value for --timeout-ms."
+    },
+    {
+      label: "--poll-ms",
+      args: ["target:1", "/dashboard", "--poll-ms"],
+      message: "Missing value for --poll-ms."
+    }
+  ])("throws when $label is missing a value", async ({ args, message }) => {
+    await expect(runWaitUrlCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    {
+      label: "timeout <= 0",
+      args: ["target:1", "/dashboard", "--timeout-ms", "0"],
+      message: "--timeout-ms must be a positive integer."
+    },
+    {
+      label: "poll <= 0",
+      args: ["target:1", "/dashboard", "--poll-ms", "-5"],
+      message: "--poll-ms must be a positive integer."
+    },
+    {
+      label: "positional timeout <= 0",
+      args: ["target:1", "/dashboard", "0"],
+      message: "timeoutMs must be a positive integer."
+    },
+    {
+      label: "non-strict timeout text",
+      args: ["target:1", "/dashboard", "--timeout-ms", "2500abc"],
+      message: "--timeout-ms must be a positive integer."
+    }
+  ])("throws on non-positive numeric option: $label", async ({ args, message }) => {
+    await expect(runWaitUrlCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it("throws on unknown option token", async () => {
+    await expect(runWaitUrlCommand(["target:1", "/dashboard", "--unknown"]))
+      .rejects.toThrow("Unknown wait-url option: --unknown");
+
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+});

package/apps/browserctl/src/commands/wait-url.ts

@@ -0,0 +1,76 @@
+import { callDaemonTool } from "../daemon-client";
+import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
+
+export type WaitUrlCommandResult = Record<string, unknown>;
+
+function parsePositiveInteger(value: string, optionName: string): number {
+  const normalized = value.trim();
+  if (!/^[1-9]\d*$/.test(normalized)) {
+    throw new Error(`${optionName} must be a positive integer.`);
+  }
+
+  return Number.parseInt(normalized, 10);
+}
+
+function parseWaitOptions(tokens: string[]): {
+  timeoutMs?: number;
+  pollMs?: number;
+} {
+  let timeoutMs: number | undefined;
+  let pollMs: number | undefined;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--timeout-ms") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --timeout-ms.");
+      }
+      timeoutMs = parsePositiveInteger(value, "--timeout-ms");
+      index += 1;
+      continue;
+    }
+
+    if (token === "--poll-ms") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --poll-ms.");
+      }
+      pollMs = parsePositiveInteger(value, "--poll-ms");
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith("--")) {
+      throw new Error(`Unknown wait-url option: ${token}`);
+    }
+
+    if (timeoutMs === undefined) {
+      timeoutMs = parsePositiveInteger(token, "timeoutMs");
+      continue;
+    }
+
+    throw new Error(`Unknown wait-url option: ${token}`);
+  }
+
+  return {
+    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    ...(pollMs !== undefined ? { pollMs } : {})
+  };
+}
+
+export async function runWaitUrlCommand(args: string[]): Promise<WaitUrlCommandResult> {
+  const context = parseCommandContext(args);
+  const targetId = requirePositionalArg(context, 0, "targetId");
+  const urlPattern = requirePositionalArg(context, 1, "urlPattern");
+  const options = parseWaitOptions(context.positional.slice(2));
+
+  return await callDaemonTool<WaitUrlCommandResult>(
+    "browser.wait.url",
+    buildToolArguments(context, {
+      targetId,
+      urlPattern,
+      ...options
+    })
+  );
+}