@omercnet/paseo-shared-browser 4.1.2 → 4.1.3-next.367.1

package/npm-shrinkwrap.json

@@ -1,15 +1,15 @@
 {
   "name": "@omercnet/paseo-shared-browser",
-  "version": "4.1.2",
+  "version": "4.1.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@omercnet/paseo-shared-browser",
-      "version": "4.1.2",
+      "version": "4.1.3",
       "dependencies": {
         "@getpaseo/plugin": "0.14.0",
-        "@modelcontextprotocol/sdk": "1.30.0",
+        "@modelcontextprotocol/sdk": "1.32.2",
         "agent-browser": "0.40.0",
         "esbuild": "0.28.2",
         "zod": "4.6.7"
@@ -511,9 +511,9 @@
       }
     },
     "node_modules/@modelcontextprotocol/sdk": {
-      "version": "1.30.0",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.30.0.tgz",
-      "integrity": "sha512-xKd8OIzlqNzcqcNumGAa6g+PW2kjD5vrpcKOnfldAUPP3j7lnqMPwlTXQm8gF+UwH72z0lqaRbjr9hqGz0eITA==",
+      "version": "1.32.2",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.32.2.tgz",
+      "integrity": "sha512-SWsVtH/0vULSQStoZ6xxH2K09Li8fXYTMC64ZeogCdpZ3XSi1eCPOByV1OpuJxuI3OcmHhosDWYyii07tpPsLw==",
       "license": "MIT",
       "dependencies": {
         "@hono/node-server": "^1.19.9 || ^2.0.5",
@@ -1204,9 +1204,9 @@
       }
     },
     "node_modules/hono": {
-      "version": "4.13.14",
-      "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.14.tgz",
-      "integrity": "sha512-yhRLQ21U6qa9Hsu2N7Qcbh8tE+WKEcoErjIo56LeSGiGXGp9sA7UpE86Ui9uexb61KakiGwuHMn2QdV7w6i6kQ==",
+      "version": "4.13.16",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.16.tgz",
+      "integrity": "sha512-AOLOEhvrV+iH92xXCnFr/5+3KjPKcI3xP63XJtX5spAnkznPdHijlIsUTpi7/9EhWqrTCekw5c5zh1K+YsVw7A==",
       "license": "MIT",
       "engines": {
         "node": ">=16.9.0"
@@ -1233,9 +1233,9 @@
       }
     },
     "node_modules/i18next": {
-      "version": "26.5.12",
-      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.5.12.tgz",
-      "integrity": "sha512-vTt8tc3y5axoU7wwTYg8vjpILLyP33a5GyGJAVI7FDRx1XueYxZVIkcVeStoftrVnAM/o28hKvK0sslucDI9aQ==",
+      "version": "26.6.0",
+      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.6.0.tgz",
+      "integrity": "sha512-jpb1n5386s9mbBLNF6tSNIVhbBUUNiNeDyjWte+uxHP/Wr+CEy7WBM8q29TkfQ46VbwKeJFYdQJK3pSUhLp4CQ==",
       "funding": [
         {
           "type": "individual",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-shared-browser",
-  "version": "4.1.2",
+  "version": "4.1.3-next.367.1",
   "description": "One real Chromium session per Paseo workspace, shared live across every connected client.",
   "keywords": [
     "browser",
@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "@getpaseo/plugin": "0.14.0",
-    "@modelcontextprotocol/sdk": "1.30.0",
+    "@modelcontextprotocol/sdk": "1.32.2",
     "agent-browser": "0.40.0",
     "esbuild": "0.28.2",
     "zod": "4.6.7"

package/server/agent-browser-runtime.ts

@@ -317,6 +317,8 @@ export class AgentBrowserRuntime {
   private shutDown = false;
   /** A daemon was launched for this session, so absence of evidence is not proof of exit. */
   private daemonLaunched = false;
+  /** The in-flight initial `open`, settled only once the daemon it started was captured. */
+  private opening: Promise<unknown> | null = null;
   private readonly nativeVideo: boolean;
   private video: NativeVideoCapture | null = null;
   private videoRetirement: Promise<void> | null = null;
@@ -379,36 +381,53 @@ export class AgentBrowserRuntime {
     // From here a nonce-owned daemon may exist even if open rejects (e.g. navigation failure).
     this.daemonLaunched = true;
     this.daemon = null;
+    const opening = this.openDaemon([
+      "--session",
+      this.session,
+      "--profile",
+      this.profilePath,
+      "--executable-path",
+      this.executablePath,
+      ...(videoExtension ? ["--extension", videoExtension] : []),
+      "--hide-scrollbars",
+      "false",
+      ...(this.headed ? ["--headed"] : []),
+      ...(chromiumArguments ? ["--args", chromiumArguments] : []),
+      "--json",
+      "open",
+      this.initialUrl,
+    ]);
+    this.opening = opening;
     let opened: unknown;
     try {
-      opened = await this.invoke([
-        "--session",
-        this.session,
-        "--profile",
-        this.profilePath,
-        "--executable-path",
-        this.executablePath,
-        ...(videoExtension ? ["--extension", videoExtension] : []),
-        "--hide-scrollbars",
-        "false",
-        ...(this.headed ? ["--headed"] : []),
-        ...(chromiumArguments ? ["--args", chromiumArguments] : []),
-        "--json",
-        "open",
-        this.initialUrl,
-      ]);
-    } catch (error) {
-      // Record the daemon a failed open left behind: since agent-browser 0.40.0 `close`
-      // removes the PID file before returning, after which its exit is unobservable.
-      await this.captureDaemon().catch(() => undefined);
-      throw error;
+      opened = await opening;
+    } finally {
+      if (this.opening === opening) this.opening = null;
     }
     this.assertRuntimeOpen();
     const targetId = findString(opened, ["targetId", "target_id"]);
+    await this.connectCdp(targetId);
+  }
+
+  /**
+   * Runs the initial `open` and records the daemon it started before settling. Since
+   * agent-browser 0.40.0 `close` removes the PID file before returning, after which the
+   * daemon's exit is unobservable, so shutdown awaits this before issuing `close`.
+   */
+  private async openDaemon(args: string[]): Promise<unknown> {
+    let opened: unknown;
+    try {
+      opened = await this.invoke(args);
+    } catch (error) {
+      await this.protectIpcMetadata();
+      // The PID file may be a stale record of an earlier daemon, written before this one
+      // recorded its own: drop it when disproven and leave it to shutdown's lazy lookup.
+      await this.captureDaemon(true).catch(() => undefined);
+      throw error;
+    }
     await this.protectIpcMetadata();
     await this.captureDaemon();
-    this.assertRuntimeOpen();
-    await this.connectCdp(targetId);
+    return opened;
   }
 
   /** Attach an independent page controller to an existing browser session. */
@@ -1777,6 +1796,11 @@ export class AgentBrowserRuntime {
 
   /** Close, then require observed exit; escalate to a verified-owned SIGKILL and observe that too. */
   private async stopDaemon(force: boolean): Promise<void> {
+    // A launch still awaiting `open` must capture its daemon before `close` removes the PID file.
+    await this.opening?.catch(() => undefined);
+    // A failed open may have found only a stale record, its daemon writing the PID file later:
+    // record that before `close` removes it, still skipping a record disproven as ours.
+    if (this.daemonLaunched && !this.daemon) await this.captureDaemon(true).catch(() => undefined);
     let forced = force;
     if (!forced) {
       try {
@@ -1797,11 +1821,20 @@ export class AgentBrowserRuntime {
   /**
    * Records the PID-file daemon. Only a PID whose environment carries this runtime's own
    * nonce gets a verified identity; anything else is observable but never signalled.
+   * `possiblyStale` drops a PID proven not this runtime's live daemon (foreign or gone), so
+   * a later lookup re-reads the file; an unknown probe keeps a live PID as exit evidence.
    */
-  private async captureDaemon(): Promise<void> {
+  private async captureDaemon(possiblyStale = false): Promise<void> {
     const pid = await this.daemonPid();
     if (pid === null) return;
     const probe = await probeProcess(pid, this.ownerNonce);
+    if (
+      possiblyStale &&
+      (probe.status === "foreign" ||
+        probe.status === "absent" ||
+        (probe.status === "unknown" && !processExists(pid)))
+    )
+      return;
     this.daemon = { pid, identity: probe.status === "owned" ? probe.identity : null };
   }
 

package/server/daemon-shutdown.test.ts

@@ -38,6 +38,9 @@ const cli = vi.hoisted(() => ({
   closes: 0,
   /** Set to make `open` fail after its side effect, like a navigation failure. */
   onOpen: null as null | (() => void),
+  /** Set to hold the `open` reply until it resolves, like a slow initial navigation. */
+  openReply: null as null | Promise<void>,
+  opens: 0,
   version: "0.37.1",
 }));
 vi.mock("node:child_process", async (importOriginal) => ({
@@ -52,6 +55,11 @@ vi.mock("node:child_process", async (importOriginal) => ({
       cli.closes += 1;
       cli.onClose?.();
     }
+    if (args.includes("open")) cli.opens += 1;
+    if (args.includes("open") && cli.openReply) {
+      void cli.openReply.then(() => callback(null, { stdout: "{}\n" }));
+      return;
+    }
     if (args.includes("open") && cli.onOpen) {
       cli.onOpen();
       callback(new Error("Navigation failed: net::ERR_CONNECTION_REFUSED"));
@@ -71,6 +79,8 @@ afterEach(async () => {
   cli.onClose = null;
   cli.closes = 0;
   cli.onOpen = null;
+  cli.openReply = null;
+  cli.opens = 0;
   cli.version = "0.37.1";
   probe.unreadable = false;
   probe.simulated = null;
@@ -223,6 +233,27 @@ describe("unverifiable daemon identity (platforms without /proc, unowned PIDs)",
     expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
   });
 
+  it("confirms the exit of a daemon left by a failed open when its identity probe is unknown", async () => {
+    const f = await fixture();
+    // The normal probe result where /proc is missing or unreadable (macOS, Windows).
+    probe.unreadable = true;
+    const daemon = await ownChild(f.native.ownerNonce);
+    const pidFile = join(f.ipc, "owned.pid");
+    cli.version = AGENT_BROWSER_VERSION;
+    cli.onOpen = () => writeFileSync(pidFile, String(daemon.pid));
+    // agent-browser >= 0.40.0: close returns only after the daemon removed its PID file.
+    cli.onClose = () => {
+      daemon.kill("SIGTERM");
+      rmSync(pidFile, { force: true });
+    };
+    await expect(f.runtime.launch()).rejects.toThrow("agent-browser command failed");
+    expect(f.native.daemon).toEqual({ pid: daemon.pid, identity: null });
+    const kill = vi.spyOn(process, "kill");
+    await f.runtime.shutdown();
+    expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+    await exited(daemon);
+  });
+
   it("has nothing to observe or signal for a runtime that never launched", async () => {
     // Never launched: ordinary cleanup has nothing to observe.
     const f = await fixture(150);
@@ -308,6 +339,85 @@ describe.each(ownershipModes)(
       expect(daemon.pid && alive(daemon.pid)).toBe(false);
     });
 
+    it("does not take a stale PID file left before a failed open as the exit of a later daemon", async () => {
+      const f = await fixture(200);
+      const stale = await ownChild();
+      stale.kill("SIGKILL");
+      await exited(stale);
+      const pidFile = join(f.ipc, "owned.pid");
+      // A crashed earlier daemon left its PID file; the new one has not recorded itself yet.
+      await writeFile(pidFile, String(stale.pid));
+      cli.version = AGENT_BROWSER_VERSION;
+      cli.onOpen = () => undefined;
+      await expect(f.runtime.launch()).rejects.toThrow("agent-browser command failed");
+      // The new daemon records itself only after the open already failed.
+      const daemon = await ownChild(f.native.ownerNonce);
+      own(daemon);
+      await writeFile(pidFile, String(daemon.pid));
+      const kill = vi.spyOn(process, "kill");
+      await f.runtime.shutdown();
+      expect(kill).toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+      await exited(daemon);
+      expect(daemon.pid && alive(daemon.pid)).toBe(false);
+    });
+
+    it("confirms the exit of a daemon that records its PID after a failed open, before close removes it", async () => {
+      const f = await fixture();
+      const stale = await ownChild();
+      stale.kill("SIGKILL");
+      await exited(stale);
+      const pidFile = join(f.ipc, "owned.pid");
+      // A crashed earlier daemon left its PID file; the new one has not recorded itself yet.
+      await writeFile(pidFile, String(stale.pid));
+      cli.version = AGENT_BROWSER_VERSION;
+      cli.onOpen = () => undefined;
+      await expect(f.runtime.launch()).rejects.toThrow("agent-browser command failed");
+      expect(f.native.daemon).toBeNull();
+      // The new daemon records itself only after the open already failed.
+      const daemon = await ownChild(f.native.ownerNonce);
+      own(daemon);
+      await writeFile(pidFile, String(daemon.pid));
+      // agent-browser >= 0.40.0: close returns only after the daemon removed its PID file.
+      cli.onClose = () => {
+        daemon.kill("SIGTERM");
+        rmSync(pidFile, { force: true });
+      };
+      const kill = vi.spyOn(process, "kill");
+      await f.runtime.shutdown();
+      expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+      await exited(daemon);
+    });
+
+    it("captures the daemon of a launch still awaiting open before a racing shutdown closes it", async () => {
+      const f = await fixture();
+      const daemon = await ownChild(f.native.ownerNonce);
+      own(daemon);
+      const pidFile = join(f.ipc, "owned.pid");
+      cli.version = AGENT_BROWSER_VERSION;
+      // The daemon recorded its PID, but the initial open replies only later.
+      await writeFile(pidFile, String(daemon.pid));
+      const { promise: openReply, resolve: reply } = Promise.withResolvers<void>();
+      cli.openReply = openReply;
+      // agent-browser >= 0.40.0: close returns only after the daemon removed its PID file;
+      // the aborted open then replies with the PID file already gone.
+      cli.onClose = () => {
+        daemon.kill("SIGTERM");
+        rmSync(pidFile, { force: true });
+        reply();
+      };
+      const launching = f.runtime.launch();
+      await vi.waitFor(() => expect(cli.opens).toBe(1));
+      const kill = vi.spyOn(process, "kill");
+      const stopping = f.runtime.shutdown();
+      // A real-time race: the open replies on its own a little later unless close ends it
+      // first; awaiting the launch from shutdown is exactly what is under test.
+      setTimeout(reply, 100);
+      await expect(launching).rejects.toThrow("shutting down");
+      await stopping;
+      expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+      await exited(daemon);
+    });
+
     it("shares one in-flight shutdown and never reports success after a failed one", async () => {
       const f = await fixture(150);
       const daemon = await ownChild();