perf(test): dedupe browser/telegram coverage and trim batch retry cost

src/browser/server.agent-contract-snapshot-endpoints.test.ts

@@ -317,6 +317,17 @@ describe("browser control server", () => {
       targetId: "abcd1234",
       maxChars: DEFAULT_AI_SNAPSHOT_MAX_CHARS,
     });
+
+    const snapAiZero = (await realFetch(`${base}/snapshot?format=ai&maxChars=0`).then((r) =>
+      r.json(),
+    )) as { ok: boolean; format?: string };
+    expect(snapAiZero.ok).toBe(true);
+    expect(snapAiZero.format).toBe("ai");
+    const [lastCall] = pwMocks.snapshotAiViaPlaywright.mock.calls.at(-1) ?? [];
+    expect(lastCall).toEqual({
+      cdpUrl: cdpBaseUrl,
+      targetId: "abcd1234",
+    });
   });
 
   it("agent contract: navigation + common act commands", async () => {

src/browser/server.skips-default-maxchars-explicitly-set-zero.test.ts

@@ -1,276 +0,0 @@
-import { type AddressInfo, createServer } from "node:net";
-import { fetch as realFetch } from "undici";
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-
-let testPort = 0;
-let cdpBaseUrl = "";
-let reachable = false;
-let cfgAttachOnly = false;
-let prevGatewayPort: string | undefined;
-
-const cdpMocks = vi.hoisted(() => ({
-  createTargetViaCdp: vi.fn(async () => {
-    throw new Error("cdp disabled");
-  }),
-  snapshotAria: vi.fn(async () => ({
-    nodes: [{ ref: "1", role: "link", name: "x", depth: 0 }],
-  })),
-}));
-
-const pwMocks = vi.hoisted(() => ({
-  armDialogViaPlaywright: vi.fn(async () => {}),
-  armFileUploadViaPlaywright: vi.fn(async () => {}),
-  clickViaPlaywright: vi.fn(async () => {}),
-  closePageViaPlaywright: vi.fn(async () => {}),
-  closePlaywrightBrowserConnection: vi.fn(async () => {}),
-  downloadViaPlaywright: vi.fn(async () => ({
-    url: "https://example.com/report.pdf",
-    suggestedFilename: "report.pdf",
-    path: "/tmp/report.pdf",
-  })),
-  dragViaPlaywright: vi.fn(async () => {}),
-  evaluateViaPlaywright: vi.fn(async () => "ok"),
-  fillFormViaPlaywright: vi.fn(async () => {}),
-  getConsoleMessagesViaPlaywright: vi.fn(async () => []),
-  hoverViaPlaywright: vi.fn(async () => {}),
-  scrollIntoViewViaPlaywright: vi.fn(async () => {}),
-  navigateViaPlaywright: vi.fn(async () => ({ url: "https://example.com" })),
-  pdfViaPlaywright: vi.fn(async () => ({ buffer: Buffer.from("pdf") })),
-  pressKeyViaPlaywright: vi.fn(async () => {}),
-  responseBodyViaPlaywright: vi.fn(async () => ({
-    url: "https://example.com/api/data",
-    status: 200,
-    headers: { "content-type": "application/json" },
-    body: '{"ok":true}',
-  })),
-  resizeViewportViaPlaywright: vi.fn(async () => {}),
-  selectOptionViaPlaywright: vi.fn(async () => {}),
-  setInputFilesViaPlaywright: vi.fn(async () => {}),
-  snapshotAiViaPlaywright: vi.fn(async () => ({ snapshot: "ok" })),
-  takeScreenshotViaPlaywright: vi.fn(async () => ({
-    buffer: Buffer.from("png"),
-  })),
-  typeViaPlaywright: vi.fn(async () => {}),
-  waitForDownloadViaPlaywright: vi.fn(async () => ({
-    url: "https://example.com/report.pdf",
-    suggestedFilename: "report.pdf",
-    path: "/tmp/report.pdf",
-  })),
-  waitForViaPlaywright: vi.fn(async () => {}),
-}));
-
-function makeProc(pid = 123) {
-  const handlers = new Map<string, Array<(...args: unknown[]) => void>>();
-  return {
-    pid,
-    killed: false,
-    exitCode: null as number | null,
-    on: (event: string, cb: (...args: unknown[]) => void) => {
-      handlers.set(event, [...(handlers.get(event) ?? []), cb]);
-      return undefined;
-    },
-    emitExit: () => {
-      for (const cb of handlers.get("exit") ?? []) {
-        cb(0);
-      }
-    },
-    kill: () => {
-      return true;
-    },
-  };
-}
-
-const proc = makeProc();
-
-vi.mock("../config/config.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../config/config.js")>();
-  return {
-    ...actual,
-    loadConfig: () => ({
-      browser: {
-        enabled: true,
-        color: "#FF4500",
-        attachOnly: cfgAttachOnly,
-        headless: true,
-        defaultProfile: "openclaw",
-        profiles: {
-          openclaw: { cdpPort: testPort + 1, color: "#FF4500" },
-        },
-      },
-    }),
-    writeConfigFile: vi.fn(async () => {}),
-  };
-});
-
-const launchCalls = vi.hoisted(() => [] as Array<{ port: number }>);
-vi.mock("./chrome.js", () => ({
-  isChromeCdpReady: vi.fn(async () => reachable),
-  isChromeReachable: vi.fn(async () => reachable),
-  launchOpenClawChrome: vi.fn(async (_resolved: unknown, profile: { cdpPort: number }) => {
-    launchCalls.push({ port: profile.cdpPort });
-    reachable = true;
-    return {
-      pid: 123,
-      exe: { kind: "chrome", path: "/fake/chrome" },
-      userDataDir: "/tmp/openclaw",
-      cdpPort: profile.cdpPort,
-      startedAt: Date.now(),
-      proc,
-    };
-  }),
-  resolveOpenClawUserDataDir: vi.fn(() => "/tmp/openclaw"),
-  stopOpenClawChrome: vi.fn(async () => {
-    reachable = false;
-  }),
-}));
-
-vi.mock("./cdp.js", () => ({
-  createTargetViaCdp: cdpMocks.createTargetViaCdp,
-  normalizeCdpWsUrl: vi.fn((wsUrl: string) => wsUrl),
-  snapshotAria: cdpMocks.snapshotAria,
-  getHeadersWithAuth: vi.fn(() => ({})),
-  appendCdpPath: vi.fn((cdpUrl: string, path: string) => {
-    const base = cdpUrl.replace(/\/$/, "");
-    const suffix = path.startsWith("/") ? path : `/${path}`;
-    return `${base}${suffix}`;
-  }),
-}));
-
-vi.mock("./pw-ai.js", () => pwMocks);
-
-vi.mock("../media/store.js", () => ({
-  ensureMediaDir: vi.fn(async () => {}),
-  saveMediaBuffer: vi.fn(async () => ({ path: "/tmp/fake.png" })),
-}));
-
-vi.mock("./screenshot.js", () => ({
-  DEFAULT_BROWSER_SCREENSHOT_MAX_BYTES: 128,
-  DEFAULT_BROWSER_SCREENSHOT_MAX_SIDE: 64,
-  normalizeBrowserScreenshot: vi.fn(async (buf: Buffer) => ({
-    buffer: buf,
-    contentType: "image/png",
-  })),
-}));
-
-async function getFreePort(): Promise<number> {
-  while (true) {
-    const port = await new Promise<number>((resolve, reject) => {
-      const s = createServer();
-      s.once("error", reject);
-      s.listen(0, "127.0.0.1", () => {
-        const assigned = (s.address() as AddressInfo).port;
-        s.close((err) => (err ? reject(err) : resolve(assigned)));
-      });
-    });
-    if (port < 65535) {
-      return port;
-    }
-  }
-}
-
-function makeResponse(
-  body: unknown,
-  init?: { ok?: boolean; status?: number; text?: string },
-): Response {
-  const ok = init?.ok ?? true;
-  const status = init?.status ?? 200;
-  const text = init?.text ?? "";
-  return {
-    ok,
-    status,
-    json: async () => body,
-    text: async () => text,
-  } as unknown as Response;
-}
-
-describe("browser control server", () => {
-  beforeAll(async () => {
-    reachable = false;
-    cfgAttachOnly = false;
-    launchCalls.length = 0;
-
-    cdpMocks.createTargetViaCdp.mockImplementation(async () => {
-      throw new Error("cdp disabled");
-    });
-
-    for (const fn of Object.values(pwMocks)) {
-      fn.mockClear();
-    }
-    for (const fn of Object.values(cdpMocks)) {
-      fn.mockClear();
-    }
-
-    testPort = await getFreePort();
-    cdpBaseUrl = `http://127.0.0.1:${testPort + 1}`;
-    prevGatewayPort = process.env.OPENCLAW_GATEWAY_PORT;
-    process.env.OPENCLAW_GATEWAY_PORT = String(testPort - 2);
-
-    // Minimal CDP JSON endpoints used by the server.
-    vi.stubGlobal(
-      "fetch",
-      vi.fn(async (url: string, init?: RequestInit) => {
-        const u = String(url);
-        if (u.includes("/json/list")) {
-          if (!reachable) {
-            return makeResponse([]);
-          }
-          return makeResponse([
-            {
-              id: "abcd1234",
-              title: "Tab",
-              url: "https://example.com",
-              webSocketDebuggerUrl: "ws://127.0.0.1/devtools/page/abcd1234",
-              type: "page",
-            },
-            {
-              id: "abce9999",
-              title: "Other",
-              url: "https://other",
-              webSocketDebuggerUrl: "ws://127.0.0.1/devtools/page/abce9999",
-              type: "page",
-            },
-          ]);
-        }
-        void init;
-        return makeResponse({}, { ok: false, status: 500, text: "unexpected" });
-      }),
-    );
-  });
-
-  afterAll(async () => {
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-    if (prevGatewayPort === undefined) {
-      delete process.env.OPENCLAW_GATEWAY_PORT;
-    } else {
-      process.env.OPENCLAW_GATEWAY_PORT = prevGatewayPort;
-    }
-    const { stopBrowserControlServer } = await import("./server.js");
-    await stopBrowserControlServer();
-  });
-
-  it("keeps maxChars unset when snapshot explicitly passes zero", async () => {
-    const { startBrowserControlServerFromConfig } = await import("./server.js");
-    const started = await startBrowserControlServerFromConfig();
-    expect(started?.port).toBe(testPort);
-
-    const base = `http://127.0.0.1:${testPort}`;
-    const startedPayload = (await realFetch(`${base}/start`, { method: "POST" }).then((r) =>
-      r.json(),
-    )) as { ok: boolean; profile?: string };
-    expect(startedPayload.ok).toBe(true);
-    expect(startedPayload.profile).toBe("openclaw");
-
-    const snapAi = (await realFetch(`${base}/snapshot?format=ai&maxChars=0`).then((r) =>
-      r.json(),
-    )) as { ok: boolean; format?: string };
-    expect(snapAi.ok).toBe(true);
-    expect(snapAi.format).toBe("ai");
-    expect(launchCalls.length).toBeGreaterThan(0);
-    const [call] = pwMocks.snapshotAiViaPlaywright.mock.calls.at(-1) ?? [];
-    expect(call).toEqual({
-      cdpUrl: cdpBaseUrl,
-      targetId: "abcd1234",
-    });
-  });
-});

src/memory/manager.batch.test.ts

@@ -30,7 +30,22 @@ describe("memory indexing with OpenAI batches", () => {
   let workspaceDir: string;
   let indexPath: string;
   let manager: MemoryIndexManager | null = null;
-  let setTimeoutSpy: ReturnType<typeof vi.spyOn>;
+
+  function useFastShortTimeouts() {
+    const realSetTimeout = setTimeout;
+    const spy = vi.spyOn(global, "setTimeout").mockImplementation(((
+      handler: TimerHandler,
+      timeout?: number,
+      ...args: unknown[]
+    ) => {
+      const delay = typeof timeout === "number" ? timeout : 0;
+      if (delay > 0 && delay <= 2000) {
+        return realSetTimeout(handler, 0, ...args);
+      }
+      return realSetTimeout(handler, delay, ...args);
+    }) as typeof setTimeout);
+    return () => spy.mockRestore();
+  }
 
   beforeAll(async () => {
     fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-mem-batch-"));
@@ -46,18 +61,6 @@ describe("memory indexing with OpenAI batches", () => {
     embedBatch.mockImplementation(async (texts: string[]) =>
       texts.map((_text, index) => [index + 1, 0, 0]),
     );
-    const realSetTimeout = setTimeout;
-    setTimeoutSpy = vi.spyOn(global, "setTimeout").mockImplementation(((
-      handler: TimerHandler,
-      timeout?: number,
-      ...args: unknown[]
-    ) => {
-      const delay = typeof timeout === "number" ? timeout : 0;
-      if (delay > 0 && delay <= 2000) {
-        return realSetTimeout(handler, 0, ...args);
-      }
-      return realSetTimeout(handler, delay, ...args);
-    }) as typeof setTimeout);
     workspaceDir = path.join(fixtureRoot, `case-${++caseId}`);
     indexPath = path.join(workspaceDir, "index.sqlite");
     await fs.mkdir(path.join(workspaceDir, "memory"), { recursive: true });
@@ -65,7 +68,6 @@ describe("memory indexing with OpenAI batches", () => {
 
   afterEach(async () => {
     vi.unstubAllGlobals();
-    setTimeoutSpy.mockRestore();
     if (manager) {
       await manager.close();
       manager = null;
@@ -180,6 +182,7 @@ describe("memory indexing with OpenAI batches", () => {
   });
 
   it("retries OpenAI batch create on transient failures", async () => {
+    const restoreTimeouts = useFastShortTimeouts();
     const content = ["retry", "the", "batch"].join("\n\n");
     await fs.writeFile(path.join(workspaceDir, "memory", "2026-01-08.md"), content);
 
@@ -268,17 +271,21 @@ describe("memory indexing with OpenAI batches", () => {
       },
     };
 
-    const result = await getMemorySearchManager({ cfg, agentId: "main" });
+    try {
-    expect(result.manager).not.toBeNull();
+      const result = await getMemorySearchManager({ cfg, agentId: "main" });
-    if (!result.manager) {
+      expect(result.manager).not.toBeNull();
-      throw new Error("manager missing");
+      if (!result.manager) {
-    }
+        throw new Error("manager missing");
-    manager = result.manager;
+      }
-    await manager.sync({ force: true });
+      manager = result.manager;
+      await manager.sync({ force: true });
 
-    const status = manager.status();
+      const status = manager.status();
-    expect(status.chunks).toBeGreaterThan(0);
+      expect(status.chunks).toBeGreaterThan(0);
-    expect(batchCreates).toBe(2);
+      expect(batchCreates).toBe(2);
+    } finally {
+      restoreTimeouts();
+    }
   });
 
   it("tracks batch failures, resets on success, and disables after repeated failures", async () => {
@@ -319,7 +326,7 @@ describe("memory indexing with OpenAI batches", () => {
       }
       if (url.endsWith("/batches")) {
         if (mode === "fail") {
-          return new Response("batch failed", { status: 500 });
+          return new Response("batch failed", { status: 400 });
         }
         return new Response(JSON.stringify({ id: "batch_1", status: "in_progress" }), {
           status: 200,