@flrande/browserctl 0.5.0 → 0.6.0

package/apps/browserctl/src/commands/session-list.test.ts

@@ -1,81 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { callDaemonToolMock } = vi.hoisted(() => ({
-  callDaemonToolMock: vi.fn()
-}));
-
-vi.mock("../daemon-client", () => ({
-  callDaemonTool: callDaemonToolMock
-}));
-
-import { runSessionListCommand } from "./session-list";
-
-afterEach(() => {
-  callDaemonToolMock.mockReset();
-});
-
-describe("runSessionListCommand", () => {
-  it("forwards tenant and limit filters", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runSessionListCommand([
-      "--tenant",
-      "finance",
-      "--limit",
-      "20"
-    ]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.session.list", {
-      sessionId: "cli:local",
-      tenant: "finance",
-      limit: 20
-    });
-  });
-
-  it("supports no options", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runSessionListCommand([]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.session.list", {
-      sessionId: "cli:local"
-    });
-  });
-
-  it("throws when --tenant is missing value", async () => {
-    await expect(runSessionListCommand(["--tenant"])).rejects.toThrow(
-      "Missing value for --tenant."
-    );
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("throws when --limit is missing value", async () => {
-    await expect(runSessionListCommand(["--limit"])).rejects.toThrow(
-      "Missing value for --limit."
-    );
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("throws on invalid --limit", async () => {
-    await expect(runSessionListCommand(["--limit", "0"])).rejects.toThrow(
-      "--limit must be a positive integer."
-    );
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("rejects non-strict integer text for --limit", async () => {
-    await expect(runSessionListCommand(["--limit", "20abc"])).rejects.toThrow(
-      "--limit must be a positive integer."
-    );
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("throws on unknown option token", async () => {
-    await expect(runSessionListCommand(["--unknown"])).rejects.toThrow(
-      "Unknown session-list option: --unknown"
-    );
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-});

package/apps/browserctl/src/commands/session-list.ts

@@ -1,70 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext } from "./common";
-
-export type SessionListCommandResult = 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 parseSessionListOptions(tokens: string[]): {
-  tenant?: string;
-  limit?: number;
-} {
-  let tenant: string | undefined;
-  let limit: number | undefined;
-
-  for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index];
-    if (token === "--tenant") {
-      const value = tokens[index + 1];
-      if (value === undefined) {
-        throw new Error("Missing value for --tenant.");
-      }
-
-      const trimmedValue = value.trim();
-      if (trimmedValue.length === 0) {
-        throw new Error("--tenant must be a non-empty string.");
-      }
-
-      tenant = trimmedValue;
-      index += 1;
-      continue;
-    }
-
-    if (token === "--limit") {
-      const value = tokens[index + 1];
-      if (value === undefined) {
-        throw new Error("Missing value for --limit.");
-      }
-
-      limit = parsePositiveInteger(value, "--limit");
-      index += 1;
-      continue;
-    }
-
-    throw new Error(`Unknown session-list option: ${token}`);
-  }
-
-  return {
-    ...(tenant !== undefined ? { tenant } : {}),
-    ...(limit !== undefined ? { limit } : {})
-  };
-}
-
-export async function runSessionListCommand(args: string[]): Promise<SessionListCommandResult> {
-  const context = parseCommandContext(args);
-  const options = parseSessionListOptions(context.positional);
-
-  return await callDaemonTool<SessionListCommandResult>(
-    "browser.session.list",
-    buildToolArguments(context, {
-      ...options
-    })
-  );
-}

package/apps/browserctl/src/commands/snapshot.ts

@@ -1,16 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type SnapshotCommandResult = Record<string, unknown>;
-
-export async function runSnapshotCommand(args: string[]): Promise<SnapshotCommandResult> {
-  const context = parseCommandContext(args);
-  const targetId = requirePositionalArg(context, 0, "targetId");
-
-  return await callDaemonTool<SnapshotCommandResult>(
-    "browser.snapshot",
-    buildToolArguments(context, {
-      targetId
-    })
-  );
-}

package/apps/browserctl/src/commands/status.ts

@@ -1,10 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext } from "./common";
-
-export type StatusCommandResult = Record<string, unknown>;
-
-export async function runStatusCommand(args: string[] = []): Promise<StatusCommandResult> {
-  const context = parseCommandContext(args);
-
-  return await callDaemonTool<StatusCommandResult>("browser.status", buildToolArguments(context));
-}

package/apps/browserctl/src/commands/storage-get.ts

@@ -1,20 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type StorageGetCommandResult = Record<string, unknown>;
-
-export async function runStorageGetCommand(args: string[]): Promise<StorageGetCommandResult> {
-  const context = parseCommandContext(args);
-  const targetId = requirePositionalArg(context, 0, "targetId");
-  const scope = requirePositionalArg(context, 1, "scope");
-  const key = requirePositionalArg(context, 2, "key");
-
-  return await callDaemonTool<StorageGetCommandResult>(
-    "browser.storage.get",
-    buildToolArguments(context, {
-      targetId,
-      scope,
-      key
-    })
-  );
-}

package/apps/browserctl/src/commands/storage-set.ts

@@ -1,22 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type StorageSetCommandResult = Record<string, unknown>;
-
-export async function runStorageSetCommand(args: string[]): Promise<StorageSetCommandResult> {
-  const context = parseCommandContext(args);
-  const targetId = requirePositionalArg(context, 0, "targetId");
-  const scope = requirePositionalArg(context, 1, "scope");
-  const key = requirePositionalArg(context, 2, "key");
-  const value = requirePositionalArg(context, 3, "value");
-
-  return await callDaemonTool<StorageSetCommandResult>(
-    "browser.storage.set",
-    buildToolArguments(context, {
-      targetId,
-      scope,
-      key,
-      value
-    })
-  );
-}

package/apps/browserctl/src/commands/tab-close.ts

@@ -1,20 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type TabCloseCommandResult = {
-  driver: string;
-  targetId: string;
-  closed: boolean;
-};
-
-export async function runTabCloseCommand(args: string[]): Promise<TabCloseCommandResult> {
-  const context = parseCommandContext(args);
-  const targetId = requirePositionalArg(context, 0, "targetId");
-
-  return await callDaemonTool<TabCloseCommandResult>(
-    "browser.tab.close",
-    buildToolArguments(context, {
-      targetId
-    })
-  );
-}

package/apps/browserctl/src/commands/tab-focus.ts

@@ -1,20 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type TabFocusCommandResult = {
-  driver: string;
-  targetId: string;
-  focused: boolean;
-};
-
-export async function runTabFocusCommand(args: string[]): Promise<TabFocusCommandResult> {
-  const context = parseCommandContext(args);
-  const targetId = requirePositionalArg(context, 0, "targetId");
-
-  return await callDaemonTool<TabFocusCommandResult>(
-    "browser.tab.focus",
-    buildToolArguments(context, {
-      targetId
-    })
-  );
-}

package/apps/browserctl/src/commands/tab-open.ts

@@ -1,19 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type TabOpenCommandResult = {
-  driver: string;
-  targetId: string;
-};
-
-export async function runTabOpenCommand(args: string[]): Promise<TabOpenCommandResult> {
-  const context = parseCommandContext(args);
-  const url = requirePositionalArg(context, 0, "url");
-
-  return await callDaemonTool<TabOpenCommandResult>(
-    "browser.tab.open",
-    buildToolArguments(context, {
-      url
-    })
-  );
-}

package/apps/browserctl/src/commands/tabs.ts

@@ -1,13 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext } from "./common";
-
-export type TabsCommandResult = {
-  driver: string;
-  tabs: string[];
-};
-
-export async function runTabsCommand(args: string[] = []): Promise<TabsCommandResult> {
-  const context = parseCommandContext(args);
-
-  return await callDaemonTool<TabsCommandResult>("browser.tab.list", buildToolArguments(context));
-}

package/apps/browserctl/src/commands/trace-get.test.ts

@@ -1,61 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { callDaemonToolMock } = vi.hoisted(() => ({
-  callDaemonToolMock: vi.fn()
-}));
-
-vi.mock("../daemon-client", () => ({
-  callDaemonTool: callDaemonToolMock
-}));
-
-import { runTraceGetCommand } from "./trace-get";
-
-afterEach(() => {
-  callDaemonToolMock.mockReset();
-});
-
-describe("runTraceGetCommand", () => {
-  it("forwards limit option", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runTraceGetCommand(["--limit", "50"]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.trace.get", {
-      sessionId: "cli:local",
-      limit: 50
-    });
-  });
-
-  it("supports empty options", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runTraceGetCommand([]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.trace.get", {
-      sessionId: "cli:local"
-    });
-  });
-
-  it("throws when --limit is missing a value", async () => {
-    await expect(runTraceGetCommand(["--limit"]))
-      .rejects.toThrow("Missing value for --limit.");
-
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("throws when --limit is invalid", async () => {
-    await expect(runTraceGetCommand(["--limit", "0"]))
-      .rejects.toThrow("--limit must be a positive integer.");
-
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("throws on unknown option token", async () => {
-    await expect(runTraceGetCommand(["--unknown"]))
-      .rejects.toThrow("Unknown trace-get option: --unknown");
-
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-});

package/apps/browserctl/src/commands/trace-get.ts

@@ -1,62 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext } from "./common";
-
-type TraceGetKeyResponse = {
-  stepIndex?: number;
-  kind?: string;
-  timestamp?: string;
-  data?: {
-    memoryHit?: boolean;
-  } & Record<string, unknown>;
-};
-
-export type TraceGetCommandResult = {
-  sessionId?: string;
-  steps?: Array<Record<string, unknown>>;
-  keyResponses?: TraceGetKeyResponse[];
-  screenshots?: Array<Record<string, unknown>>;
-} & Record<string, unknown>;
-
-function parsePositiveInteger(value: string, optionName: string): number {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`${optionName} must be a positive integer.`);
-  }
-
-  return parsed;
-}
-
-function parseTraceGetOptions(tokens: string[]): {
-  limit?: number;
-} {
-  let limit: number | undefined;
-
-  for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index];
-    if (token === "--limit") {
-      const value = tokens[index + 1];
-      if (value === undefined) {
-        throw new Error("Missing value for --limit.");
-      }
-      limit = parsePositiveInteger(value, "--limit");
-      index += 1;
-      continue;
-    }
-
-    throw new Error(`Unknown trace-get option: ${token}`);
-  }
-
-  return limit === undefined ? {} : { limit };
-}
-
-export async function runTraceGetCommand(args: string[]): Promise<TraceGetCommandResult> {
-  const context = parseCommandContext(args);
-  const options = parseTraceGetOptions(context.positional);
-
-  return await callDaemonTool<TraceGetCommandResult>(
-    "browser.trace.get",
-    buildToolArguments(context, {
-      ...options
-    })
-  );
-}

package/apps/browserctl/src/commands/upload-arm.ts

@@ -1,26 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type UploadArmCommandResult = {
-  driver: string;
-  targetId: string;
-  armed: boolean;
-  files: string[];
-};
-
-export async function runUploadArmCommand(args: string[]): Promise<UploadArmCommandResult> {
-  const context = parseCommandContext(args);
-  const targetId = requirePositionalArg(context, 0, "targetId");
-  const files = context.positional.slice(1);
-  if (files.length === 0) {
-    throw new Error("Missing required argument: files.");
-  }
-
-  return await callDaemonTool<UploadArmCommandResult>(
-    "browser.upload.arm",
-    buildToolArguments(context, {
-      targetId,
-      files
-    })
-  );
-}

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

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

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

@@ -1,76 +0,0 @@
-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
-    })
-  );
-}