@flrande/browserctl 0.5.0 → 0.6.0

package/apps/browserctl/src/commands/memory-upsert.ts

@@ -1,142 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type MemoryUpsertCommandResult = Record<string, unknown>;
-
-type MemoryUpsertOptions = {
-  profileId?: string;
-  signals: unknown[];
-  confidence?: number;
-  confirmed?: boolean;
-};
-
-function requireOptionValue(tokens: string[], index: number, optionName: string): string {
-  const value = tokens[index + 1];
-  if (value === undefined || value.startsWith("--")) {
-    throw new Error(`Missing value for ${optionName}.`);
-  }
-
-  return value;
-}
-
-function parseNumber(value: string, optionName: string): number {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) {
-    throw new Error(`${optionName} must be a valid number.`);
-  }
-
-  return parsed;
-}
-
-function parseBoolean(value: string, optionName: string): boolean {
-  const normalizedValue = value.trim().toLowerCase();
-  if (normalizedValue === "true") {
-    return true;
-  }
-
-  if (normalizedValue === "false") {
-    return false;
-  }
-
-  throw new Error(`${optionName} must be true or false when provided with a value.`);
-}
-
-function parseSignalsJson(value: string): unknown[] {
-  let parsedValue: unknown;
-  try {
-    parsedValue = JSON.parse(value);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Invalid JSON for --signals-json: ${message}`);
-  }
-
-  if (!Array.isArray(parsedValue)) {
-    throw new Error("--signals-json must decode to a JSON array.");
-  }
-
-  return parsedValue;
-}
-
-function parseUpsertOptions(tokens: string[]): MemoryUpsertOptions {
-  let profileId: string | undefined;
-  let signals: unknown[] | undefined;
-  let confidence: number | undefined;
-  let confirmed: boolean | undefined;
-
-  for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index];
-    if (token === "--profile-id") {
-      const value = requireOptionValue(tokens, index, "--profile-id");
-
-      const trimmedValue = value.trim();
-      if (trimmedValue.length === 0) {
-        throw new Error("--profile-id must be a non-empty string.");
-      }
-
-      profileId = trimmedValue;
-      index += 1;
-      continue;
-    }
-
-    if (token === "--signals-json") {
-      const value = requireOptionValue(tokens, index, "--signals-json");
-
-      signals = parseSignalsJson(value);
-      index += 1;
-      continue;
-    }
-
-    if (token === "--confidence") {
-      const value = requireOptionValue(tokens, index, "--confidence");
-
-      confidence = parseNumber(value, "--confidence");
-      index += 1;
-      continue;
-    }
-
-    if (token === "--confirmed") {
-      const maybeValue = tokens[index + 1];
-      if (maybeValue === undefined || maybeValue.startsWith("--")) {
-        confirmed = true;
-        continue;
-      }
-
-      confirmed = parseBoolean(maybeValue, "--confirmed");
-      index += 1;
-      continue;
-    }
-
-    throw new Error(`Unknown memory-upsert option: ${token}`);
-  }
-
-  if (signals === undefined) {
-    throw new Error("Missing value for --signals-json.");
-  }
-
-  return {
-    signals,
-    ...(profileId !== undefined ? { profileId } : {}),
-    ...(confidence !== undefined ? { confidence } : {}),
-    ...(confirmed !== undefined ? { confirmed } : {})
-  };
-}
-
-export async function runMemoryUpsertCommand(args: string[]): Promise<MemoryUpsertCommandResult> {
-  const context = parseCommandContext(args);
-  const domain = requirePositionalArg(context, 0, "domain");
-  const intentKey = requirePositionalArg(context, 1, "intentKey");
-  const options = parseUpsertOptions(context.positional.slice(2));
-  const profileId = options.profileId ?? context.profile ?? "default";
-
-  return await callDaemonTool<MemoryUpsertCommandResult>(
-    "browser.memory.upsert",
-    buildToolArguments(context, {
-      domain,
-      profileId,
-      intentKey,
-      signals: options.signals,
-      ...(options.confidence !== undefined ? { confidence: options.confidence } : {}),
-      ...(options.confirmed !== undefined ? { confirmed: options.confirmed } : {})
-    })
-  );
-}

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

@@ -1,110 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { callDaemonToolMock } = vi.hoisted(() => ({
-  callDaemonToolMock: vi.fn()
-}));
-
-vi.mock("../daemon-client", () => ({
-  callDaemonTool: callDaemonToolMock
-}));
-
-import { runNetworkListCommand } from "./network-list";
-
-afterEach(() => {
-  callDaemonToolMock.mockReset();
-});
-
-describe("runNetworkListCommand", () => {
-  it("forwards filter options", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runNetworkListCommand([
-      "target:1",
-      "--url-contains",
-      "/api/",
-      "--method",
-      "post",
-      "--status",
-      "201",
-      "--since",
-      "2026-01-01T00:00:00.000Z",
-      "--limit",
-      "50"
-    ]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.network.list", {
-      sessionId: "cli:local",
-      targetId: "target:1",
-      urlContains: "/api/",
-      method: "POST",
-      status: 201,
-      since: "2026-01-01T00:00:00.000Z",
-      limit: 50
-    });
-  });
-
-  it.each([
-    {
-      label: "--url-contains",
-      args: ["target:1", "--url-contains"],
-      message: "Missing value for --url-contains."
-    },
-    {
-      label: "--method",
-      args: ["target:1", "--method"],
-      message: "Missing value for --method."
-    },
-    {
-      label: "--status",
-      args: ["target:1", "--status"],
-      message: "Missing value for --status."
-    },
-    {
-      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(runNetworkListCommand(args)).rejects.toThrow(message);
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    {
-      label: "empty --url-contains",
-      args: ["target:1", "--url-contains", " "],
-      message: "--url-contains must be a non-empty string."
-    },
-    {
-      label: "status <= 0",
-      args: ["target:1", "--status", "0"],
-      message: "--status must be a positive integer."
-    },
-    {
-      label: "status non-strict integer text",
-      args: ["target:1", "--status", "200ok"],
-      message: "--status must be a positive integer."
-    },
-    {
-      label: "limit <= 0",
-      args: ["target:1", "--limit", "0"],
-      message: "--limit must be a positive integer."
-    }
-  ])("throws on invalid option value: $label", async ({ args, message }) => {
-    await expect(runNetworkListCommand(args)).rejects.toThrow(message);
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-
-  it("throws on unknown option token", async () => {
-    await expect(runNetworkListCommand(["target:1", "--unknown"]))
-      .rejects.toThrow("Unknown network-list option: --unknown");
-
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,112 +0,0 @@
-import { callDaemonTool } from "../daemon-client";
-import { buildToolArguments, parseCommandContext, requirePositionalArg } from "./common";
-
-export type NetworkListCommandResult = 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 parseNetworkListOptions(tokens: string[]): {
-  urlContains?: string;
-  method?: string;
-  status?: number;
-  since?: string;
-  limit?: number;
-} {
-  let urlContains: string | undefined;
-  let method: string | undefined;
-  let status: number | undefined;
-  let since: string | undefined;
-  let limit: number | undefined;
-
-  for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index];
-    if (token === "--url-contains") {
-      const value = tokens[index + 1];
-      if (value === undefined) {
-        throw new Error("Missing value for --url-contains.");
-      }
-      const trimmed = value.trim();
-      if (trimmed.length === 0) {
-        throw new Error("--url-contains must be a non-empty string.");
-      }
-      urlContains = trimmed;
-      index += 1;
-      continue;
-    }
-
-    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 === "--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 network-list option: ${token}`);
-  }
-
-  return {
-    ...(urlContains !== undefined ? { urlContains } : {}),
-    ...(method !== undefined ? { method } : {}),
-    ...(status !== undefined ? { status } : {}),
-    ...(since !== undefined ? { since } : {}),
-    ...(limit !== undefined ? { limit } : {})
-  };
-}
-
-export async function runNetworkListCommand(args: string[]): Promise<NetworkListCommandResult> {
-  const context = parseCommandContext(args);
-  const targetId = requirePositionalArg(context, 0, "targetId");
-  const options = parseNetworkListOptions(context.positional.slice(1));
-
-  return await callDaemonTool<NetworkListCommandResult>(
-    "browser.network.list",
-    buildToolArguments(context, {
-      targetId,
-      ...options
-    })
-  );
-}

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

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

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

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

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

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

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

@@ -1,16 +0,0 @@
-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/session-drop.test.ts

@@ -1,36 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const { callDaemonToolMock } = vi.hoisted(() => ({
-  callDaemonToolMock: vi.fn()
-}));
-
-vi.mock("../daemon-client", () => ({
-  callDaemonTool: callDaemonToolMock
-}));
-
-import { runSessionDropCommand } from "./session-drop";
-
-afterEach(() => {
-  callDaemonToolMock.mockReset();
-});
-
-describe("runSessionDropCommand", () => {
-  it("forwards session id to drop", async () => {
-    callDaemonToolMock.mockResolvedValue({ ok: true });
-
-    await runSessionDropCommand(["tenant-a:task-1"]);
-
-    expect(callDaemonToolMock).toHaveBeenCalledTimes(1);
-    expect(callDaemonToolMock).toHaveBeenCalledWith("browser.session.drop", {
-      sessionId: "cli:local",
-      sessionIdToDelete: "tenant-a:task-1"
-    });
-  });
-
-  it("throws when session id is missing", async () => {
-    await expect(runSessionDropCommand([])).rejects.toThrow(
-      "Missing required argument: sessionId."
-    );
-    expect(callDaemonToolMock).not.toHaveBeenCalled();
-  });
-});

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

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