@flrande/browserctl 0.1.0-dev.7.1

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

@@ -0,0 +1,67 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { callDaemonToolMock } = vi.hoisted(() => ({
+  callDaemonToolMock: vi.fn()
+}));
+
+vi.mock("../daemon-client", () => ({
+  callDaemonTool: callDaemonToolMock
+}));
+
+import { runDownloadWaitCommand } from "./download-wait";
+
+const ORIGINAL_AUTH_TOKEN = process.env.BROWSERCTL_AUTH_TOKEN;
+
+afterEach(() => {
+  callDaemonToolMock.mockReset();
+
+  if (ORIGINAL_AUTH_TOKEN === undefined) {
+    delete process.env.BROWSERCTL_AUTH_TOKEN;
+    return;
+  }
+
+  process.env.BROWSERCTL_AUTH_TOKEN = ORIGINAL_AUTH_TOKEN;
+});
+
+describe("runDownloadWaitCommand", () => {
+  it("forwards optional download path when provided", async () => {
+    callDaemonToolMock.mockResolvedValue({
+      driver: "managed",
+      targetId: "target:1",
+      download: {}
+    });
+
+    await runDownloadWaitCommand(["target:1", "downloads/file.bin"]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith(
+      "browser.download.wait",
+      expect.objectContaining({
+        sessionId: "cli:local",
+        targetId: "target:1",
+        path: "downloads/file.bin"
+      })
+    );
+  });
+
+  it("uses --token over environment token", async () => {
+    process.env.BROWSERCTL_AUTH_TOKEN = "env-token";
+    callDaemonToolMock.mockResolvedValue({
+      driver: "managed",
+      targetId: "target:1",
+      download: {}
+    });
+
+    await runDownloadWaitCommand(["--token", "cli-token", "target:1"]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith(
+      "browser.download.wait",
+      expect.objectContaining({
+        sessionId: "cli:local",
+        targetId: "target:1",
+        authToken: "cli-token"
+      })
+    );
+  });
+});

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

@@ -0,0 +1,27 @@
+import { callDaemonTool } from "../daemon-client";
+import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
+
+export type DownloadWaitCommandResult = {
+  driver: string;
+  targetId: string;
+  download: Record<string, unknown>;
+};
+
+export async function runDownloadWaitCommand(args: string[]): Promise<DownloadWaitCommandResult> {
+  const context = parseCommandContext(args);
+  const targetId = requirePositionalArg(context, 0, "targetId");
+  const path = context.positional[1];
+
+  return await callDaemonTool<DownloadWaitCommandResult>(
+    "browser.download.wait",
+    buildToolArguments(
+      context,
+      path === undefined
+        ? { targetId }
+        : {
+            targetId,
+            path
+          }
+    )
+  );
+}

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

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

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

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

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

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

package/apps/browserctl/src/commands/network-wait-for.ts

@@ -0,0 +1,100 @@
+import { callDaemonTool } from "../daemon-client";
+import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
+
+export type NetworkWaitForCommandResult = 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 parseNetworkWaitOptions(tokens: string[]): {
+  method?: string;
+  status?: number;
+  timeoutMs?: number;
+  pollMs?: number;
+} {
+  let method: string | undefined;
+  let status: number | undefined;
+  let timeoutMs: number | undefined;
+  let pollMs: number | undefined;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--method") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --method.");
+      }
+      method = value.trim().toUpperCase();
+      index += 1;
+      continue;
+    }
+
+    if (token === "--status") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --status.");
+      }
+      status = parsePositiveInteger(value, "--status");
+      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 (timeoutMs === undefined) {
+      timeoutMs = parsePositiveInteger(token, "timeoutMs");
+      continue;
+    }
+
+    throw new Error(`Unknown network-wait-for option: ${token}`);
+  }
+
+  return {
+    ...(method !== undefined ? { method } : {}),
+    ...(status !== undefined ? { status } : {}),
+    ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    ...(pollMs !== undefined ? { pollMs } : {})
+  };
+}
+
+export async function runNetworkWaitForCommand(
+  args: string[]
+): Promise<NetworkWaitForCommandResult> {
+  const context = parseCommandContext(args);
+  const targetId = requirePositionalArg(context, 0, "targetId");
+  const urlPattern = requirePositionalArg(context, 1, "urlPattern");
+  const options = parseNetworkWaitOptions(context.positional.slice(2));
+
+  return await callDaemonTool<NetworkWaitForCommandResult>(
+    "browser.network.waitFor",
+    buildToolArguments(context, {
+      targetId,
+      urlPattern,
+      ...options
+    })
+  );
+}

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

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

package/apps/browserctl/src/commands/profile-use.ts

@@ -0,0 +1,18 @@
+import { callDaemonTool } from "../daemon-client";
+import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
+
+export type ProfileUseCommandResult = {
+  profile: string;
+};
+
+export async function runProfileUseCommand(args: string[]): Promise<ProfileUseCommandResult> {
+  const context = parseCommandContext(args);
+  const profile = requirePositionalArg(context, 0, "profile");
+
+  return await callDaemonTool<ProfileUseCommandResult>(
+    "browser.profile.use",
+    buildToolArguments(context, {
+      profile
+    })
+  );
+}

package/apps/browserctl/src/commands/response-body.ts

@@ -0,0 +1,24 @@
+import { callDaemonTool } from "../daemon-client";
+import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
+
+export type ResponseBodyCommandResult = {
+  driver: string;
+  targetId: string;
+  requestId: string;
+  body: string;
+  encoding: string;
+};
+
+export async function runResponseBodyCommand(args: string[]): Promise<ResponseBodyCommandResult> {
+  const context = parseCommandContext(args);
+  const targetId = requirePositionalArg(context, 0, "targetId");
+  const requestId = requirePositionalArg(context, 1, "requestId");
+
+  return await callDaemonTool<ResponseBodyCommandResult>(
+    "browser.network.responseBody",
+    buildToolArguments(context, {
+      targetId,
+      requestId
+    })
+  );
+}

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

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

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,13 @@
+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/upload-arm.ts

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