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

package/apps/browserctl/src/main.dispatch.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import * as a11ySnapshotCommand from "./commands/a11y-snapshot";
 import * as consoleListCommand from "./commands/console-list";
@@ -14,17 +14,25 @@ import * as downloadWaitCommand from "./commands/download-wait";
 import * as elementScreenshotCommand from "./commands/element-screenshot";
 import * as frameListCommand from "./commands/frame-list";
 import * as frameSnapshotCommand from "./commands/frame-snapshot";
+import * as harExportCommand from "./commands/har-export";
+import * as networkListCommand from "./commands/network-list";
 import * as networkWaitForCommand from "./commands/network-wait-for";
 import * as profileListCommand from "./commands/profile-list";
 import * as profileUseCommand from "./commands/profile-use";
 import * as responseBodyCommand from "./commands/response-body";
+import * as sessionDropCommand from "./commands/session-drop";
+import * as sessionListCommand from "./commands/session-list";
 import * as snapshotCommand from "./commands/snapshot";
 import * as storageGetCommand from "./commands/storage-get";
 import * as storageSetCommand from "./commands/storage-set";
 import * as tabCloseCommand from "./commands/tab-close";
 import * as tabFocusCommand from "./commands/tab-focus";
 import * as tabOpenCommand from "./commands/tab-open";
+import * as traceGetCommand from "./commands/trace-get";
 import * as uploadArmCommand from "./commands/upload-arm";
+import * as waitElementCommand from "./commands/wait-element";
+import * as waitTextCommand from "./commands/wait-text";
+import * as waitUrlCommand from "./commands/wait-url";
 import { EXIT_CODES, runCli } from "./main";
 
 function createIoCapture() {
@@ -50,6 +58,9 @@ function createIoCapture() {
   };
 }
 
+const ORIGINAL_BROWSERCTL_AUTH_TOKEN = process.env.BROWSERCTL_AUTH_TOKEN;
+const ORIGINAL_BROWSERCTL_BROWSER = process.env.BROWSERCTL_BROWSER;
+
 type DispatchCase = {
   command: string;
   commandArgs: string[];
@@ -57,6 +68,13 @@ type DispatchCase = {
   handlerName: string;
 };
 
+type MemoryDispatchCase = {
+  command: string;
+  commandArgs: string[];
+  expectedTool: string;
+  expectedArgs: Record<string, unknown>;
+};
+
 const COMMAND_DISPATCH_CASES: DispatchCase[] = [
   {
     command: "a11y-snapshot",
@@ -136,6 +154,18 @@ const COMMAND_DISPATCH_CASES: DispatchCase[] = [
     moduleRef: frameSnapshotCommand as unknown as Record<string, unknown>,
     handlerName: "runFrameSnapshotCommand"
   },
+  {
+    command: "har-export",
+    commandArgs: ["target:1"],
+    moduleRef: harExportCommand as unknown as Record<string, unknown>,
+    handlerName: "runHarExportCommand"
+  },
+  {
+    command: "network-list",
+    commandArgs: ["target:1"],
+    moduleRef: networkListCommand as unknown as Record<string, unknown>,
+    handlerName: "runNetworkListCommand"
+  },
   {
     command: "network-wait-for",
     commandArgs: ["target:1", "/api", "1000"],
@@ -160,6 +190,18 @@ const COMMAND_DISPATCH_CASES: DispatchCase[] = [
     moduleRef: responseBodyCommand as unknown as Record<string, unknown>,
     handlerName: "runResponseBodyCommand"
   },
+  {
+    command: "session-drop",
+    commandArgs: ["tenant-a:job-1"],
+    moduleRef: sessionDropCommand as unknown as Record<string, unknown>,
+    handlerName: "runSessionDropCommand"
+  },
+  {
+    command: "session-list",
+    commandArgs: ["--tenant", "ops", "--limit", "10"],
+    moduleRef: sessionListCommand as unknown as Record<string, unknown>,
+    handlerName: "runSessionListCommand"
+  },
   {
     command: "snapshot",
     commandArgs: ["target:1"],
@@ -196,6 +238,30 @@ const COMMAND_DISPATCH_CASES: DispatchCase[] = [
     moduleRef: tabOpenCommand as unknown as Record<string, unknown>,
     handlerName: "runTabOpenCommand"
   },
+  {
+    command: "trace-get",
+    commandArgs: ["--limit", "10"],
+    moduleRef: traceGetCommand as unknown as Record<string, unknown>,
+    handlerName: "runTraceGetCommand"
+  },
+  {
+    command: "wait-element",
+    commandArgs: ["target:1", "#root", "1500"],
+    moduleRef: waitElementCommand as unknown as Record<string, unknown>,
+    handlerName: "runWaitElementCommand"
+  },
+  {
+    command: "wait-text",
+    commandArgs: ["target:1", "ready"],
+    moduleRef: waitTextCommand as unknown as Record<string, unknown>,
+    handlerName: "runWaitTextCommand"
+  },
+  {
+    command: "wait-url",
+    commandArgs: ["target:1", "/dashboard"],
+    moduleRef: waitUrlCommand as unknown as Record<string, unknown>,
+    handlerName: "runWaitUrlCommand"
+  },
   {
     command: "upload-arm",
     commandArgs: ["target:1", "upload.txt"],
@@ -204,8 +270,123 @@ const COMMAND_DISPATCH_CASES: DispatchCase[] = [
   }
 ];
 
+const MEMORY_DISPATCH_CASES: MemoryDispatchCase[] = [
+  {
+    command: "memory-status",
+    commandArgs: [],
+    expectedTool: "browser.memory.status",
+    expectedArgs: {
+      sessionId: "cli:local"
+    }
+  },
+  {
+    command: "memory-mode-set",
+    commandArgs: ["ask"],
+    expectedTool: "browser.memory.mode.set",
+    expectedArgs: {
+      sessionId: "cli:local",
+      mode: "ask"
+    }
+  },
+  {
+    command: "memory-resolve",
+    commandArgs: ["forum.example", "open_profile"],
+    expectedTool: "browser.memory.resolve",
+    expectedArgs: {
+      sessionId: "cli:local",
+      domain: "forum.example",
+      profileId: "default",
+      intentKey: "open_profile"
+    }
+  },
+  {
+    command: "memory-upsert",
+    commandArgs: [
+      "forum.example",
+      "open_profile",
+      "--signals-json",
+      "[{\"kind\":\"urlPattern\",\"value\":\"/profile\"}]",
+      "--confidence",
+      "0.9",
+      "--confirmed"
+    ],
+    expectedTool: "browser.memory.upsert",
+    expectedArgs: {
+      sessionId: "cli:local",
+      domain: "forum.example",
+      profileId: "default",
+      intentKey: "open_profile",
+      signals: [{ kind: "urlPattern", value: "/profile" }],
+      confidence: 0.9,
+      confirmed: true
+    }
+  },
+  {
+    command: "memory-list",
+    commandArgs: ["--domain", "forum.example", "--profile-id", "managed", "--intent-key", "open_profile"],
+    expectedTool: "browser.memory.list",
+    expectedArgs: {
+      sessionId: "cli:local",
+      domain: "forum.example",
+      profileId: "managed",
+      intentKey: "open_profile"
+    }
+  },
+  {
+    command: "memory-inspect",
+    commandArgs: ["memory:1"],
+    expectedTool: "browser.memory.inspect",
+    expectedArgs: {
+      sessionId: "cli:local",
+      id: "memory:1"
+    }
+  },
+  {
+    command: "memory-delete",
+    commandArgs: ["memory:1"],
+    expectedTool: "browser.memory.delete",
+    expectedArgs: {
+      sessionId: "cli:local",
+      id: "memory:1"
+    }
+  },
+  {
+    command: "memory-purge",
+    commandArgs: [],
+    expectedTool: "browser.memory.purge",
+    expectedArgs: {
+      sessionId: "cli:local"
+    }
+  },
+  {
+    command: "memory-ttl-set",
+    commandArgs: ["7"],
+    expectedTool: "browser.memory.ttl.set",
+    expectedArgs: {
+      sessionId: "cli:local",
+      ttlDays: 7
+    }
+  }
+];
+
 afterEach(() => {
   vi.restoreAllMocks();
+  if (ORIGINAL_BROWSERCTL_AUTH_TOKEN === undefined) {
+    delete process.env.BROWSERCTL_AUTH_TOKEN;
+  } else {
+    process.env.BROWSERCTL_AUTH_TOKEN = ORIGINAL_BROWSERCTL_AUTH_TOKEN;
+  }
+
+  if (ORIGINAL_BROWSERCTL_BROWSER === undefined) {
+    delete process.env.BROWSERCTL_BROWSER;
+  } else {
+    process.env.BROWSERCTL_BROWSER = ORIGINAL_BROWSERCTL_BROWSER;
+  }
+});
+
+beforeEach(() => {
+  delete process.env.BROWSERCTL_AUTH_TOKEN;
+  delete process.env.BROWSERCTL_BROWSER;
 });
 
 describe("cli dispatch matrix", () => {
@@ -253,4 +434,28 @@ describe("cli dispatch matrix", () => {
       }
     });
   });
+
+  it.each(MEMORY_DISPATCH_CASES)(
+    "dispatches $command to $expectedTool",
+    async ({ command, commandArgs, expectedTool, expectedArgs }) => {
+      const callDaemonToolSpy = vi.spyOn(daemonClient, "callDaemonTool").mockResolvedValue({
+        ok: true
+      });
+      const { io, state } = createIoCapture();
+
+      const exitCode = await runCli([command, ...commandArgs, "--json"], io);
+
+      expect(exitCode).toBe(EXIT_CODES.OK);
+      expect(state.stderr).toBe("");
+      expect(callDaemonToolSpy).toHaveBeenCalledTimes(1);
+      expect(callDaemonToolSpy).toHaveBeenCalledWith(expectedTool, expectedArgs);
+      expect(JSON.parse(state.stdout)).toEqual({
+        ok: true,
+        command,
+        data: {
+          ok: true
+        }
+      });
+    }
+  );
 });

package/apps/browserctl/src/main.test.ts

@@ -39,6 +39,22 @@ describe("cli", () => {
     expect(parseArgs(["status"]).command).toBe("status");
   });
 
+  it("treats removed template command as unknown", () => {
+    expect(parseArgs(["template-run"]).error).toBe("Unknown command: template-run");
+  });
+
+  it("parses memory-status command", () => {
+    expect(parseArgs(["memory-status"]).command).toBe("memory-status");
+  });
+
+  it("parses memory-mode-set command", () => {
+    expect(parseArgs(["memory-mode-set", "ask"]).command).toBe("memory-mode-set");
+  });
+
+  it("parses memory-resolve command", () => {
+    expect(parseArgs(["memory-resolve", "forum.example", "open_profile"]).command).toBe("memory-resolve");
+  });
+
   it("preserves unknown flags and '--' separator as command args", () => {
     expect(parseArgs(["status", "--profile", "default", "--", "--raw"])).toEqual({
       command: "status",
@@ -122,6 +138,9 @@ describe("cli", () => {
     expect(state.stderr).toBe("");
     expect(state.stdout).toContain("Usage:");
     expect(state.stdout).toContain("browserctl help [command]");
+    expect(state.stdout).toContain("session-list [--tenant <tenant>] [--limit <n>]");
+    expect(state.stdout).toContain("memory-status");
+    expect(state.stdout).toContain("memory-mode-set <mode>");
   });
 
   it("writes JSON help output when --json is provided", async () => {
@@ -165,6 +184,17 @@ describe("cli", () => {
     expect(state.stdout).toContain("browserctl tab-open <url>");
   });
 
+  it("shows payload option in act command help", async () => {
+    const { io, state } = createIoCapture();
+
+    const exitCode = await runCli(["help", "act"], io);
+
+    expect(exitCode).toBe(EXIT_CODES.OK);
+    expect(state.stderr).toBe("");
+    expect(state.stdout).toContain("browserctl act <actionType> <targetId> [--payload-json <json>]");
+    expect(state.stdout).toContain("--payload-json <json>");
+  });
+
   it("returns INVALID_ARGS for unknown help topic", async () => {
     const { io, state } = createIoCapture();
 

package/apps/browserctl/src/main.ts

@@ -14,12 +14,25 @@ import { runDownloadWaitCommand } from "./commands/download-wait";
 import { runElementScreenshotCommand } from "./commands/element-screenshot";
 import { runFrameListCommand } from "./commands/frame-list";
 import { runFrameSnapshotCommand } from "./commands/frame-snapshot";
+import { runHarExportCommand } from "./commands/har-export";
+import { runMemoryDeleteCommand } from "./commands/memory-delete";
+import { runMemoryInspectCommand } from "./commands/memory-inspect";
+import { runMemoryListCommand } from "./commands/memory-list";
+import { runMemoryModeSetCommand } from "./commands/memory-mode-set";
+import { runMemoryPurgeCommand } from "./commands/memory-purge";
+import { runMemoryResolveCommand } from "./commands/memory-resolve";
+import { runMemoryStatusCommand } from "./commands/memory-status";
+import { runMemoryTtlSetCommand } from "./commands/memory-ttl-set";
+import { runMemoryUpsertCommand } from "./commands/memory-upsert";
+import { runNetworkListCommand } from "./commands/network-list";
 import { runNetworkWaitForCommand } from "./commands/network-wait-for";
 import { parseCommandContext } from "./commands/common";
 import { runProfileListCommand } from "./commands/profile-list";
 import { runProfileUseCommand } from "./commands/profile-use";
 import { runResponseBodyCommand } from "./commands/response-body";
 import { runScreenshotCommand } from "./commands/screenshot";
+import { runSessionDropCommand } from "./commands/session-drop";
+import { runSessionListCommand } from "./commands/session-list";
 import { runSnapshotCommand } from "./commands/snapshot";
 import { runStatusCommand } from "./commands/status";
 import { runStorageGetCommand } from "./commands/storage-get";
@@ -28,7 +41,11 @@ import { runTabCloseCommand } from "./commands/tab-close";
 import { runTabFocusCommand } from "./commands/tab-focus";
 import { runTabOpenCommand } from "./commands/tab-open";
 import { runTabsCommand } from "./commands/tabs";
+import { runTraceGetCommand } from "./commands/trace-get";
 import { runUploadArmCommand } from "./commands/upload-arm";
+import { runWaitElementCommand } from "./commands/wait-element";
+import { runWaitTextCommand } from "./commands/wait-text";
+import { runWaitUrlCommand } from "./commands/wait-url";
 import { ensureDaemonRunning, getDaemonStatus, stopDaemon } from "./daemon-client";
 
 export const EXIT_CODES = {
@@ -51,6 +68,11 @@ export type CommandName =
   | "dom-query-all"
   | "element-screenshot"
   | "a11y-snapshot"
+  | "wait-element"
+  | "wait-text"
+  | "wait-url"
+  | "network-list"
+  | "har-export"
   | "network-wait-for"
   | "cookie-get"
   | "cookie-set"
@@ -66,6 +88,18 @@ export type CommandName =
   | "download-wait"
   | "console-list"
   | "response-body"
+  | "session-list"
+  | "session-drop"
+  | "trace-get"
+  | "memory-status"
+  | "memory-resolve"
+  | "memory-upsert"
+  | "memory-list"
+  | "memory-inspect"
+  | "memory-delete"
+  | "memory-purge"
+  | "memory-mode-set"
+  | "memory-ttl-set"
   | "daemon-status"
   | "daemon-start"
   | "daemon-stop";
@@ -94,6 +128,11 @@ const VALID_COMMANDS: ReadonlySet<CommandName> = new Set([
   "dom-query-all",
   "element-screenshot",
   "a11y-snapshot",
+  "wait-element",
+  "wait-text",
+  "wait-url",
+  "network-list",
+  "har-export",
   "network-wait-for",
   "cookie-get",
   "cookie-set",
@@ -109,6 +148,18 @@ const VALID_COMMANDS: ReadonlySet<CommandName> = new Set([
   "download-wait",
   "console-list",
   "response-body",
+  "session-list",
+  "session-drop",
+  "trace-get",
+  "memory-status",
+  "memory-resolve",
+  "memory-upsert",
+  "memory-list",
+  "memory-inspect",
+  "memory-delete",
+  "memory-purge",
+  "memory-mode-set",
+  "memory-ttl-set",
   "daemon-status",
   "daemon-start",
   "daemon-stop"
@@ -172,6 +223,28 @@ const COMMAND_HELP: Readonly<Record<CommandName, CommandHelpEntry>> = {
     usage: "a11y-snapshot <targetId> [selector]",
     description: "Get accessibility tree snapshot."
   },
+  "wait-element": {
+    usage: "wait-element <targetId> <selector> [--timeout-ms <ms>] [--poll-ms <ms>]",
+    description: "Wait until selector appears in the page."
+  },
+  "wait-text": {
+    usage: "wait-text <targetId> <text> [--selector <selector>] [--timeout-ms <ms>] [--poll-ms <ms>]",
+    description: "Wait until expected text appears."
+  },
+  "wait-url": {
+    usage: "wait-url <targetId> <urlPattern> [--timeout-ms <ms>] [--poll-ms <ms>]",
+    description: "Wait until current URL matches a pattern."
+  },
+  "network-list": {
+    usage:
+      "network-list <targetId> [--url-contains <text>] [--method <METHOD>] [--status <CODE>] [--since <ISO>] [--limit <n>]",
+    description: "List captured network requests with filters."
+  },
+  "har-export": {
+    usage:
+      "har-export <targetId> [--include-bodies] [--url-contains <text>] [--method <METHOD>] [--status <CODE>] [--since <ISO>] [--limit <n>]",
+    description: "Export captured network requests as HAR."
+  },
   "network-wait-for": {
     usage:
       "network-wait-for <targetId> <urlPattern> [--method <METHOD>] [--status <CODE>] [--timeout-ms <ms>] [--poll-ms <ms>]",
@@ -206,7 +279,7 @@ const COMMAND_HELP: Readonly<Record<CommandName, CommandHelpEntry>> = {
     description: "Snapshot one frame subtree."
   },
   act: {
-    usage: "act <actionType> <targetId>",
+    usage: "act <actionType> <targetId> [--payload-json <json>]",
     description: "Execute high-level action against a tab."
   },
   "upload-arm": {
@@ -226,13 +299,62 @@ const COMMAND_HELP: Readonly<Record<CommandName, CommandHelpEntry>> = {
     description: "Wait for next download and persist file."
   },
   "console-list": {
-    usage: "console-list <targetId>",
+    usage: "console-list <targetId> [--type <type>] [--contains <text>] [--since <ISO>] [--limit <n>]",
     description: "List collected console events."
   },
   "response-body": {
     usage: "response-body <targetId> <requestId>",
     description: "Read response body for a captured request."
   },
+  "session-list": {
+    usage: "session-list [--tenant <tenant>] [--limit <n>]",
+    description: "List active sessions for governance and multi-tenant inspection."
+  },
+  "session-drop": {
+    usage: "session-drop <sessionId>",
+    description: "Drop one session state by id."
+  },
+  "trace-get": {
+    usage: "trace-get [--limit <n>]",
+    description: "Read task-level trace steps and key responses for current session."
+  },
+  "memory-status": {
+    usage: "memory-status",
+    description: "Read navigation memory runtime status and counters."
+  },
+  "memory-resolve": {
+    usage: "memory-resolve <domain> <intentKey> [--profile-id <profileId>]",
+    description: "Resolve a memory entry for a domain/intent key."
+  },
+  "memory-upsert": {
+    usage:
+      "memory-upsert <domain> <intentKey> --signals-json <json> [--profile-id <profileId>] [--confidence <n>] [--confirmed [true|false]]",
+    description: "Create or update one memory entry."
+  },
+  "memory-list": {
+    usage: "memory-list [--domain <domain>] [--profile-id <profileId>] [--intent-key <intentKey>]",
+    description: "List navigation memory entries with optional filters."
+  },
+  "memory-inspect": {
+    usage: "memory-inspect <id>",
+    description: "Inspect one memory entry by id."
+  },
+  "memory-delete": {
+    usage: "memory-delete <id>",
+    description: "Delete one memory entry by id."
+  },
+  "memory-purge": {
+    usage: "memory-purge",
+    description: "Purge expired memory entries."
+  },
+  "memory-mode-set": {
+    usage: "memory-mode-set <mode>",
+    description: "Set navigation memory mode (off/ask/auto)."
+  },
+  "memory-ttl-set": {
+    usage: "memory-ttl-set <ttlDays>",
+    description: "Set navigation memory retention in days."
+  },
   "daemon-status": {
     usage: "daemon-status",
     description: "Inspect local daemon process status."
@@ -254,7 +376,21 @@ const COMMAND_GROUPS: ReadonlyArray<{ title: string; commands: readonly CommandN
   },
   {
     title: "Driver/session",
-    commands: ["status", "profile-list", "profile-use", "tabs"]
+    commands: ["status", "profile-list", "profile-use", "tabs", "session-list", "session-drop"]
+  },
+  {
+    title: "Navigation memory",
+    commands: [
+      "memory-status",
+      "memory-resolve",
+      "memory-upsert",
+      "memory-list",
+      "memory-inspect",
+      "memory-delete",
+      "memory-purge",
+      "memory-mode-set",
+      "memory-ttl-set"
+    ]
   },
   {
     title: "Tab/page",
@@ -267,6 +403,11 @@ const COMMAND_GROUPS: ReadonlyArray<{ title: string; commands: readonly CommandN
       "dom-query-all",
       "element-screenshot",
       "a11y-snapshot",
+      "wait-element",
+      "wait-text",
+      "wait-url",
+      "network-list",
+      "har-export",
       "network-wait-for",
       "cookie-get",
       "cookie-set",
@@ -276,7 +417,8 @@ const COMMAND_GROUPS: ReadonlyArray<{ title: string; commands: readonly CommandN
       "frame-list",
       "frame-snapshot",
       "console-list",
-      "response-body"
+      "response-body",
+      "trace-get"
     ]
   },
   {
@@ -346,6 +488,72 @@ function formatCommandHelp(command: CommandName): string {
     lines.push("  --session <id>         Session namespace (default: cli:local).");
     lines.push("  --profile <driverKey>  Driver override.");
     lines.push("  --token <authToken>    Request auth token override.");
+    if (command === "act") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --payload-json <json>  JSON object forwarded as action.payload.");
+    } else if (command === "wait-element" || command === "wait-url") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --timeout-ms <ms>  Maximum wait time (positive integer).");
+      lines.push("  --poll-ms <ms>     Poll interval (positive integer).");
+    } else if (command === "wait-text") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --selector <selector>  Limit matching to selector results.");
+      lines.push("  --timeout-ms <ms>      Maximum wait time (positive integer).");
+      lines.push("  --poll-ms <ms>         Poll interval (positive integer).");
+    } else if (command === "network-list") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --url-contains <text>  URL substring filter.");
+      lines.push("  --method <METHOD>      HTTP method filter.");
+      lines.push("  --status <CODE>        HTTP status filter.");
+      lines.push("  --since <ISO>          Timestamp lower bound.");
+      lines.push("  --limit <n>            Max number of entries.");
+    } else if (command === "console-list") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --type <type>      Console type filter (log/error/warn...).");
+      lines.push("  --contains <text>  Message substring filter.");
+      lines.push("  --since <ISO>      Timestamp lower bound.");
+      lines.push("  --limit <n>        Max number of entries.");
+    } else if (command === "har-export") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --include-bodies       Include response bodies when available.");
+      lines.push("  --url-contains <text>  URL substring filter.");
+      lines.push("  --method <METHOD>      HTTP method filter.");
+      lines.push("  --status <CODE>        HTTP status filter.");
+      lines.push("  --since <ISO>          Timestamp lower bound.");
+      lines.push("  --limit <n>            Max number of entries.");
+    } else if (command === "trace-get") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --limit <n>  Max number of records per trace section.");
+    } else if (command === "session-list") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --tenant <tenant>  Tenant filter.");
+      lines.push("  --limit <n>        Max number of sessions.");
+    } else if (command === "memory-resolve") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --profile-id <profileId>  Override memory scope profile id.");
+    } else if (command === "memory-upsert") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --signals-json <json>         Required JSON array of memory signals.");
+      lines.push("  --profile-id <profileId>      Override memory scope profile id.");
+      lines.push("  --confidence <n>              Optional confidence score.");
+      lines.push("  --confirmed [true|false]      Optional confirmation flag.");
+    } else if (command === "memory-list") {
+      lines.push("");
+      lines.push("Command options:");
+      lines.push("  --domain <domain>          Optional domain filter.");
+      lines.push("  --profile-id <profileId>   Optional profile id filter.");
+      lines.push("  --intent-key <intentKey>   Optional intent key filter.");
+    }
   } else if (command === "daemon-start") {
     lines.push("");
     lines.push("Command options:");
@@ -583,6 +791,16 @@ async function executeCommand(command: CommandName, commandArgs: string[]): Prom
       return await runElementScreenshotCommand(commandArgs);
     case "a11y-snapshot":
       return await runA11ySnapshotCommand(commandArgs);
+    case "wait-element":
+      return await runWaitElementCommand(commandArgs);
+    case "wait-text":
+      return await runWaitTextCommand(commandArgs);
+    case "wait-url":
+      return await runWaitUrlCommand(commandArgs);
+    case "network-list":
+      return await runNetworkListCommand(commandArgs);
+    case "har-export":
+      return await runHarExportCommand(commandArgs);
     case "network-wait-for":
       return await runNetworkWaitForCommand(commandArgs);
     case "cookie-get":
@@ -613,6 +831,30 @@ async function executeCommand(command: CommandName, commandArgs: string[]): Prom
       return await runConsoleListCommand(commandArgs);
     case "response-body":
       return await runResponseBodyCommand(commandArgs);
+    case "session-list":
+      return await runSessionListCommand(commandArgs);
+    case "session-drop":
+      return await runSessionDropCommand(commandArgs);
+    case "trace-get":
+      return await runTraceGetCommand(commandArgs);
+    case "memory-status":
+      return await runMemoryStatusCommand(commandArgs);
+    case "memory-resolve":
+      return await runMemoryResolveCommand(commandArgs);
+    case "memory-upsert":
+      return await runMemoryUpsertCommand(commandArgs);
+    case "memory-list":
+      return await runMemoryListCommand(commandArgs);
+    case "memory-inspect":
+      return await runMemoryInspectCommand(commandArgs);
+    case "memory-delete":
+      return await runMemoryDeleteCommand(commandArgs);
+    case "memory-purge":
+      return await runMemoryPurgeCommand(commandArgs);
+    case "memory-mode-set":
+      return await runMemoryModeSetCommand(commandArgs);
+    case "memory-ttl-set":
+      return await runMemoryTtlSetCommand(commandArgs);
     case "daemon-status": {
       const context = parseCommandContext(commandArgs);
       return await getDaemonStatus({