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

package/apps/browserd/src/tool-matrix.test.ts

@@ -41,7 +41,9 @@ function sendToolRequest(
   return responsePromise;
 }
 
-async function createManagedLegacyRuntime() {
+async function createManagedLegacyRuntime(
+  overrides: Record<string, string | undefined> = {}
+) {
   const relayPort = await reserveLoopbackPort();
 
   const input = new PassThrough();
@@ -49,7 +51,8 @@ async function createManagedLegacyRuntime() {
   const runtime = bootstrapBrowserd({
     env: {
       BROWSERD_DEFAULT_DRIVER: "managed",
-      BROWSERD_CHROME_RELAY_URL: `http://127.0.0.1:${relayPort}`
+      BROWSERD_CHROME_RELAY_URL: `http://127.0.0.1:${relayPort}`,
+      ...overrides
     },
     input,
     output,
@@ -77,6 +80,9 @@ describe("browserd tool matrix", () => {
         "browser.dom.queryAll",
         "browser.element.screenshot",
         "browser.a11y.snapshot",
+        "browser.wait.element",
+        "browser.wait.text",
+        "browser.wait.url",
         "browser.cookie.get",
         "browser.cookie.set",
         "browser.cookie.clear",
@@ -87,7 +93,11 @@ describe("browserd tool matrix", () => {
         "browser.act",
         "browser.dialog.arm",
         "browser.download.trigger",
-        "browser.network.waitFor"
+        "browser.network.list",
+        "browser.network.harExport",
+        "browser.network.waitFor",
+        "browser.console.list",
+        "browser.session.drop"
       ] as const;
 
       for (const [index, toolName] of toolNames.entries()) {
@@ -112,6 +122,392 @@ describe("browserd tool matrix", () => {
     }
   });
 
+  it("routes browser.memory tools with validation and deterministic state", async () => {
+    const { input, output, runtime } = await createManagedLegacyRuntime();
+
+    try {
+      const statusResponse = await sendToolRequest(input, output, {
+        id: "request-memory-status",
+        name: "browser.memory.status",
+        traceId: "trace:memory:status",
+        arguments: {
+          sessionId: "session:memory"
+        }
+      });
+      expect(statusResponse.ok).toBe(true);
+      const statusPayload = statusResponse.data as {
+        path?: unknown;
+        mode?: unknown;
+        ttlDays?: unknown;
+        totalEntries?: unknown;
+      };
+      expect(typeof statusPayload.path).toBe("string");
+      expect((statusPayload.path as string).length).toBeGreaterThan(0);
+      expect(statusPayload.mode).toBe("ask");
+      expect(typeof statusPayload.ttlDays).toBe("number");
+      expect(typeof statusPayload.totalEntries).toBe("number");
+
+      const resolveMissingArgResponse = await sendToolRequest(input, output, {
+        id: "request-memory-resolve-missing",
+        name: "browser.memory.resolve",
+        traceId: "trace:memory:resolve:missing",
+        arguments: {
+          sessionId: "session:memory"
+        }
+      });
+      expect(resolveMissingArgResponse.ok).toBe(false);
+      expect(resolveMissingArgResponse.error).toMatchObject({
+        code: "E_INVALID_ARG"
+      });
+
+      const upsertMissingArgResponse = await sendToolRequest(input, output, {
+        id: "request-memory-upsert-missing",
+        name: "browser.memory.upsert",
+        traceId: "trace:memory:upsert:missing",
+        arguments: {
+          sessionId: "session:memory"
+        }
+      });
+      expect(upsertMissingArgResponse.ok).toBe(false);
+      expect(upsertMissingArgResponse.error).toMatchObject({
+        code: "E_INVALID_ARG"
+      });
+
+      const upsertFreeTextSignalResponse = await sendToolRequest(input, output, {
+        id: "request-memory-upsert-free-text-signal",
+        name: "browser.memory.upsert",
+        traceId: "trace:memory:upsert:free-text-signal",
+        arguments: {
+          sessionId: "session:memory",
+          domain: "example.com",
+          profileId: "managed",
+          intentKey: "checkout",
+          signals: [
+            {
+              kind: "urlPattern",
+              value: "this is copied page body text that should never be stored"
+            }
+          ],
+          confirmed: true
+        }
+      });
+      expect(upsertFreeTextSignalResponse.ok).toBe(false);
+      expect(upsertFreeTextSignalResponse.error).toMatchObject({
+        code: "E_INVALID_ARG"
+      });
+
+      const upsertResponse = await sendToolRequest(input, output, {
+        id: "request-memory-upsert",
+        name: "browser.memory.upsert",
+        traceId: "trace:memory:upsert",
+        arguments: {
+          sessionId: "session:memory",
+          domain: "example.com",
+          profileId: "managed",
+          intentKey: "checkout",
+          signals: [
+            {
+              kind: "urlPattern",
+              value: "/checkout"
+            }
+          ],
+          confidence: 0.8,
+          confirmed: true
+        }
+      });
+      expect(upsertResponse.ok).toBe(true);
+      const upsertPayload = upsertResponse.data as {
+        created?: unknown;
+        entry?: {
+          id?: unknown;
+          domain?: unknown;
+          profileId?: unknown;
+          intentKey?: unknown;
+          confidence?: unknown;
+          hitCount?: unknown;
+        };
+      };
+      expect(upsertPayload.created).toBe(true);
+      expect(upsertPayload.entry?.domain).toBe("example.com");
+      expect(upsertPayload.entry?.profileId).toBe("managed");
+      expect(upsertPayload.entry?.intentKey).toBe("checkout");
+      expect(upsertPayload.entry?.confidence).toBe(0.8);
+      expect(upsertPayload.entry?.hitCount).toBe(0);
+      expect(typeof upsertPayload.entry?.id).toBe("string");
+      expect((upsertPayload.entry?.id as string).length).toBeGreaterThan(0);
+
+      const memoryId = upsertPayload.entry?.id as string;
+
+      const listResponse = await sendToolRequest(input, output, {
+        id: "request-memory-list",
+        name: "browser.memory.list",
+        traceId: "trace:memory:list",
+        arguments: {
+          sessionId: "session:memory"
+        }
+      });
+      expect(listResponse.ok).toBe(true);
+      expect(listResponse.data).toMatchObject({
+        entries: [{ id: memoryId }]
+      });
+
+      const inspectResponse = await sendToolRequest(input, output, {
+        id: "request-memory-inspect",
+        name: "browser.memory.inspect",
+        traceId: "trace:memory:inspect",
+        arguments: {
+          sessionId: "session:memory",
+          id: memoryId
+        }
+      });
+      expect(inspectResponse.ok).toBe(true);
+      expect(inspectResponse.data).toMatchObject({
+        entry: {
+          id: memoryId
+        }
+      });
+
+      const resolveResponse = await sendToolRequest(input, output, {
+        id: "request-memory-resolve",
+        name: "browser.memory.resolve",
+        traceId: "trace:memory:resolve",
+        arguments: {
+          sessionId: "session:memory",
+          domain: "example.com",
+          profileId: "managed",
+          intentKey: "checkout"
+        }
+      });
+      expect(resolveResponse.ok).toBe(true);
+      expect(resolveResponse.data).toMatchObject({
+        hit: true,
+        entry: {
+          id: memoryId,
+          hitCount: 1
+        }
+      });
+
+      const deleteResponse = await sendToolRequest(input, output, {
+        id: "request-memory-delete",
+        name: "browser.memory.delete",
+        traceId: "trace:memory:delete",
+        arguments: {
+          sessionId: "session:memory",
+          id: memoryId
+        }
+      });
+      expect(deleteResponse.ok).toBe(true);
+      expect(deleteResponse.data).toMatchObject({
+        deleted: true
+      });
+
+      const purgeResponse = await sendToolRequest(input, output, {
+        id: "request-memory-purge",
+        name: "browser.memory.purge",
+        traceId: "trace:memory:purge",
+        arguments: {
+          sessionId: "session:memory"
+        }
+      });
+      expect(purgeResponse.ok).toBe(true);
+      expect(purgeResponse.data).toMatchObject({
+        purged: 0
+      });
+
+      const modeSetResponse = await sendToolRequest(input, output, {
+        id: "request-memory-mode-set",
+        name: "browser.memory.mode.set",
+        traceId: "trace:memory:mode:set",
+        arguments: {
+          sessionId: "session:memory",
+          mode: "ask"
+        }
+      });
+      expect(modeSetResponse.ok).toBe(true);
+      expect(modeSetResponse.data).toMatchObject({
+        mode: "ask"
+      });
+
+      const modeOffResponse = await sendToolRequest(input, output, {
+        id: "request-memory-mode-set-off",
+        name: "browser.memory.mode.set",
+        traceId: "trace:memory:mode:set:off",
+        arguments: {
+          sessionId: "session:memory",
+          mode: "off"
+        }
+      });
+      expect(modeOffResponse.ok).toBe(true);
+      expect(modeOffResponse.data).toMatchObject({
+        mode: "off"
+      });
+
+      const policyRejectResponse = await sendToolRequest(input, output, {
+        id: "request-memory-upsert-policy-reject",
+        name: "browser.memory.upsert",
+        traceId: "trace:memory:upsert:policy:reject",
+        arguments: {
+          sessionId: "session:memory",
+          domain: "example.com",
+          profileId: "managed",
+          intentKey: "checkout",
+          signals: [
+            {
+              kind: "urlPattern",
+              value: "/checkout"
+            }
+          ],
+          confidence: 0.6
+        }
+      });
+      expect(policyRejectResponse.ok).toBe(false);
+      expect(policyRejectResponse.error).toMatchObject({
+        code: "E_PERMISSION"
+      });
+
+      const ttlSetResponse = await sendToolRequest(input, output, {
+        id: "request-memory-ttl-set",
+        name: "browser.memory.ttl.set",
+        traceId: "trace:memory:ttl:set",
+        arguments: {
+          sessionId: "session:memory",
+          ttlDays: 7
+        }
+      });
+      expect(ttlSetResponse.ok).toBe(true);
+      expect(ttlSetResponse.data).toMatchObject({
+        ttlDays: 7
+      });
+    } finally {
+      runtime.close();
+      input.end();
+      output.end();
+    }
+  });
+
+  it("records memory-hit marker in browser.trace.get after browser.memory.resolve", async () => {
+    const { input, output, runtime } = await createManagedLegacyRuntime();
+
+    try {
+      const upsertResponse = await sendToolRequest(input, output, {
+        id: "request-memory-hit-upsert",
+        name: "browser.memory.upsert",
+        traceId: "trace:memory:hit:upsert",
+        arguments: {
+          sessionId: "session:memory-hit",
+          domain: "example.com",
+          profileId: "managed",
+          intentKey: "checkout",
+          signals: [
+            {
+              kind: "urlPattern",
+              value: "/checkout"
+            }
+          ],
+          confidence: 0.9,
+          confirmed: true
+        }
+      });
+      expect(upsertResponse.ok).toBe(true);
+
+      const resolveResponse = await sendToolRequest(input, output, {
+        id: "request-memory-hit-resolve",
+        name: "browser.memory.resolve",
+        traceId: "trace:memory:hit:resolve",
+        arguments: {
+          sessionId: "session:memory-hit",
+          domain: "example.com",
+          profileId: "managed",
+          intentKey: "checkout"
+        }
+      });
+      expect(resolveResponse.ok).toBe(true);
+      expect(resolveResponse.data).toMatchObject({
+        hit: true
+      });
+
+      const traceGetResponse = await sendToolRequest(input, output, {
+        id: "request-memory-hit-trace-get",
+        name: "browser.trace.get",
+        traceId: "trace:memory:hit:trace-get",
+        arguments: {
+          sessionId: "session:memory-hit",
+          limit: 20
+        }
+      });
+      expect(traceGetResponse.ok).toBe(true);
+      const tracePayload = traceGetResponse.data as {
+        keyResponses?: Array<{
+          kind?: string;
+          data?: {
+            memoryHit?: boolean;
+          };
+        }>;
+      };
+      expect(tracePayload.keyResponses?.some((response) =>
+        response.kind === "memory.resolve" && response.data?.memoryHit === true
+      )).toBe(true);
+    } finally {
+      runtime.close();
+      input.end();
+      output.end();
+    }
+  });
+
+  it("keeps browser.memory disabled when BROWSERD_MEMORY_ENABLED is false", async () => {
+    const { input, output, runtime } = await createManagedLegacyRuntime({
+      BROWSERD_MEMORY_ENABLED: "false"
+    });
+
+    try {
+      const statusResponse = await sendToolRequest(input, output, {
+        id: "request-memory-disabled-status",
+        name: "browser.memory.status",
+        traceId: "trace:memory:disabled:status",
+        arguments: {
+          sessionId: "session:memory:disabled"
+        }
+      });
+
+      expect(statusResponse.ok).toBe(true);
+      expect(statusResponse.data).toMatchObject({
+        mode: "off"
+      });
+
+      const modeSetResponse = await sendToolRequest(input, output, {
+        id: "request-memory-disabled-mode-set",
+        name: "browser.memory.mode.set",
+        traceId: "trace:memory:disabled:mode:set",
+        arguments: {
+          sessionId: "session:memory:disabled",
+          mode: "auto"
+        }
+      });
+
+      expect(modeSetResponse.ok).toBe(false);
+      expect(modeSetResponse.error).toMatchObject({
+        code: "E_PERMISSION"
+      });
+
+      const statusAfterResponse = await sendToolRequest(input, output, {
+        id: "request-memory-disabled-status-after",
+        name: "browser.memory.status",
+        traceId: "trace:memory:disabled:status:after",
+        arguments: {
+          sessionId: "session:memory:disabled"
+        }
+      });
+      expect(statusAfterResponse.ok).toBe(true);
+      expect(statusAfterResponse.data).toMatchObject({
+        mode: "off"
+      });
+    } finally {
+      runtime.close();
+      input.end();
+      output.end();
+    }
+  });
+
   it("returns E_DRIVER_UNAVAILABLE for structured action tools on managed driver", async () => {
     const { input, output, runtime } = await createManagedLegacyRuntime();
 
@@ -159,6 +555,27 @@ describe("browserd tool matrix", () => {
             targetId
           }
         },
+        {
+          name: "browser.wait.element",
+          arguments: {
+            sessionId: "session:unavailable",
+            targetId,
+            selector: "#ready",
+            timeoutMs: 5,
+            pollMs: 1
+          }
+        },
+        {
+          name: "browser.wait.text",
+          arguments: {
+            sessionId: "session:unavailable",
+            targetId,
+            text: "ready",
+            selector: "#status",
+            timeoutMs: 5,
+            pollMs: 1
+          }
+        },
         {
           name: "browser.cookie.get",
           arguments: {
@@ -374,6 +791,78 @@ describe("browserd tool matrix", () => {
         code: "E_TIMEOUT"
       });
 
+      const networkListResponse = await sendToolRequest(input, output, {
+        id: "request-flow-network-list",
+        name: "browser.network.list",
+        traceId: "trace:matrix:network-list",
+        arguments: {
+          sessionId: "session:flow",
+          targetId
+        }
+      });
+      expect(networkListResponse.ok).toBe(true);
+      expect(networkListResponse.data).toMatchObject({
+        driver: "managed",
+        targetId,
+        requests: []
+      });
+
+      const harExportResponse = await sendToolRequest(input, output, {
+        id: "request-flow-har-export",
+        name: "browser.network.harExport",
+        traceId: "trace:matrix:har-export",
+        arguments: {
+          sessionId: "session:flow",
+          targetId
+        }
+      });
+      expect(harExportResponse.ok).toBe(true);
+      expect(harExportResponse.data).toMatchObject({
+        driver: "managed",
+        targetId,
+        har: {
+          log: {
+            entries: []
+          }
+        }
+      });
+
+      const traceGetResponse = await sendToolRequest(input, output, {
+        id: "request-flow-trace-get",
+        name: "browser.trace.get",
+        traceId: "trace:matrix:trace-get",
+        arguments: {
+          sessionId: "session:flow",
+          limit: 20
+        }
+      });
+      expect(traceGetResponse.ok).toBe(true);
+      expect(traceGetResponse.data).toMatchObject({
+        sessionId: "session:flow"
+      });
+      const tracePayload = traceGetResponse.data as {
+        steps?: Array<{ tool?: string }>;
+      };
+      expect(Array.isArray(tracePayload.steps)).toBe(true);
+      expect(tracePayload.steps?.some((step) => step.tool === "browser.tab.open")).toBe(true);
+
+      const waitUrlResponse = await sendToolRequest(input, output, {
+        id: "request-flow-waiturl",
+        name: "browser.wait.url",
+        traceId: "trace:matrix:waiturl",
+        arguments: {
+          sessionId: "session:flow",
+          targetId,
+          urlPattern: "/never-match",
+          timeoutMs: 5,
+          pollMs: 1
+        }
+      });
+      expect(waitUrlResponse.ok).toBe(false);
+      expect(waitUrlResponse.error).toMatchObject({
+        code: "E_TIMEOUT"
+      });
+
       const closeResponse = await sendToolRequest(input, output, {
         id: "request-flow-close",
         name: "browser.tab.close",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flrande/browserctl",
-  "version": "0.4.0-dev.15.1",
+  "version": "0.5.0-dev.19.1",
   "private": false,
   "bin": {
     "browserctl": "bin/browserctl.cjs",
@@ -32,6 +32,7 @@
     "playwright-core": "^1.52.0",
     "tsx": "^4.21.0",
     "ws": "^8.19.0",
+    "yaml": "^2.8.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {
@@ -44,6 +45,9 @@
     "test:unit": "vitest run --config vitest.config.ts",
     "test:contract": "vitest run --config vitest.contract.config.ts",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:e2e:smoke": "vitest run --config vitest.e2e.smoke.config.ts",
+    "test:e2e:full": "vitest run --config vitest.e2e.full.config.ts",
+    "test:e2e:stress": "vitest run --config vitest.e2e.stress.config.ts",
     "test:smoke": "vitest run --config vitest.smoke.config.ts",
     "test:all": "pnpm run test:unit && pnpm run test:contract && pnpm run test:e2e && pnpm run test:smoke",
     "build": "npm pack --dry-run",

package/packages/core/src/driver.ts

@@ -42,6 +42,6 @@ export interface BrowserDriver<
 
   armUpload(targetId: TargetId, files: string[], profile?: ProfileId): Promise<void>;
   armDialog(targetId: TargetId, profile?: ProfileId): Promise<void>;
-  waitDownload(targetId: TargetId, profile?: ProfileId): Promise<TDownload>;
+  waitDownload(targetId: TargetId, profile?: ProfileId, path?: string): Promise<TDownload>;
   triggerDownload(targetId: TargetId, profile?: ProfileId): Promise<void>;
 }

package/packages/core/src/index.ts

@@ -1,5 +1,6 @@
 export * from "./types";
 export * from "./session-store";
+export * from "./navigation-memory";
 export * from "./ref-cache";
 export * from "./driver";
 export * from "./driver-registry";