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

package/apps/browserctl/src/commands/act.test.ts

@@ -0,0 +1,71 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { callDaemonToolMock } = vi.hoisted(() => ({
+  callDaemonToolMock: vi.fn()
+}));
+
+vi.mock("../daemon-client", () => ({
+  callDaemonTool: callDaemonToolMock
+}));
+
+import { runActCommand } from "./act";
+
+afterEach(() => {
+  callDaemonToolMock.mockReset();
+});
+
+describe("runActCommand", () => {
+  it("forwards --payload-json into action payload", async () => {
+    callDaemonToolMock.mockResolvedValue({
+      ok: true
+    });
+
+    await runActCommand([
+      "click",
+      "target:1",
+      "--payload-json",
+      "{\"selector\":\"#submit\",\"delayMs\":200}"
+    ]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.act", {
+      sessionId: "cli:local",
+      targetId: "target:1",
+      action: {
+        type: "click",
+        payload: {
+          selector: "#submit",
+          delayMs: 200
+        }
+      }
+    });
+  });
+
+  it("throws when --payload-json value is missing", async () => {
+    await expect(runActCommand(["click", "target:1", "--payload-json"])).rejects.toThrow(
+      "Missing value for --payload-json."
+    );
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it("throws when --payload-json is invalid JSON", async () => {
+    await expect(
+      runActCommand(["click", "target:1", "--payload-json", "{not-json}"])
+    ).rejects.toThrow("Invalid JSON for --payload-json:");
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it("throws when --payload-json is not a JSON object", async () => {
+    await expect(runActCommand(["click", "target:1", "--payload-json", "[1,2,3]"])).rejects.toThrow(
+      "--payload-json must decode to a JSON object."
+    );
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it("throws on unknown act options", async () => {
+    await expect(runActCommand(["click", "target:1", "--payload", "{}"])).rejects.toThrow(
+      "Unknown act option: --payload"
+    );
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -3,17 +3,61 @@ import { buildToolArguments, parseCommandContext, requirePositionalArg } from ".
 
 export type ActCommandResult = Record<string, unknown>;
 
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parseActPayload(tokens: string[]): Record<string, unknown> | undefined {
+  let payloadJson: string | undefined;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token === "--payload-json") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --payload-json.");
+      }
+
+      payloadJson = value;
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown act option: ${token}`);
+  }
+
+  if (payloadJson === undefined) {
+    return undefined;
+  }
+
+  let parsedPayload: unknown;
+  try {
+    parsedPayload = JSON.parse(payloadJson);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON for --payload-json: ${message}`);
+  }
+
+  if (!isObjectRecord(parsedPayload)) {
+    throw new Error("--payload-json must decode to a JSON object.");
+  }
+
+  return parsedPayload;
+}
+
 export async function runActCommand(args: string[]): Promise<ActCommandResult> {
   const context = parseCommandContext(args);
   const actionType = requirePositionalArg(context, 0, "actionType");
   const targetId = requirePositionalArg(context, 1, "targetId");
+  const payload = parseActPayload(context.positional.slice(2));
 
   return await callDaemonTool<ActCommandResult>(
     "browser.act",
     buildToolArguments(context, {
       targetId,
       action: {
-        type: actionType
+        type: actionType,
+        ...(payload !== undefined ? { payload } : {})
       }
     })
   );

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

@@ -23,11 +23,24 @@ 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";
@@ -36,7 +49,11 @@ 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;
@@ -104,6 +121,25 @@ const CASES: WrapperCase[] = [
       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"]),
@@ -162,6 +198,91 @@ const CASES: WrapperCase[] = [
       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 () =>
@@ -330,6 +451,120 @@ const CASES: WrapperCase[] = [
       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
+    }
   }
 ];
 
@@ -383,4 +618,71 @@ describe("command wrappers", () => {
 
     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();
+    }
+  );
 });

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

@@ -0,0 +1,102 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { callDaemonToolMock } = vi.hoisted(() => ({
+  callDaemonToolMock: vi.fn()
+}));
+
+vi.mock("../daemon-client", () => ({
+  callDaemonTool: callDaemonToolMock
+}));
+
+import { runConsoleListCommand } from "./console-list";
+
+afterEach(() => {
+  callDaemonToolMock.mockReset();
+});
+
+describe("runConsoleListCommand", () => {
+  it("forwards filter options", async () => {
+    callDaemonToolMock.mockResolvedValue({ ok: true });
+
+    await runConsoleListCommand([
+      "target:1",
+      "--type",
+      "error",
+      "--contains",
+      "timeout",
+      "--since",
+      "2026-01-01T00:00:00.000Z",
+      "--limit",
+      "20"
+    ]);
+
+    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
+    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.console.list", {
+      sessionId: "cli:local",
+      targetId: "target:1",
+      type: "error",
+      contains: "timeout",
+      since: "2026-01-01T00:00:00.000Z",
+      limit: 20
+    });
+  });
+
+  it.each([
+    {
+      label: "--type",
+      args: ["target:1", "--type"],
+      message: "Missing value for --type."
+    },
+    {
+      label: "--contains",
+      args: ["target:1", "--contains"],
+      message: "Missing value for --contains."
+    },
+    {
+      label: "--since",
+      args: ["target:1", "--since"],
+      message: "Missing value for --since."
+    },
+    {
+      label: "--limit",
+      args: ["target:1", "--limit"],
+      message: "Missing value for --limit."
+    }
+  ])("throws when $label is missing a value", async ({ args, message }) => {
+    await expect(runConsoleListCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    {
+      label: "empty --type",
+      args: ["target:1", "--type", " "],
+      message: "--type must be a non-empty string."
+    },
+    {
+      label: "empty --contains",
+      args: ["target:1", "--contains", " "],
+      message: "--contains must be a non-empty string."
+    },
+    {
+      label: "invalid --limit",
+      args: ["target:1", "--limit", "0"],
+      message: "--limit must be a positive integer."
+    },
+    {
+      label: "non-strict --limit text",
+      args: ["target:1", "--limit", "20rows"],
+      message: "--limit must be a positive integer."
+    }
+  ])("throws on invalid option value: $label", async ({ args, message }) => {
+    await expect(runConsoleListCommand(args)).rejects.toThrow(message);
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+
+  it("throws on unknown option token", async () => {
+    await expect(runConsoleListCommand(["target:1", "--unknown"]))
+      .rejects.toThrow("Unknown console-list option: --unknown");
+
+    expect(callDaemonToolMock).not.toHaveBeenCalled();
+  });
+});

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

@@ -7,14 +7,102 @@ export type ConsoleListCommandResult = {
   entries: 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 parseConsoleOptions(tokens: string[]): {
+  type?: string;
+  contains?: string;
+  since?: string;
+  limit?: number;
+} {
+  let type: string | undefined;
+  let contains: string | undefined;
+  let since: string | undefined;
+  let limit: number | undefined;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+
+    if (token === "--type") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --type.");
+      }
+      const trimmed = value.trim();
+      if (trimmed.length === 0) {
+        throw new Error("--type must be a non-empty string.");
+      }
+      type = trimmed;
+      index += 1;
+      continue;
+    }
+
+    if (token === "--contains") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --contains.");
+      }
+      const trimmed = value.trim();
+      if (trimmed.length === 0) {
+        throw new Error("--contains must be a non-empty string.");
+      }
+      contains = trimmed;
+      index += 1;
+      continue;
+    }
+
+    if (token === "--since") {
+      const value = tokens[index + 1];
+      if (value === undefined) {
+        throw new Error("Missing value for --since.");
+      }
+      const trimmed = value.trim();
+      if (trimmed.length === 0) {
+        throw new Error("--since must be a non-empty ISO timestamp.");
+      }
+      since = trimmed;
+      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 console-list option: ${token}`);
+  }
+
+  return {
+    ...(type !== undefined ? { type } : {}),
+    ...(contains !== undefined ? { contains } : {}),
+    ...(since !== undefined ? { since } : {}),
+    ...(limit !== undefined ? { limit } : {})
+  };
+}
+
 export async function runConsoleListCommand(args: string[]): Promise<ConsoleListCommandResult> {
   const context = parseCommandContext(args);
   const targetId = requirePositionalArg(context, 0, "targetId");
+  const options = parseConsoleOptions(context.positional.slice(1));
 
   return await callDaemonTool<ConsoleListCommandResult>(
     "browser.console.list",
     buildToolArguments(context, {
-      targetId
+      targetId,
+      ...options
     })
   );
 }