@vellumai/assistant 0.6.2 → 0.6.3

package/src/tools/terminal/safe-env.ts

@@ -32,6 +32,7 @@ export const SAFE_ENV_VARS = [
   "CES_BOOTSTRAP_SOCKET_DIR",
   "GATEWAY_INTERNAL_URL",
   "VELLUM_PLATFORM_URL",
+  "VELLUM_DOCS_BASE_URL",
   "CES_CREDENTIAL_URL",
   "CES_MANAGED_MODE",
   "IS_CONTAINERIZED",
@@ -42,6 +43,8 @@ export const SAFE_ENV_VARS = [
   "VELLUM_PROFILER_MAX_BYTES",
   "VELLUM_PROFILER_MAX_RUNS",
   "VELLUM_PROFILER_MIN_FREE_MB",
+  "VELLUM_MEMORY_LIMIT",
+  "VELLUM_CPU_LIMIT",
 ] as const;
 
 /**
@@ -71,5 +74,9 @@ export function buildSanitizedEnv(): Record<string, string> {
   // Expose the workspace directory so skills and child processes can read/write
   // workspace-scoped files (e.g. avatar traits, user data).
   env.VELLUM_WORKSPACE_DIR = getWorkspaceDir();
+  // Ensure UTF-8 locale so multi-byte characters (em dashes, curly quotes,
+  // arrows, etc.) survive piping through tools like pbcopy without corruption.
+  if (!env.LANG) env.LANG = "C.UTF-8";
+  if (!env.LC_ALL) env.LC_ALL = "C.UTF-8";
   return env;
 }

package/src/tools/terminal/shell.ts

@@ -327,30 +327,35 @@ class ShellTool implements Tool {
         detached: true,
       });
 
-      const timer = setTimeout(() => {
-        timedOut = true;
+      // Kill the entire process tree. Tries the process group first
+      // (negative PID), then falls back to killing the direct child if the
+      // PID is unavailable or the group kill fails.
+      const killTree = () => {
+        if (child.pid != null) {
+          try {
+            process.kill(-child.pid, "SIGKILL");
+            return;
+          } catch {
+            // Process group may have already exited — fall through.
+          }
+        }
         try {
-          process.kill(-child.pid!, "SIGKILL");
+          child.kill("SIGKILL");
         } catch {
-          // Process group may have already exited.
+          // Child may have already exited.
         }
+      };
+
+      const timer = setTimeout(() => {
+        timedOut = true;
+        killTree();
       }, timeoutMs);
 
       // Cooperative cancellation via AbortSignal
-      const onAbort = () => {
-        try {
-          process.kill(-child.pid!, "SIGKILL");
-        } catch {
-          // Process group may have already exited.
-        }
-      };
+      const onAbort = () => killTree();
       if (context.signal) {
         if (context.signal.aborted) {
-          try {
-            process.kill(-child.pid!, "SIGKILL");
-          } catch {
-            // Process group may have already exited.
-          }
+          killTree();
         } else {
           context.signal.addEventListener("abort", onAbort, { once: true });
         }

package/src/tools/tool-approval-handler.ts

@@ -4,6 +4,10 @@ import {
   getCanonicalGuardianRequest,
   updateCanonicalGuardianRequest,
 } from "../memory/canonical-guardian-store.js";
+import {
+  isConversationHostAccessEnabled,
+  isPermissionControlsV2Enabled,
+} from "../permissions/v2-consent-policy.js";
 import { isUntrustedTrustClass } from "../runtime/actor-trust-resolver.js";
 import { createOrReuseToolGrantRequest } from "../runtime/tool-grant-request-helper.js";
 import { redactSecrets } from "../security/secret-scanner.js";
@@ -178,6 +182,10 @@ function guardianApprovalDeniedMessage(
   return `Permission denied for "${toolName}": this action requires guardian approval and the current actor is not the guardian.`;
 }
 
+function trustedContactHostAccessDeniedMessage(toolName: string): string {
+  return `Permission denied for "${toolName}": computer access is not enabled for this conversation. Confirm the guardian's intent conversationally and ask them to enable computer access for this conversation before retrying.`;
+}
+
 export type PreExecutionGateResult =
   | { allowed: true; tool: Tool; grantConsumed?: boolean }
   | { allowed: false; result: ToolExecutionResult };
@@ -216,6 +224,8 @@ export class ToolApprovalHandler {
     startTime: number,
     emitLifecycleEvent: (event: ToolLifecycleEvent) => void,
   ): Promise<PreExecutionGateResult> {
+    const v2Enabled = isPermissionControlsV2Enabled();
+
     // Bail out immediately if the session was aborted before this tool started.
     if (context.signal?.aborted) {
       const durationMs = Date.now() - startTime;
@@ -286,9 +296,44 @@ export class ToolApprovalHandler {
       | Parameters<typeof consumeGrantForInvocation>[0]
       | null = null;
 
+    const guardianApprovalRequired = requiresGuardianApprovalForActor(
+      name,
+      input,
+      executionTarget,
+    );
+
+    if (
+      v2Enabled &&
+      context.trustClass === "trusted_contact" &&
+      guardianApprovalRequired &&
+      executionTarget === "host" &&
+      !isConversationHostAccessEnabled(context.conversationId)
+    ) {
+      const durationMs = Date.now() - startTime;
+      const reason = trustedContactHostAccessDeniedMessage(name);
+      emitLifecycleEvent({
+        type: "permission_denied",
+        toolName: name,
+        executionTarget,
+        input,
+        workingDir: context.workingDir,
+        conversationId: context.conversationId,
+        requestId: context.requestId,
+        riskLevel,
+        decision: "deny",
+        reason,
+        durationMs,
+      });
+      return {
+        allowed: false,
+        result: { content: reason, isError: true },
+      };
+    }
+
     if (
       isUntrustedTrustClass(context.trustClass) &&
-      requiresGuardianApprovalForActor(name, input, executionTarget)
+      guardianApprovalRequired &&
+      !(v2Enabled && context.trustClass === "trusted_contact")
     ) {
       const inputDigest = computeToolApprovalDigest(name, input);
       needsGrantConsumption = true;
@@ -513,7 +558,8 @@ export class ToolApprovalHandler {
           toolName: name,
           inputDigest,
           questionText: buildToolGrantQuestionText(name, input, context),
-          requesterIdentifier: context.requesterDisplayName || context.requesterIdentifier,
+          requesterIdentifier:
+            context.requesterDisplayName || context.requesterIdentifier,
         });
 
         // Only wait inline if the escalation succeeded (created or deduped).

package/src/tools/types.ts

@@ -176,6 +176,8 @@ export interface ToolContext {
   toolUseId?: string;
   /** Optional proxy for delegating host_bash execution to a connected client (managed/cloud-hosted mode). */
   hostBashProxy?: import("../daemon/host-bash-proxy.js").HostBashProxy;
+  /** Optional proxy for delegating CDP commands to a connected client (managed/cloud-hosted mode). */
+  hostBrowserProxy?: import("../daemon/host-browser-proxy.js").HostBrowserProxy;
   /** Optional proxy for delegating host_file_read/write/edit execution to a connected client (managed/cloud-hosted mode). */
   hostFileProxy?: import("../daemon/host-file-proxy.js").HostFileProxy;
   /** True when the assistant is running as a platform-managed remote instance. Used to auto-approve sandboxed bash tools. */

package/src/util/platform.ts

@@ -136,30 +136,13 @@ export function isTCPEnabled(): boolean {
 
 /**
  * Returns the hostname/address for the TCP listener.
- * If iOS pairing is enabled (flag file): '0.0.0.0' (LAN-accessible).
- * Default: '127.0.0.1' (localhost only).
+ * Always binds to localhost only. iOS pairing uses the gateway
+ * relay.
  */
 export function getTCPHost(): string {
-  if (isIOSPairingEnabled()) return "0.0.0.0";
   return "127.0.0.1";
 }
 
-/**
- * Returns whether iOS pairing mode is enabled.
- * When enabled, the TCP listener binds to 0.0.0.0 (all interfaces)
- * instead of 127.0.0.1 (localhost only), making the daemon reachable
- * from iOS devices on the same local network.
- *
- * Checks for the presence of the flag file ~/.vellum/ios-pairing-enabled.
- * Default: false.
- *
- * This is separate from isTCPEnabled() — TCP can be enabled for localhost-only
- * access without exposing the daemon to the LAN.
- */
-export function isIOSPairingEnabled(): boolean {
-  return existsSync(join(vellumRoot(), "ios-pairing-enabled"));
-}
-
 /**
  * Returns the XDG-compliant path for the platform API token
  * (~/.config/vellum/platform-token). This is the canonical location
@@ -202,6 +185,18 @@ export function getPidPath(): string {
   return join(vellumRoot(), "vellum.pid");
 }
 
+/**
+ * Returns the path to the runtime HTTP port file (~/.vellum/runtime-port).
+ * The daemon writes its active HTTP port here on startup so thin helpers
+ * that need to reach the runtime (e.g. the chrome-extension native messaging
+ * helper) can locate a non-default `RUNTIME_HTTP_PORT` without a manifest
+ * change. Root-level path by design — the file is read by helpers that may
+ * not know the workspace override path.
+ */
+export function getRuntimePortFilePath(): string {
+  return join(vellumRoot(), "runtime-port");
+}
+
 export function getDbPath(): string {
   return join(getDataDir(), "db", "assistant.db");
 }

package/src/workspace/top-level-renderer.ts

@@ -1,7 +1,21 @@
+import { homedir, userInfo } from "node:os";
+
 import type { TopLevelSnapshot } from "./top-level-scanner.js";
 
 export interface WorkspaceTopLevelRenderOptions {
   conversationAttachmentsPath?: string | null;
+  /**
+   * Host home directory on the client machine. When provided, takes
+   * precedence over the daemon's own `os.homedir()`. This matters for
+   * platform-managed (containerized) daemons where `os.homedir()` returns
+   * the container's home, not the user's actual Mac.
+   */
+  hostHomeDir?: string;
+  /**
+   * Host username on the client machine. When provided, takes precedence
+   * over the daemon's own `os.userInfo().username`. See `hostHomeDir`.
+   */
+  hostUsername?: string;
 }
 
 /**
@@ -19,11 +33,15 @@ export function renderWorkspaceTopLevelContext(
   lines.push(`Directories: ${snapshot.directories.join(", ")}`);
   lines.push(`Files: ${snapshot.files.join(", ")}`);
   if (options.conversationAttachmentsPath) {
-    lines.push(`Current conversation attachments: ${options.conversationAttachmentsPath}`);
+    lines.push(
+      `Current conversation attachments: ${options.conversationAttachmentsPath}`,
+    );
   }
   if (snapshot.truncated) {
     lines.push("(list truncated — more entries exist)");
   }
+  lines.push(`Host home directory: ${options.hostHomeDir ?? homedir()}`);
+  lines.push(`Host username: ${options.hostUsername ?? userInfo().username}`);
   lines.push("</workspace>");
   return lines.join("\n");
 }

package/src/__tests__/chrome-cdp.test.ts

@@ -1,419 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-// We need to mock child_process.spawn and execSync, and the global fetch /
-// WebSocket so tests don't need a real Chrome process.
-
-const spawnMock = mock(() => {
-  const proc = { unref: mock(() => {}) };
-  return proc;
-});
-
-const execSyncMock = mock(() => "");
-
-mock.module("node:child_process", () => ({
-  spawn: spawnMock,
-  execSync: execSyncMock,
-}));
-
-const {
-  ensureChromeWithCdp,
-  isCdpReady,
-  minimizeChromeWindow,
-  restoreChromeWindow,
-} = await import("../tools/browser/chrome-cdp.js");
-
-// Track fetch calls so we can assert readiness-check behavior
-let fetchImpl: (url: string | URL | Request) => Promise<Response>;
-
-const originalFetch = globalThis.fetch;
-
-/** Helper: a fetchImpl that simulates a CDP endpoint with page targets. */
-function cdpReadyFetch(url: string | URL | Request): Promise<Response> {
-  const urlStr = String(url);
-  if (urlStr.includes("/json/list")) {
-    return Promise.resolve(
-      new Response(JSON.stringify([{ type: "page" }]), { status: 200 }),
-    );
-  }
-  return Promise.resolve(new Response("{}", { status: 200 }));
-}
-
-beforeEach(() => {
-  // Default: CDP not ready
-  fetchImpl = async () => {
-    throw new Error("Connection refused");
-  };
-  globalThis.fetch = (async (
-    input: string | URL | Request,
-    _init?: RequestInit,
-  ) => {
-    return fetchImpl(input);
-  }) as typeof globalThis.fetch;
-  spawnMock.mockClear();
-  execSyncMock.mockClear();
-});
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-});
-
-// ---------------------------------------------------------------------------
-// isCdpReady
-// ---------------------------------------------------------------------------
-
-describe("isCdpReady", () => {
-  test("returns true when the endpoint responds with 200 and has page targets", async () => {
-    fetchImpl = cdpReadyFetch;
-    expect(await isCdpReady()).toBe(true);
-  });
-
-  test("returns false when fetch throws (connection refused)", async () => {
-    fetchImpl = async () => {
-      throw new Error("Connection refused");
-    };
-    expect(await isCdpReady()).toBe(false);
-  });
-
-  test("returns false when the endpoint responds with non-ok status", async () => {
-    fetchImpl = async () => new Response("", { status: 500 });
-    expect(await isCdpReady()).toBe(false);
-  });
-
-  test("returns false when CDP is up but has no page targets", async () => {
-    fetchImpl = async (url) => {
-      const urlStr = String(url);
-      if (urlStr.includes("/json/list")) {
-        return new Response("[]", { status: 200 });
-      }
-      return new Response("{}", { status: 200 });
-    };
-    expect(await isCdpReady()).toBe(false);
-  });
-
-  test("uses the provided base URL", async () => {
-    const calledUrls: string[] = [];
-    fetchImpl = async (url) => {
-      const urlStr = String(url);
-      calledUrls.push(urlStr);
-      if (urlStr.includes("/json/list")) {
-        return new Response(JSON.stringify([{ type: "page" }]), {
-          status: 200,
-        });
-      }
-      return new Response("{}", { status: 200 });
-    };
-    await isCdpReady("http://localhost:9333");
-    expect(calledUrls.some((u) => u.startsWith("http://localhost:9333/"))).toBe(
-      true,
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// ensureChromeWithCdp
-// ---------------------------------------------------------------------------
-
-describe("ensureChromeWithCdp", () => {
-  test("returns immediately if CDP is already ready (launchedByUs=false)", async () => {
-    fetchImpl = cdpReadyFetch;
-    const session = await ensureChromeWithCdp();
-    expect(session.launchedByUs).toBe(false);
-    expect(session.baseUrl).toBe("http://localhost:9222");
-    expect(spawnMock).not.toHaveBeenCalled();
-  });
-
-  test("spawns Chrome and retries when CDP is not initially ready", async () => {
-    let callCount = 0;
-    fetchImpl = async (url) => {
-      callCount++;
-      // First isCdpReady check fails (2 fetch calls: /json/version + /json/list).
-      // Stale-check /json/version also fails.
-      // After spawn, successive isCdpReady calls succeed on the 5th overall call.
-      if (callCount >= 5) {
-        const urlStr = String(url);
-        if (urlStr.includes("/json/list")) {
-          return new Response(JSON.stringify([{ type: "page" }]), {
-            status: 200,
-          });
-        }
-        return new Response("{}", { status: 200 });
-      }
-      throw new Error("Connection refused");
-    };
-
-    // Replace setTimeout with a zero-delay version to skip retry waits
-    const origSetTimeout = globalThis.setTimeout;
-    globalThis.setTimeout = ((
-      fn: TimerHandler,
-      _ms?: number,
-      ...args: unknown[]
-    ) => {
-      return origSetTimeout(fn, 0, ...args);
-    }) as typeof setTimeout;
-    try {
-      const session = await ensureChromeWithCdp({
-        startUrl: "https://example.com/",
-      });
-      expect(session.launchedByUs).toBe(true);
-      expect(session.baseUrl).toBe("http://localhost:9222");
-      expect(spawnMock).toHaveBeenCalledTimes(1);
-
-      // Verify spawn was called with the right Chrome path and args
-      const spawnArgs = spawnMock.mock.calls[0] as unknown as [
-        string,
-        string[],
-      ];
-      expect(spawnArgs[0]).toContain("Google Chrome");
-      const flags = spawnArgs[1];
-      expect(flags).toContain("--remote-debugging-port=9222");
-      expect(flags).toContain("--force-renderer-accessibility");
-      expect(flags.some((f: string) => f.includes("Chrome-CDP"))).toBe(true);
-      expect(flags).toContain("https://example.com/");
-    } finally {
-      globalThis.setTimeout = origSetTimeout;
-    }
-  });
-
-  test("uses custom port when specified", async () => {
-    fetchImpl = cdpReadyFetch;
-    const session = await ensureChromeWithCdp({ port: 9333 });
-    expect(session.baseUrl).toBe("http://localhost:9333");
-  });
-
-  test("uses custom userDataDir when specified", async () => {
-    fetchImpl = cdpReadyFetch;
-    const session = await ensureChromeWithCdp({
-      userDataDir: "/tmp/test-chrome",
-    });
-    expect(session.userDataDir).toBe("/tmp/test-chrome");
-  });
-
-  test("throws after exhausting retries", async () => {
-    // Never becomes ready
-    fetchImpl = async () => {
-      throw new Error("Connection refused");
-    };
-
-    // Replace setTimeout with a zero-delay version to skip retry waits
-    const origSetTimeout = globalThis.setTimeout;
-    globalThis.setTimeout = ((
-      fn: TimerHandler,
-      _ms?: number,
-      ...args: unknown[]
-    ) => {
-      return origSetTimeout(fn, 0, ...args);
-    }) as typeof setTimeout;
-    try {
-      const promise = ensureChromeWithCdp();
-      await expect(promise).rejects.toThrow("CDP endpoint not responding");
-    } finally {
-      globalThis.setTimeout = origSetTimeout;
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Window management (minimize / restore)
-// ---------------------------------------------------------------------------
-
-describe("minimizeChromeWindow", () => {
-  test("does nothing when no page targets exist", async () => {
-    fetchImpl = async () => new Response("[]", { status: 200 });
-    // Should not throw
-    await minimizeChromeWindow();
-  });
-
-  test("sends minimize command via WebSocket", async () => {
-    // Track the WebSocket interactions
-    const sentMessages: string[] = [];
-    let wsOnOpen: (() => void) | undefined;
-    let wsOnMessage: ((event: { data: string }) => void) | undefined;
-
-    fetchImpl = async (url) => {
-      const urlStr = String(url);
-      if (urlStr.includes("/json/list")) {
-        return new Response(
-          JSON.stringify([
-            {
-              type: "page",
-              webSocketDebuggerUrl: "ws://localhost:9222/devtools/page/ABC",
-            },
-          ]),
-        );
-      }
-      return new Response("{}", { status: 200 });
-    };
-
-    const OriginalWebSocket = globalThis.WebSocket;
-    globalThis.WebSocket = class MockWebSocket {
-      constructor(_url: string) {}
-      addEventListener(event: string, handler: (...args: unknown[]) => void) {
-        if (event === "open") wsOnOpen = handler as () => void;
-        if (event === "message")
-          wsOnMessage = handler as (event: { data: string }) => void;
-      }
-      send(data: string) {
-        sentMessages.push(data);
-        const msg = JSON.parse(data);
-        if (msg.method === "Browser.getWindowForTarget") {
-          // Simulate response with windowId
-          setTimeout(() => {
-            wsOnMessage?.({
-              data: JSON.stringify({ id: 1, result: { windowId: 42 } }),
-            });
-          }, 0);
-        } else if (msg.method === "Browser.setWindowBounds") {
-          setTimeout(() => {
-            wsOnMessage?.({ data: JSON.stringify({ id: 2, result: {} }) });
-          }, 0);
-        }
-      }
-      close() {}
-    } as unknown as typeof WebSocket;
-
-    const promise = minimizeChromeWindow();
-
-    // Trigger the open event
-    await new Promise((r) => setTimeout(r, 10));
-    wsOnOpen?.();
-
-    await promise;
-
-    // Verify the setWindowBounds call had windowState: "minimized"
-    const boundsMsg = sentMessages.find((m) =>
-      m.includes("Browser.setWindowBounds"),
-    );
-    expect(boundsMsg).toBeDefined();
-    const parsed = JSON.parse(boundsMsg!);
-    expect(parsed.params.bounds.windowState).toBe("minimized");
-
-    globalThis.WebSocket = OriginalWebSocket;
-  });
-});
-
-describe("setWindowState error handling", () => {
-  test("rejects when Browser.setWindowBounds returns an error", async () => {
-    let wsOnOpen: (() => void) | undefined;
-    let wsOnMessage: ((event: { data: string }) => void) | undefined;
-
-    fetchImpl = async (url) => {
-      const urlStr = String(url);
-      if (urlStr.includes("/json/list")) {
-        return new Response(
-          JSON.stringify([
-            {
-              type: "page",
-              webSocketDebuggerUrl: "ws://localhost:9222/devtools/page/ABC",
-            },
-          ]),
-        );
-      }
-      return new Response("{}", { status: 200 });
-    };
-
-    const OriginalWebSocket = globalThis.WebSocket;
-    globalThis.WebSocket = class MockWebSocket {
-      constructor(_url: string) {}
-      addEventListener(event: string, handler: (...args: unknown[]) => void) {
-        if (event === "open") wsOnOpen = handler as () => void;
-        if (event === "message")
-          wsOnMessage = handler as (event: { data: string }) => void;
-      }
-      send(data: string) {
-        const msg = JSON.parse(data);
-        if (msg.method === "Browser.getWindowForTarget") {
-          setTimeout(() => {
-            wsOnMessage?.({
-              data: JSON.stringify({ id: 1, result: { windowId: 42 } }),
-            });
-          }, 0);
-        } else if (msg.method === "Browser.setWindowBounds") {
-          setTimeout(() => {
-            wsOnMessage?.({
-              data: JSON.stringify({
-                id: 2,
-                error: { message: "No window with given id" },
-              }),
-            });
-          }, 0);
-        }
-      }
-      close() {}
-    } as unknown as typeof WebSocket;
-
-    const promise = minimizeChromeWindow();
-    await new Promise((r) => setTimeout(r, 10));
-    wsOnOpen?.();
-
-    await expect(promise).rejects.toThrow("Browser.setWindowBounds failed");
-
-    globalThis.WebSocket = OriginalWebSocket;
-  });
-});
-
-describe("restoreChromeWindow", () => {
-  test("sends restore command via WebSocket", async () => {
-    const sentMessages: string[] = [];
-    let wsOnOpen: (() => void) | undefined;
-    let wsOnMessage: ((event: { data: string }) => void) | undefined;
-
-    fetchImpl = async (url) => {
-      const urlStr = String(url);
-      if (urlStr.includes("/json/list")) {
-        return new Response(
-          JSON.stringify([
-            {
-              type: "page",
-              webSocketDebuggerUrl: "ws://localhost:9222/devtools/page/ABC",
-            },
-          ]),
-        );
-      }
-      return new Response("{}", { status: 200 });
-    };
-
-    const OriginalWebSocket = globalThis.WebSocket;
-    globalThis.WebSocket = class MockWebSocket {
-      constructor(_url: string) {}
-      addEventListener(event: string, handler: (...args: unknown[]) => void) {
-        if (event === "open") wsOnOpen = handler as () => void;
-        if (event === "message")
-          wsOnMessage = handler as (event: { data: string }) => void;
-      }
-      send(data: string) {
-        sentMessages.push(data);
-        const msg = JSON.parse(data);
-        if (msg.method === "Browser.getWindowForTarget") {
-          setTimeout(() => {
-            wsOnMessage?.({
-              data: JSON.stringify({ id: 1, result: { windowId: 42 } }),
-            });
-          }, 0);
-        } else if (msg.method === "Browser.setWindowBounds") {
-          setTimeout(() => {
-            wsOnMessage?.({ data: JSON.stringify({ id: 2, result: {} }) });
-          }, 0);
-        }
-      }
-      close() {}
-    } as unknown as typeof WebSocket;
-
-    const promise = restoreChromeWindow();
-    await new Promise((r) => setTimeout(r, 10));
-    wsOnOpen?.();
-    await promise;
-
-    const boundsMsg = sentMessages.find((m) =>
-      m.includes("Browser.setWindowBounds"),
-    );
-    expect(boundsMsg).toBeDefined();
-    const parsed = JSON.parse(boundsMsg!);
-    expect(parsed.params.bounds.windowState).toBe("normal");
-
-    globalThis.WebSocket = OriginalWebSocket;
-  });
-});