@flrande/browserctl 0.5.0-dev.22.1 → 0.6.0

package/apps/browserctl/src/commands/command-wrappers.test.ts

@@ -1,688 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { callDaemonToolMock } = vi.hoisted(() => ({
-  callDaemonToolMock: vi.fn()
-}));
-
-vi.mock("../daemon-client", () => ({
-  callDaemonTool: callDaemonToolMock
-}));
-
-import { DAEMON_STARTUP_ARGUMENT } from "./common";
-import { runA11ySnapshotCommand } from "./a11y-snapshot";
-import { runActCommand } from "./act";
-import { runConsoleListCommand } from "./console-list";
-import { runCookieClearCommand } from "./cookie-clear";
-import { runCookieGetCommand } from "./cookie-get";
-import { runCookieSetCommand } from "./cookie-set";
-import { runDialogArmCommand } from "./dialog-arm";
-import { runDomQueryAllCommand } from "./dom-query-all";
-import { runDomQueryCommand } from "./dom-query";
-import { runDownloadTriggerCommand } from "./download-trigger";
-import { runDownloadWaitCommand } from "./download-wait";
-import { runElementScreenshotCommand } from "./element-screenshot";
-import { runFrameListCommand } from "./frame-list";
-import { runFrameSnapshotCommand } from "./frame-snapshot";
-import { runHarExportCommand } from "./har-export";
-import { runMemoryDeleteCommand } from "./memory-delete";
-import { runMemoryInspectCommand } from "./memory-inspect";
-import { runMemoryListCommand } from "./memory-list";
-import { runMemoryModeSetCommand } from "./memory-mode-set";
-import { runMemoryPurgeCommand } from "./memory-purge";
-import { runMemoryResolveCommand } from "./memory-resolve";
-import { runMemoryStatusCommand } from "./memory-status";
-import { runMemoryTtlSetCommand } from "./memory-ttl-set";
-import { runMemoryUpsertCommand } from "./memory-upsert";
-import { runNetworkListCommand } from "./network-list";
-import { runNetworkWaitForCommand } from "./network-wait-for";
-import { runProfileListCommand } from "./profile-list";
-import { runProfileUseCommand } from "./profile-use";
-import { runResponseBodyCommand } from "./response-body";
-import { runScreenshotCommand } from "./screenshot";
-import { runSessionDropCommand } from "./session-drop";
-import { runSessionListCommand } from "./session-list";
-import { runSnapshotCommand } from "./snapshot";
-import { runStatusCommand } from "./status";
-import { runStorageGetCommand } from "./storage-get";
-import { runStorageSetCommand } from "./storage-set";
-import { runTabCloseCommand } from "./tab-close";
-import { runTabFocusCommand } from "./tab-focus";
-import { runTabOpenCommand } from "./tab-open";
-import { runTabsCommand } from "./tabs";
-import { runTraceGetCommand } from "./trace-get";
-import { runUploadArmCommand } from "./upload-arm";
-import { runWaitElementCommand } from "./wait-element";
-import { runWaitTextCommand } from "./wait-text";
-import { runWaitUrlCommand } from "./wait-url";
-
-type WrapperCase = {
-  name: string;
-  run: () => Promise<unknown>;
-  expectedTool: string;
-  expectedArgs: Record<string, unknown>;
-};
-
-const BASE_ARGS = {
-  sessionId: "cli:local"
-};
-
-const CASES: WrapperCase[] = [
-  {
-    name: "status",
-    run: async () => await runStatusCommand(),
-    expectedTool: "browser.status",
-    expectedArgs: { ...BASE_ARGS }
-  },
-  {
-    name: "tabs",
-    run: async () => await runTabsCommand(),
-    expectedTool: "browser.tab.list",
-    expectedArgs: { ...BASE_ARGS }
-  },
-  {
-    name: "profile-list",
-    run: async () => await runProfileListCommand(),
-    expectedTool: "browser.profile.list",
-    expectedArgs: { ...BASE_ARGS }
-  },
-  {
-    name: "profile-use",
-    run: async () => await runProfileUseCommand(["managed"]),
-    expectedTool: "browser.profile.use",
-    expectedArgs: {
-      ...BASE_ARGS,
-      profile: "managed"
-    }
-  },
-  {
-    name: "tab-open",
-    run: async () => await runTabOpenCommand(["https://example.com"]),
-    expectedTool: "browser.tab.open",
-    expectedArgs: {
-      ...BASE_ARGS,
-      url: "https://example.com"
-    }
-  },
-  {
-    name: "tab-focus",
-    run: async () => await runTabFocusCommand(["target:1"]),
-    expectedTool: "browser.tab.focus",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "tab-close",
-    run: async () => await runTabCloseCommand(["target:1"]),
-    expectedTool: "browser.tab.close",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "session-list",
-    run: async () => await runSessionListCommand(["--tenant", "finance", "--limit", "5"]),
-    expectedTool: "browser.session.list",
-    expectedArgs: {
-      ...BASE_ARGS,
-      tenant: "finance",
-      limit: 5
-    }
-  },
-  {
-    name: "session-drop",
-    run: async () => await runSessionDropCommand(["tenant-a:job-1"]),
-    expectedTool: "browser.session.drop",
-    expectedArgs: {
-      ...BASE_ARGS,
-      sessionIdToDelete: "tenant-a:job-1"
-    }
-  },
-  {
-    name: "snapshot",
-    run: async () => await runSnapshotCommand(["target:1"]),
-    expectedTool: "browser.snapshot",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "screenshot",
-    run: async () => await runScreenshotCommand(["target:1"]),
-    expectedTool: "browser.screenshot",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "dom-query",
-    run: async () => await runDomQueryCommand(["target:1", "#root"]),
-    expectedTool: "browser.dom.query",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      selector: "#root"
-    }
-  },
-  {
-    name: "dom-query-all",
-    run: async () => await runDomQueryAllCommand(["target:1", ".item"]),
-    expectedTool: "browser.dom.queryAll",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      selector: ".item"
-    }
-  },
-  {
-    name: "element-screenshot",
-    run: async () => await runElementScreenshotCommand(["target:1", "#hero"]),
-    expectedTool: "browser.element.screenshot",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      selector: "#hero"
-    }
-  },
-  {
-    name: "a11y-snapshot",
-    run: async () => await runA11ySnapshotCommand(["target:1", "  #main  "]),
-    expectedTool: "browser.a11y.snapshot",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      selector: "#main"
-    }
-  },
-  {
-    name: "wait-element",
-    run: async () => await runWaitElementCommand(["target:1", "#ready", "--timeout-ms", "1200", "--poll-ms", "20"]),
-    expectedTool: "browser.wait.element",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      selector: "#ready",
-      timeoutMs: 1200,
-      pollMs: 20
-    }
-  },
-  {
-    name: "wait-text",
-    run: async () => await runWaitTextCommand(["target:1", "done", "--selector", "#status", "--timeout-ms", "1500"]),
-    expectedTool: "browser.wait.text",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      text: "done",
-      selector: "#status",
-      timeoutMs: 1500
-    }
-  },
-  {
-    name: "wait-url",
-    run: async () => await runWaitUrlCommand(["target:1", "/dashboard", "1800"]),
-    expectedTool: "browser.wait.url",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      urlPattern: "/dashboard",
-      timeoutMs: 1800
-    }
-  },
-  {
-    name: "network-list",
-    run: async () =>
-      await runNetworkListCommand([
-        "target:1",
-        "--url-contains",
-        "/api",
-        "--method",
-        "get",
-        "--status",
-        "200",
-        "--since",
-        "2026-01-01T00:00:00.000Z",
-        "--limit",
-        "15"
-      ]),
-    expectedTool: "browser.network.list",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      urlContains: "/api",
-      method: "GET",
-      status: 200,
-      since: "2026-01-01T00:00:00.000Z",
-      limit: 15
-    }
-  },
-  {
-    name: "har-export",
-    run: async () =>
-      await runHarExportCommand([
-        "target:1",
-        "--include-bodies",
-        "--method",
-        "post",
-        "--status",
-        "201",
-        "--limit",
-        "10"
-      ]),
-    expectedTool: "browser.network.harExport",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      includeBodies: true,
-      method: "POST",
-      status: 201,
-      limit: 10
-    }
-  },
-  {
-    name: "network-wait-for",
-    run: async () =>
-      await runNetworkWaitForCommand([
-        "target:1",
-        "/api/items",
-        "--method",
-        "post",
-        "--status",
-        "201",
-        "--timeout-ms",
-        "3000",
-        "--poll-ms",
-        "50"
-      ]),
-    expectedTool: "browser.network.waitFor",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      urlPattern: "/api/items",
-      method: "POST",
-      status: 201,
-      timeoutMs: 3000,
-      pollMs: 50
-    }
-  },
-  {
-    name: "cookie-get",
-    run: async () => await runCookieGetCommand(["target:1", "  sid  "]),
-    expectedTool: "browser.cookie.get",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      name: "sid"
-    }
-  },
-  {
-    name: "cookie-set",
-    run: async () => await runCookieSetCommand(["target:1", "sid", "abc", "  https://example.com  "]),
-    expectedTool: "browser.cookie.set",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      name: "sid",
-      value: "abc",
-      url: "https://example.com"
-    }
-  },
-  {
-    name: "cookie-clear",
-    run: async () => await runCookieClearCommand(["target:1", "  sid  "]),
-    expectedTool: "browser.cookie.clear",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      name: "sid"
-    }
-  },
-  {
-    name: "storage-get",
-    run: async () => await runStorageGetCommand(["target:1", "local", "theme"]),
-    expectedTool: "browser.storage.get",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      scope: "local",
-      key: "theme"
-    }
-  },
-  {
-    name: "storage-set",
-    run: async () => await runStorageSetCommand(["target:1", "session", "token", "abc"]),
-    expectedTool: "browser.storage.set",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      scope: "session",
-      key: "token",
-      value: "abc"
-    }
-  },
-  {
-    name: "frame-list",
-    run: async () => await runFrameListCommand(["target:1"]),
-    expectedTool: "browser.frame.list",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "frame-snapshot",
-    run: async () => await runFrameSnapshotCommand(["target:1", "frame:0"]),
-    expectedTool: "browser.frame.snapshot",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      frameId: "frame:0"
-    }
-  },
-  {
-    name: "act",
-    run: async () => await runActCommand(["click", "target:1"]),
-    expectedTool: "browser.act",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      action: {
-        type: "click"
-      }
-    }
-  },
-  {
-    name: "upload-arm",
-    run: async () => await runUploadArmCommand(["target:1", "a.txt", "b.txt"]),
-    expectedTool: "browser.upload.arm",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      files: ["a.txt", "b.txt"]
-    }
-  },
-  {
-    name: "dialog-arm",
-    run: async () => await runDialogArmCommand(["target:1"]),
-    expectedTool: "browser.dialog.arm",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "download-trigger",
-    run: async () => await runDownloadTriggerCommand(["target:1"]),
-    expectedTool: "browser.download.trigger",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "download-wait",
-    run: async () => await runDownloadWaitCommand(["target:1", "downloads/file.bin"]),
-    expectedTool: "browser.download.wait",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      path: "downloads/file.bin"
-    }
-  },
-  {
-    name: "console-list",
-    run: async () => await runConsoleListCommand(["target:1"]),
-    expectedTool: "browser.console.list",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1"
-    }
-  },
-  {
-    name: "response-body",
-    run: async () => await runResponseBodyCommand(["target:1", "request:1"]),
-    expectedTool: "browser.network.responseBody",
-    expectedArgs: {
-      ...BASE_ARGS,
-      targetId: "target:1",
-      requestId: "request:1"
-    }
-  },
-  {
-    name: "memory-status",
-    run: async () => await runMemoryStatusCommand([]),
-    expectedTool: "browser.memory.status",
-    expectedArgs: {
-      ...BASE_ARGS
-    }
-  },
-  {
-    name: "memory-resolve",
-    run: async () => await runMemoryResolveCommand(["forum.example", "open_profile"]),
-    expectedTool: "browser.memory.resolve",
-    expectedArgs: {
-      ...BASE_ARGS,
-      domain: "forum.example",
-      profileId: "default",
-      intentKey: "open_profile"
-    }
-  },
-  {
-    name: "memory-upsert",
-    run: async () =>
-      await runMemoryUpsertCommand([
-        "forum.example",
-        "open_profile",
-        "--signals-json",
-        "[{\"kind\":\"urlPattern\",\"value\":\"/profile\"}]",
-        "--confidence",
-        "0.9",
-        "--confirmed"
-      ]),
-    expectedTool: "browser.memory.upsert",
-    expectedArgs: {
-      ...BASE_ARGS,
-      domain: "forum.example",
-      profileId: "default",
-      intentKey: "open_profile",
-      signals: [{ kind: "urlPattern", value: "/profile" }],
-      confidence: 0.9,
-      confirmed: true
-    }
-  },
-  {
-    name: "memory-list",
-    run: async () =>
-      await runMemoryListCommand([
-        "--domain",
-        "forum.example",
-        "--profile-id",
-        "managed",
-        "--intent-key",
-        "open_profile"
-      ]),
-    expectedTool: "browser.memory.list",
-    expectedArgs: {
-      ...BASE_ARGS,
-      domain: "forum.example",
-      profileId: "managed",
-      intentKey: "open_profile"
-    }
-  },
-  {
-    name: "memory-inspect",
-    run: async () => await runMemoryInspectCommand(["memory:1"]),
-    expectedTool: "browser.memory.inspect",
-    expectedArgs: {
-      ...BASE_ARGS,
-      id: "memory:1"
-    }
-  },
-  {
-    name: "memory-delete",
-    run: async () => await runMemoryDeleteCommand(["memory:1"]),
-    expectedTool: "browser.memory.delete",
-    expectedArgs: {
-      ...BASE_ARGS,
-      id: "memory:1"
-    }
-  },
-  {
-    name: "memory-purge",
-    run: async () => await runMemoryPurgeCommand([]),
-    expectedTool: "browser.memory.purge",
-    expectedArgs: {
-      ...BASE_ARGS
-    }
-  },
-  {
-    name: "memory-mode-set",
-    run: async () => await runMemoryModeSetCommand(["ask"]),
-    expectedTool: "browser.memory.mode.set",
-    expectedArgs: {
-      ...BASE_ARGS,
-      mode: "ask"
-    }
-  },
-  {
-    name: "memory-ttl-set",
-    run: async () => await runMemoryTtlSetCommand(["7"]),
-    expectedTool: "browser.memory.ttl.set",
-    expectedArgs: {
-      ...BASE_ARGS,
-      ttlDays: 7
-    }
-  },
-  {
-    name: "trace-get",
-    run: async () => await runTraceGetCommand(["--limit", "20"]),
-    expectedTool: "browser.trace.get",
-    expectedArgs: {
-      ...BASE_ARGS,
-      limit: 20
-    }
-  }
-];
-
-afterEach(() => {
-  callDaemonToolMock.mockReset();
-  delete process.env.BROWSERCTL_AUTH_TOKEN;
-  delete process.env.BROWSERCTL_BROWSER;
-});
-
-describe("command wrappers", () => {
-  it.each(CASES)("forwards $name to daemon tool", async ({ run, expectedTool, expectedArgs }) => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await run();
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith(expectedTool, expectedArgs);
-  });
-
-  it("forwards session/profile/token/browser context switches", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runStatusCommand([
-      "--session",
-      "session:matrix",
-      "--profile",
-      "chrome-relay",
-      "--token",
-      "cli-token",
-      "--browser",
-      "edge"
-    ]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.status", {
-      sessionId: "session:matrix",
-      profile: "chrome-relay",
-      authToken: "cli-token",
-      [DAEMON_STARTUP_ARGUMENT]: {
-        managedLocal: {
-          browserName: "chromium",
-          channel: "msedge"
-        }
-      }
-    });
-  });
-
-  it("throws for upload-arm when files are missing", async () => {
-    await expect(runUploadArmCommand(["target:1"]))
-      .rejects.toThrow("Missing required argument: files.");
-
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    {
-      name: "memory-resolve --profile-id",
-      run: async () => await runMemoryResolveCommand(["forum.example", "open_profile", "--profile-id", "--bad"]),
-      expectedMessage: "Missing value for --profile-id."
-    },
-    {
-      name: "memory-list --domain",
-      run: async () => await runMemoryListCommand(["--domain", "--bad"]),
-      expectedMessage: "Missing value for --domain."
-    },
-    {
-      name: "memory-list --profile-id",
-      run: async () => await runMemoryListCommand(["--profile-id", "--bad"]),
-      expectedMessage: "Missing value for --profile-id."
-    },
-    {
-      name: "memory-list --intent-key",
-      run: async () => await runMemoryListCommand(["--intent-key", "--bad"]),
-      expectedMessage: "Missing value for --intent-key."
-    },
-    {
-      name: "memory-upsert --profile-id",
-      run: async () =>
-        await runMemoryUpsertCommand([
-          "forum.example",
-          "open_profile",
-          "--signals-json",
-          "[]",
-          "--profile-id",
-          "--bad"
-        ]),
-      expectedMessage: "Missing value for --profile-id."
-    },
-    {
-      name: "memory-upsert --signals-json",
-      run: async () =>
-        await runMemoryUpsertCommand(["forum.example", "open_profile", "--signals-json", "--bad"]),
-      expectedMessage: "Missing value for --signals-json."
-    }
-  ])("rejects flag token as option value for $name", async ({ run, expectedMessage }) => {
-    await expect(run()).rejects.toThrow(expectedMessage);
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("accepts ttlDays value 0", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runMemoryTtlSetCommand(["0"]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.memory.ttl.set", {
-      ...BASE_ARGS,
-      ttlDays: 0
-    });
-  });
-
-  it.each(["1.9", "7days", "-1"])(
-    "rejects non-strict non-negative integer ttlDays value: %s",
-    async (ttlValue) => {
-      await expect(runMemoryTtlSetCommand([ttlValue]))
-        .rejects.toThrow("ttlDays must be a non-negative integer string.");
-
-      expect(callDaemonToolMock).not.toHaveBeenCalled();
-    }
-  );
-});