@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/headless-browser-navigate.test.ts

@@ -77,10 +77,13 @@ let getOrCreateSessionPageMock: ReturnType<typeof mock>;
 let clearSnapshotBackendNodeMapMock: ReturnType<typeof mock>;
 let positionWindowSidebarMock: ReturnType<typeof mock>;
 
+const preferredBackendKinds = new Map<string, string>();
+
 mock.module("../tools/browser/browser-manager.js", () => {
   getOrCreateSessionPageMock = mock(async () => mockPage);
   clearSnapshotBackendNodeMapMock = mock(() => {});
   positionWindowSidebarMock = mock(async () => {});
+  preferredBackendKinds.clear();
   return {
     browserManager: {
       getOrCreateSessionPage: getOrCreateSessionPageMock,
@@ -88,6 +91,14 @@ mock.module("../tools/browser/browser-manager.js", () => {
       supportsRouteInterception: true,
       isInteractive: () => false,
       positionWindowSidebar: positionWindowSidebarMock,
+      getPreferredBackendKind: (conversationId: string) =>
+        preferredBackendKinds.get(conversationId) ?? null,
+      setPreferredBackendKind: (conversationId: string, kind: string) => {
+        preferredBackendKinds.set(conversationId, kind);
+      },
+      clearPreferredBackendKind: (conversationId: string) => {
+        preferredBackendKinds.delete(conversationId);
+      },
     },
   };
 });
@@ -101,12 +112,14 @@ mock.module("../tools/browser/browser-screencast.js", () => ({
 
 // Default url-safety: allow everything
 let parseUrlResult: URL | null = null;
+let parseUrlMock: (input: unknown) => URL | null = () => parseUrlResult;
 let isPrivateResult = false;
+let isPrivateHostMock: (hostname: string) => boolean = () => isPrivateResult;
 let resolveResult: { blockedAddress?: string } = {};
 
 mock.module("../tools/network/url-safety.js", () => ({
-  parseUrl: (_input: unknown) => parseUrlResult,
-  isPrivateOrLocalHost: () => isPrivateResult,
+  parseUrl: (input: unknown) => parseUrlMock(input),
+  isPrivateOrLocalHost: (hostname: string) => isPrivateHostMock(hostname),
   resolveHostAddresses: async () => [],
   resolveRequestAddress: async () => resolveResult,
   sanitizeUrlForOutput: (url: URL) => url.href,
@@ -195,7 +208,9 @@ function resetCdp() {
 describe("executeBrowserNavigate", () => {
   beforeEach(() => {
     parseUrlResult = null;
+    parseUrlMock = () => parseUrlResult;
     isPrivateResult = false;
+    isPrivateHostMock = () => isPrivateResult;
     resolveResult = {};
     resetMockPage();
     resetCdp();
@@ -557,9 +572,9 @@ describe("executeBrowserNavigate", () => {
     expect(cdpDisposed).toBe(true);
   });
 
-  // ── Extension path (no browserManager / route interception) ───
+  // ── Extension path (no Playwright route interception) ──────────
 
-  test("extension path skips getOrCreateSessionPage and route interception", async () => {
+  test("extension path skips Playwright route interception", async () => {
     parseUrlResult = new URL("https://example.com/page");
     // Supplying a non-null hostBrowserProxy on the context routes the
     // mocked getCdpClient to the extension path (it mirrors the real
@@ -578,11 +593,133 @@ describe("executeBrowserNavigate", () => {
     );
 
     expect(result.isError).toBe(false);
-    // Extension path never installs or removes a Playwright route.
+    // Extension path never installs or removes a Playwright route
+    // (route interception only works on the local Playwright path).
     expect(mockPage.route.mock.calls.length).toBe(routeCallsBefore);
     expect(mockPage.unroute.mock.calls.length).toBe(unrouteCallsBefore);
     // Page.navigate still goes through the CdpClient.
     expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
     expect(cdpDisposed).toBe(true);
   });
+
+  test("extension path blocks redirects via post-navigation final URL check", async () => {
+    // The initial URL is public and passes pre-flight checks. The
+    // extension path has no Playwright route interception, but the
+    // post-navigation defense-in-depth check catches the private final URL.
+    parseUrlResult = new URL("https://public.example.com/start");
+    isPrivateResult = false;
+
+    // Configure mocks to return different results for the initial URL
+    // vs. the final URL returned by navigateAndWait.
+    parseUrlMock = (input: unknown) => {
+      if (typeof input === "string" && input.includes("127.0.0.1")) {
+        return new URL(input);
+      }
+      return parseUrlResult;
+    };
+    isPrivateHostMock = (hostname: string) => {
+      return hostname === "127.0.0.1";
+    };
+
+    // navigateAndWait returns a private final URL (simulating a
+    // server-side redirect).
+    cdpSendHandler = (method, params) => {
+      if (method === "Page.navigate") return { frameId: "f1" };
+      if (method === "Runtime.evaluate") {
+        const expression = String(params?.["expression"] ?? "");
+        if (expression === "document.location.href") {
+          return { result: { value: "about:blank" } };
+        }
+        if (
+          expression.includes("readyState") &&
+          expression.includes("document.location.href")
+        ) {
+          return {
+            result: {
+              value: {
+                readyState: "complete",
+                href: "http://127.0.0.1/admin",
+              },
+            },
+          };
+        }
+        return { result: { value: null } };
+      }
+      return {};
+    };
+
+    const extensionCtx: ToolContext = {
+      ...ctx,
+      hostBrowserProxy: {} as unknown as ToolContext["hostBrowserProxy"],
+    };
+    const result = await executeBrowserNavigate(
+      { url: "https://public.example.com/start" },
+      extensionCtx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Navigation blocked");
+    expect(result.content).toContain("Final URL resolved to a local/private");
+    expect(result.content).toContain("allow_private_network=true");
+    expect(cdpDisposed).toBe(true);
+  });
+
+  // ── Defense-in-depth: post-navigation final URL check ─────────
+
+  test("post-nav check blocks when final URL resolves to private target", async () => {
+    // The initial URL is public and passes pre-flight checks, but the
+    // final URL (after redirect) resolves to a private address. The
+    // route handler is NOT triggered (navigation succeeds), so only the
+    // post-navigation defense-in-depth check catches it.
+    parseUrlResult = new URL("https://public.example.com/redirect");
+    isPrivateResult = false;
+
+    // Configure parseUrlMock to return different results for the initial
+    // URL vs. the final URL returned by navigateAndWait.
+    parseUrlMock = (input: unknown) => {
+      if (typeof input === "string" && input.includes("192.168")) {
+        return new URL(input);
+      }
+      return parseUrlResult;
+    };
+    isPrivateHostMock = (hostname: string) => {
+      return hostname === "192.168.1.1";
+    };
+
+    // navigateAndWait returns a private final URL (simulating a
+    // server-side redirect that the route handler didn't catch).
+    cdpSendHandler = (method, params) => {
+      if (method === "Page.navigate") return { frameId: "f1" };
+      if (method === "Runtime.evaluate") {
+        const expression = String(params?.["expression"] ?? "");
+        if (expression === "document.location.href") {
+          return { result: { value: "about:blank" } };
+        }
+        if (
+          expression.includes("readyState") &&
+          expression.includes("document.location.href")
+        ) {
+          return {
+            result: {
+              value: {
+                readyState: "complete",
+                href: "http://192.168.1.1/admin",
+              },
+            },
+          };
+        }
+        return { result: { value: null } };
+      }
+      return {};
+    };
+
+    const result = await executeBrowserNavigate(
+      { url: "https://public.example.com/redirect" },
+      ctx,
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Navigation blocked");
+    expect(result.content).toContain("Final URL resolved to a local/private");
+    expect(result.content).toContain("allow_private_network=true");
+    expect(cdpDisposed).toBe(true);
+  });
 });

package/src/__tests__/headless-browser-read-tools.test.ts

@@ -76,12 +76,23 @@ let mockPage: {
   };
 };
 
+const preferredBackendKinds = new Map<string, string>();
+
 mock.module("../tools/browser/browser-manager.js", () => {
+  preferredBackendKinds.clear();
   return {
     browserManager: {
       getOrCreateSessionPage: async () => mockPage,
       closeSessionPage: async () => {},
       closeAllPages: async () => {},
+      getPreferredBackendKind: (conversationId: string) =>
+        preferredBackendKinds.get(conversationId) ?? null,
+      setPreferredBackendKind: (conversationId: string, kind: string) => {
+        preferredBackendKinds.set(conversationId, kind);
+      },
+      clearPreferredBackendKind: (conversationId: string) => {
+        preferredBackendKinds.delete(conversationId);
+      },
     },
   };
 });

package/src/__tests__/headless-browser-snapshot.test.ts

@@ -35,9 +35,11 @@ let closeAllPagesMock: ReturnType<typeof mock>;
 let clearSnapshotBackendNodeMapMock: ReturnType<typeof mock>;
 let storeSnapshotBackendNodeMapMock: ReturnType<typeof mock>;
 let storedBackendNodeMaps: Map<string, Map<string, number>>;
+const preferredBackendKinds = new Map<string, string>();
 
 mock.module("../tools/browser/browser-manager.js", () => {
   storedBackendNodeMaps = new Map();
+  preferredBackendKinds.clear();
   closeSessionPageMock = mock(async () => {});
   closeAllPagesMock = mock(async () => {});
   clearSnapshotBackendNodeMapMock = mock((conversationId: string) => {
@@ -80,6 +82,14 @@ mock.module("../tools/browser/browser-manager.js", () => {
         if (!map) return null;
         return map.get(elementId) ?? null;
       },
+      getPreferredBackendKind: (conversationId: string) =>
+        preferredBackendKinds.get(conversationId) ?? null,
+      setPreferredBackendKind: (conversationId: string, kind: string) => {
+        preferredBackendKinds.set(conversationId, kind);
+      },
+      clearPreferredBackendKind: (conversationId: string) => {
+        preferredBackendKinds.delete(conversationId);
+      },
     },
   };
 });

package/src/__tests__/heartbeat-service.test.ts

@@ -23,6 +23,39 @@ mock.module("../config/loader.js", () => ({
   invalidateConfigCache: () => {},
 }));
 
+// ── Guardian persona mock ─────────────────────────────────────────
+//
+// `heartbeat-service.isShallowProfile` reads the guardian persona via
+// `resolveGuardianPersona()` and compares against the exported
+// `GUARDIAN_PERSONA_TEMPLATE` scaffold. We mock the module so each
+// test can seed whatever persona content it needs; the scaffold text
+// below is kept byte-identical to the real template in
+// `persona-resolver.ts` so the "scaffold-only" path triggers a match.
+const GUARDIAN_PERSONA_TEMPLATE = `_ Lines starting with _ are comments - they won't appear in the system prompt
+
+# User Profile
+
+Store details about your user here. Edit freely - build this over time as you learn about them. Don't be pushy about seeking details, but when you learn something, write it down. More context makes you more useful.
+
+- Preferred name/reference:
+- Pronouns:
+- Locale:
+- Work role:
+- Goals:
+- Hobbies/fun:
+- Daily tools:
+`;
+
+// `resolveGuardianPersona` returns already-stripped + trimmed content
+// (or null for missing/empty files). Tests mutate this variable to
+// drive `isShallowProfile`.
+let mockGuardianPersona: string | null = null;
+
+mock.module("../prompts/persona-resolver.js", () => ({
+  GUARDIAN_PERSONA_TEMPLATE,
+  resolveGuardianPersona: () => mockGuardianPersona,
+}));
+
 // Mock conversation store
 const createdConversations: Array<{ title: string; conversationType: string }> =
   [];
@@ -85,7 +118,13 @@ const IDENTITY_TEMPLATE = readFileSync(
   join(templatesDir, "IDENTITY.md"),
   "utf-8",
 );
-const USER_TEMPLATE = readFileSync(join(templatesDir, "USER.md"), "utf-8");
+
+// Stripped/trimmed form of the guardian persona scaffold — mirrors
+// the transformation applied by `resolveGuardianPersona` (which runs
+// `stripCommentLines` internally). Used to simulate a freshly-seeded,
+// never-edited persona file.
+const { stripCommentLines } = await import("../util/strip-comment-lines.js");
+const SCAFFOLD_PERSONA = stripCommentLines(GUARDIAN_PERSONA_TEMPLATE).trim();
 
 describe("HeartbeatService", () => {
   let processMessageCalls: Array<{
@@ -99,7 +138,6 @@ describe("HeartbeatService", () => {
     // Clean up workspace files between tests so file-existence tests don't leak
     rmSync(join(testWorkspaceDir, "HEARTBEAT.md"), { force: true });
     rmSync(join(testWorkspaceDir, "IDENTITY.md"), { force: true });
-    rmSync(join(testWorkspaceDir, "USER.md"), { force: true });
     rmSync(join(testWorkspaceDir, ".reengagement-ts"), { force: true });
   });
 
@@ -108,6 +146,7 @@ describe("HeartbeatService", () => {
     alerterCalls = [];
     createdConversations.length = 0;
     conversationIdCounter = 0;
+    mockGuardianPersona = null;
 
     mockConfig = {
       heartbeat: {
@@ -494,9 +533,23 @@ describe("HeartbeatService", () => {
   });
 
   describe("isShallowProfile", () => {
-    test("returns true when both IDENTITY.md and USER.md are unmodified templates", () => {
+    test("returns true when IDENTITY.md is template and guardian persona is missing", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      mockGuardianPersona = null;
+
+      expect(isShallowProfile()).toBe(true);
+    });
+
+    test("returns true when IDENTITY.md is template and guardian persona has only scaffold fields", () => {
       writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
+
+      expect(isShallowProfile()).toBe(true);
+    });
+
+    test("returns true when IDENTITY.md is template and guardian persona is empty string", () => {
+      writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
+      mockGuardianPersona = "";
 
       expect(isShallowProfile()).toBe(true);
     });
@@ -506,22 +559,22 @@ describe("HeartbeatService", () => {
         join(testWorkspaceDir, "IDENTITY.md"),
         "# IDENTITY.md\n\n- **Name:** Jarvis\n",
       );
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
 
       expect(isShallowProfile()).toBe(false);
     });
 
-    test("returns false when USER.md has been customized", () => {
+    test("returns false when guardian persona has real content", () => {
       writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
-      writeFileSync(
-        join(testWorkspaceDir, "USER.md"),
-        "# USER.md\n\n- Preferred name/reference: Alice\n",
-      );
+      mockGuardianPersona =
+        "# User Profile\n\n- Preferred name/reference: Alice\n- Work role: designer";
 
       expect(isShallowProfile()).toBe(false);
     });
 
-    test("returns false when neither file exists", () => {
+    test("returns false when IDENTITY.md does not exist", () => {
+      mockGuardianPersona = null;
+
       expect(isShallowProfile()).toBe(false);
     });
   });
@@ -529,7 +582,7 @@ describe("HeartbeatService", () => {
   describe("relationship-depth prompt injection", () => {
     test("includes <relationship-depth> when profile is shallow", () => {
       writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
 
       const service = createService();
       const { prompt, includedReengagement } =
@@ -545,7 +598,7 @@ describe("HeartbeatService", () => {
         join(testWorkspaceDir, "IDENTITY.md"),
         "# IDENTITY.md\n\n- **Name:** Jarvis\n",
       );
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
 
       const service = createService();
       const { prompt, includedReengagement } =
@@ -557,7 +610,7 @@ describe("HeartbeatService", () => {
 
     test("omits <relationship-depth> when cooldown has not elapsed", () => {
       writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
       // Write a recent timestamp to simulate cooldown not elapsed
       writeFileSync(
         join(testWorkspaceDir, ".reengagement-ts"),
@@ -574,7 +627,7 @@ describe("HeartbeatService", () => {
 
     test("includes <relationship-depth> when cooldown has elapsed", () => {
       writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
       // Write a timestamp from 19 hours ago
       const nineteenHoursAgo = Date.now() - 19 * 60 * 60 * 1000;
       writeFileSync(
@@ -592,7 +645,7 @@ describe("HeartbeatService", () => {
 
     test("does not record timestamp when processMessage fails", async () => {
       writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
 
       const service = createService({
         processMessage: async () => {
@@ -609,7 +662,7 @@ describe("HeartbeatService", () => {
 
     test("records timestamp after successful delivery", async () => {
       writeFileSync(join(testWorkspaceDir, "IDENTITY.md"), IDENTITY_TEMPLATE);
-      writeFileSync(join(testWorkspaceDir, "USER.md"), USER_TEMPLATE);
+      mockGuardianPersona = SCAFFOLD_PERSONA;
 
       const service = createService();
       await service.runOnce();

package/src/__tests__/home-state-routes.test.ts

@@ -0,0 +1,162 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub the OAuth connection store before importing anything that
+// transitively pulls in the writer — otherwise importing the route
+// module would try to open the real OAuth DB.
+mock.module("../oauth/oauth-store.js", () => ({
+  listConnections: () => [],
+}));
+
+// Stub the DB-authoritative conversation count helper so the writer
+// (invoked by the read-through fallback) does not lazy-open a real
+// sqlite handle against a stale or deleted per-test tmpdir.
+mock.module("../memory/conversation-queries.js", () => ({
+  countConversations: () => 0,
+}));
+
+const { handleGetHomeState, homeStateRouteDefinitions } =
+  await import("../runtime/routes/home-state-routes.js");
+const { writeRelationshipState, getRelationshipStatePath } =
+  await import("../home/relationship-state-writer.js");
+
+interface RelationshipStateWire {
+  version: number;
+  assistantId: string;
+  tier: number;
+  progressPercent: number;
+  facts: unknown[];
+  capabilities: Array<{ id: string; tier: string }>;
+  conversationCount: number;
+  hatchedDate: string;
+  assistantName: string;
+  userName?: string;
+  updatedAt: string;
+}
+
+let workspaceDir: string;
+let origWorkspaceDir: string | undefined;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-hsr-"));
+  origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+});
+
+afterEach(() => {
+  if (origWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
+  }
+  try {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  } catch {
+    // best-effort cleanup
+  }
+});
+
+describe("home-state-routes", () => {
+  describe("route registration", () => {
+    test("exposes GET /v1/home/state", () => {
+      const routes = homeStateRouteDefinitions();
+      expect(routes).toHaveLength(1);
+      expect(routes[0].endpoint).toBe("home/state");
+      expect(routes[0].method).toBe("GET");
+    });
+  });
+
+  describe("handleGetHomeState", () => {
+    test("returns persisted state when the JSON file exists", async () => {
+      // Seed a minimal USER.md so the writer produces a non-empty
+      // state, then let the writer persist it.
+      mkdirSync(workspaceDir, { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "USER.md"),
+        "- Preferred name: Casey\n- Work role: Engineer\n",
+        "utf-8",
+      );
+      await writeRelationshipState();
+      expect(existsSync(getRelationshipStatePath())).toBe(true);
+
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      expect(body.version).toBe(1);
+      expect(body.assistantId).toBe("default");
+      expect(body.capabilities).toHaveLength(6);
+      expect(body.userName).toBe("Casey");
+      expect(typeof body.updatedAt).toBe("string");
+      expect(Number.isNaN(Date.parse(body.updatedAt))).toBe(false);
+    });
+
+    test("read-through fallback when the file is missing", async () => {
+      // Do NOT call the writer — the file should not exist. The
+      // route must still succeed via computeRelationshipState().
+      expect(existsSync(getRelationshipStatePath())).toBe(false);
+
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      expect(body.version).toBe(1);
+      expect(body.tier).toBe(1);
+      expect(body.progressPercent).toBe(0);
+      expect(body.capabilities).toHaveLength(6);
+      expect(body.conversationCount).toBe(0);
+
+      // Fallback must NOT write the file — that's the writer's job.
+      expect(existsSync(getRelationshipStatePath())).toBe(false);
+    });
+
+    test("falls back to compute when the persisted file is malformed", async () => {
+      // Write a deliberately broken file at the state path.
+      const path = getRelationshipStatePath();
+      mkdirSync(join(path, ".."), { recursive: true });
+      writeFileSync(path, "this is not json", "utf-8");
+
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      // Parsed body is a fresh compute, not the garbage on disk.
+      expect(body.version).toBe(1);
+      expect(body.capabilities).toHaveLength(6);
+    });
+
+    test("GET returns fresh state even when the persisted file is stale", async () => {
+      // Persist a snapshot with userName=Casey.
+      mkdirSync(workspaceDir, { recursive: true });
+      writeFileSync(
+        join(workspaceDir, "USER.md"),
+        "- Preferred name: Casey\n",
+        "utf-8",
+      );
+      await writeRelationshipState();
+      expect(existsSync(getRelationshipStatePath())).toBe(true);
+
+      // Mutate USER.md outside of any turn-boundary writer call. This
+      // simulates: a user editing their persona file, OAuth connecting
+      // a provider, or a conversation delete flow touching state
+      // outside the turn-boundary writer.
+      writeFileSync(
+        join(workspaceDir, "USER.md"),
+        "- Preferred name: Jamie\n",
+        "utf-8",
+      );
+
+      // The route must return the FRESH value (Jamie), not the
+      // cached value (Casey) from the persisted file.
+      const res = await handleGetHomeState();
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as RelationshipStateWire;
+      expect(body.userName).toBe("Jamie");
+    });
+  });
+});

package/src/__tests__/host-bash-proxy.test.ts

@@ -405,26 +405,21 @@ describe("HostBashProxy", () => {
     function spySignal(source: AbortSignal): Spied {
       const addCalls: string[] = [];
       const removeCalls: string[] = [];
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const s = source as any;
       const origAdd = source.addEventListener.bind(source);
       const origRemove = source.removeEventListener.bind(source);
       s.addEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         addCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origAdd as any)(type, ...rest);
       };
       s.removeEventListener = (
         type: string,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ...rest: any[]
       ) => {
         removeCalls.push(type);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return (origRemove as any)(type, ...rest);
       };
       return { signal: source, addCalls, removeCalls };