@omercnet/paseo-shared-browser 1.2.2-next.240.1 → 1.2.2-next.242.1

package/OVERVIEW.md

@@ -1,4 +1,4 @@
-Shared Browser runs one real Chromium browser per workspace on the daemon host and shows that same live page to every connected Paseo client, so viewers and agents act on one page with one set of cookies and logins. Many viewers can watch, and one human at a time holds control. Open it from the Command Center, the **Shared Browser** composer pill, or, on Paseo 0.11 and newer, the sidebar footer.
+Shared Browser runs one real Chromium browser per workspace on the daemon host and shows that same live page to every connected Paseo client, so viewers and agents act on one page with one set of cookies and logins. Many viewers can watch, and one human at a time holds control. Open it from the Command Center, the **Shared Browser** composer pill, or the sidebar footer.
 
 ## How it works
 
@@ -13,7 +13,7 @@ New agents whose provider accepts external MCP servers receive a local MCP serve
 
 ## Setup
 
-- Paseo 0.9, 0.10 or 0.11, and Node.js 24 or newer on the daemon host.
+- Paseo ^0.11.0, and Node.js 24 or newer on the daemon host.
 - Chromium is downloaded when the plugin is installed and stored in the Paseo data directory. On Linux ARM64 nothing is downloaded, and you install a non-Snap Chromium at `/usr/bin/chromium` first. `PASEO_SHARED_BROWSER_CHROMIUM_EXECUTABLE` points the plugin at a different Chromium.
 
 ## Limits

package/README.md

@@ -110,7 +110,7 @@ Before upgrading the plugin on Windows, close active Shared Browser sessions and
 daemon; Windows does not allow the installer to replace runtime executables that are still running.
 
 Open a workspace, search the Command Center for **Open Shared Browser**, or tap the **Shared
-Browser** composer pill while a workspace session is open. On Paseo 0.11 or newer, a **Shared
+Browser** composer pill while a workspace session is open. A **Shared
 Browser (n)** row in the sidebar footer appears while browser sessions are open; it lists them and
 jumps to the chosen workspace's browser panel.
 
@@ -119,7 +119,7 @@ jumps to the chosen workspace's browser panel.
 The plugin automatically injects its stdio MCP adapter only when a new, non-internal agent is
 created with a provider that accepts external MCP servers. Agents that already exist, resumed
 sessions, imported sessions, and Paseo's internal agents are not modified. Paseo's built-in OMP
-provider accepts session MCP servers from Paseo 0.11, so new OMP agents receive the adapter there.
+provider accepts session MCP servers, so new OMP agents receive the adapter.
 Pi agents also receive the adapter, but require Pi's optional MCP support to
 launch it.
 
@@ -353,6 +353,11 @@ bun run check
 bun run test:unit
 ```
 
+The `test:tabs` native check requires explicit
+`PASEO_SHARED_BROWSER_AGENT_BROWSER_BINARY` and
+`PASEO_SHARED_BROWSER_CHROMIUM_EXECUTABLE` paths. It creates and cleans up its own
+temporary Paseo home and browser profile.
+
 `node scripts/test-image-capture-mounted.mjs --tooling-root /path/to/test-workspace`
 opt-in checks the real React/React Query image scheduling and viewing recovery hooks
 in JSDOM. The tooling workspace must already provide compatible React, react-dom,
@@ -417,10 +422,7 @@ runs the actual Paseo compiler on both plugin entries.
 Release Please maintains the version, changelog, component tag, and GitHub release from
 Conventional Commits in the monorepo.
 
-Both the Paseo daemon and app must satisfy the version range in `paseo-plugin.json`.
-The upstream 0.9, 0.10 and 0.11 ranges remain supported by the manifest;
-the tested `0.11.0-beta.3` prerelease is also allowed. Older daemon/client
-combinations still need runtime qualification. Encoded video is opt-in on the daemon and
+Both the Paseo daemon and app must satisfy `^0.11.0`. Encoded video is opt-in on the daemon and
 requires WebCodecs in a web client; JPEG is always available. The client surface uses React
 Native primitives and works in desktop, web, iOS, and Android Paseo clients.
 

package/client/sidebar.tsx

@@ -123,9 +123,8 @@ function createSidebarItem(client: PluginClientContext) {
   };
 }
 
-/** Sidebar footer row listing open sessions. Hosts before 0.11 lack the API and get no row. */
+/** Sidebar footer row listing open sessions. */
 export function contributeSharedBrowserSidebar(client: PluginClientContext): () => void {
-  if (typeof client.addSidebarFooterItem !== "function") return () => {};
   return client.addSidebarFooterItem({
     id: "shared-browser-sessions",
     title: "Shared Browser",

package/index.server.ts

@@ -109,12 +109,8 @@ export default function contribute(server: PluginServerContext) {
   server.handle(resizeBrowserRpc, handleResizeBrowser);
   server.handle(applyDevicePresetRpc, handleApplyDevicePreset);
   server.handle(sendBrowserInputRpc, handleSendBrowserInput);
-  // OMP accepts session MCP servers from Paseo 0.11.0-beta.1, the release that added
-  // registerUsageSource; 0.9/0.10 reject agent creation when an OMP config carries MCP servers.
-  const ompAcceptsMcp = typeof server.registerUsageSource === "function";
   server.before("agent.create", async ({ request }) => {
     if (request.config.internal) return request;
-    if (request.config.provider === "omp" && !ompAcceptsMcp) return request;
     const ticket = randomBytes(32).toString("base64url");
     if (!(await issueTicketWithinDeadline(ticket))) return request;
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-shared-browser",
-  "version": "1.2.2-next.240.1",
+  "version": "1.2.2-next.242.1",
   "description": "One real Chromium session per Paseo workspace, shared live across every connected client.",
   "keywords": [
     "browser",
@@ -50,6 +50,7 @@
     "test": "vitest run tests/contracts.test.ts tests/lease.test.ts tests/runtime-lifecycle.test.ts tests/agent-access.test.ts tests/agent-input-safety.test.ts tests/tabs.test.ts tests/tabs-runtime-loss.test.ts tests/composer-pills.test.ts tests/sidebar.test.ts tests/pointer-mapping.test.ts tests/frame-lifecycle.test.ts tests/viewport-resync.test.ts client server shared",
     "test:unit": "vitest run tests/contracts.test.ts tests/lease.test.ts tests/runtime-lifecycle.test.ts tests/agent-access.test.ts tests/agent-input-safety.test.ts tests/tabs.test.ts tests/tabs-runtime-loss.test.ts tests/composer-pills.test.ts tests/sidebar.test.ts tests/pointer-mapping.test.ts tests/frame-lifecycle.test.ts tests/viewport-resync.test.ts client server shared",
     "test:smoke": "vitest run tests/browser.smoke.test.ts tests/browser.drag-cancel.smoke.test.ts tests/xvfb.smoke.test.ts tests/browser.failed-open.smoke.test.ts tests/browser.background-tab.smoke.test.ts --testTimeout=30000",
+    "test:tabs": "vitest run tests/browser-tabs.smoke.test.ts --testTimeout=30000",
     "test:video": "vitest run tests/video.smoke.test.ts --testTimeout=30000"
   },
   "dependencies": {

package/paseo-plugin.json

@@ -1,8 +1,6 @@
 {
   "id": "shared-browser",
   "description": "One real Chromium session per Paseo workspace, shared live across every connected client.",
-  "requirements": {
-    "paseo": "^0.9.0 || ^0.10.0 || ^0.11.0 || 0.11.0-beta.3 || 0.11.0-beta.4"
-  },
+  "requirements": { "paseo": "^0.11.0" },
   "build": [["node", "scripts/prepare-dependencies.mjs"], ["npm", "run", "prepare:runtime"]]
 }

package/server/agent-browser-runtime.ts

@@ -368,6 +368,9 @@ export class AgentBrowserRuntime {
     const existingArguments = process.env.PASEO_SHARED_BROWSER_CHROMIUM_ARGS;
     const chromiumArguments = [
       existingArguments,
+      // agent-browser creates the launch page itself. Chromium's default
+      // startup window otherwise leaves an additional chrome://newtab page.
+      "--no-startup-window",
       videoExtension ? `--allowlisted-extension-id=${NATIVE_VIDEO_EXTENSION_ID}` : undefined,
     ]
       .filter(Boolean)

package/server/runtime-owner.ts

@@ -7,7 +7,9 @@ import {
   AgentBrowserRuntime,
   type AgentBrowserRuntimeOptions,
   type BrowserViewport,
+  type RuntimeTarget,
 } from "./agent-browser-runtime";
+import { CdpUnknownOutcomeError } from "./cdp";
 import { resolveBrowserRuntimeRoot } from "./runtime-path";
 import type { JsonValue } from "./runtime-protocol";
 import type { RuntimeOwner } from "./supervisor";
@@ -25,6 +27,7 @@ interface OwnedRuntime {
   rootTargetId: string;
   runtimeOptions: AgentBrowserRuntimeOptions;
   tabs: Map<string, Promise<AgentBrowserRuntime>>;
+  tabOrder: string[];
   display: PrivateVirtualDisplay | null;
   /** Bounded, secret-free reason an opted-in private display is not in use. */
   displayNotice: string | null;
@@ -53,6 +56,22 @@ function optionalMouseModifiers(data: Record<string, JsonValue>): [] | [number]
     : [browserGestureKeySchema.shape.modifiers.parse(data.modifiers)];
 }
 
+/** Retain known tab positions across unordered CDP snapshots; append newly discovered pages. */
+async function orderedTargets(owned: OwnedRuntime): Promise<RuntimeTarget[]> {
+  const targets = await owned.runtime.targets();
+  const byId = new Map(targets.map((target) => [target.targetId, target]));
+  const surviving = owned.tabOrder.filter((targetId) => byId.has(targetId));
+  const known = new Set(surviving);
+  for (const target of targets) {
+    if (!known.has(target.targetId)) {
+      surviving.push(target.targetId);
+      known.add(target.targetId);
+    }
+  }
+  owned.tabOrder = surviving;
+  return surviving.map((targetId) => byId.get(targetId)!);
+}
+
 /** Give each page its own CDP attachment and media state within one Chromium profile. */
 async function tabRuntime(owned: OwnedRuntime, targetId: string): Promise<AgentBrowserRuntime> {
   const existing = owned.tabs.get(targetId);
@@ -151,6 +170,7 @@ export async function createRuntimeOwner(
           rootTargetId: identity.targetId,
           runtimeOptions,
           tabs: new Map(),
+          tabOrder: [identity.targetId],
           display,
           displayNotice,
         };
@@ -179,20 +199,22 @@ export async function createRuntimeOwner(
           ? (input as Record<string, JsonValue>)
           : {};
       if (operation === "tabs.list") {
-        return (await owned.runtime.targets()).map(({ targetId, title, url }) => ({
+        return (await orderedTargets(owned)).map(({ targetId, title, url }) => ({
           targetId,
           title,
           url,
         }));
       }
       if (operation === "tabs.create") {
-        if ((await owned.runtime.targets()).length >= MAX_BROWSER_TABS)
+        if ((await orderedTargets(owned)).length >= MAX_BROWSER_TABS)
           throw new Error("Browser tab limit reached");
-        return { targetId: await owned.runtime.createTarget() };
+        const targetId = await owned.runtime.createTarget();
+        owned.tabOrder.push(targetId);
+        return { targetId };
       }
       if (operation === "tabs.close") {
         const targetId = String(data.targetId);
-        const targets = await owned.runtime.targets();
+        const targets = await orderedTargets(owned);
         if (!targets.some((target) => target.targetId === targetId)) {
           throw new Error("Browser tab is no longer available");
         }
@@ -207,7 +229,20 @@ export async function createRuntimeOwner(
           owned.rootTargetId = successor.targetId;
         }
         await owned.runtime.closeTarget(targetId);
+        // Target.closeTarget can acknowledge before Chromium drops the page from
+        // its target list. Success requires observing its absence; the close is
+        // never replayed, and exhaustion is reported rather than assumed.
+        let gone = false;
+        for (let attempt = 0; attempt < 20 && !gone; attempt++) {
+          gone = !(await owned.runtime.targets()).some((target) => target.targetId === targetId);
+          if (gone) break;
+          const { promise, resolve } = Promise.withResolvers<void>();
+          setTimeout(resolve, 50);
+          await promise;
+        }
         owned.tabs.delete(targetId);
+        if (!gone) throw new CdpUnknownOutcomeError("Browser tab close could not be confirmed");
+        owned.tabOrder = owned.tabOrder.filter((id) => id !== targetId);
         return null;
       }
       const targetId = typeof data.targetId === "string" ? data.targetId : null;

package/server/supervisor.ts

@@ -828,8 +828,8 @@ export class RuntimeSupervisor<Runtime extends RuntimeInstance = RuntimeInstance
   private async selectAgentTab(binding: AgentBinding, tabId: string): Promise<BrowserState> {
     this.assertAgentBindingCurrent(binding);
     if (binding.tabId === tabId && binding.viewerToken) {
-      const current = await this.browserPolicy.status(binding.viewerToken);
-      this.assertAgentBindingCurrent(binding);
+      // Same-tab selection needs the same expiry recovery as status/capture.
+      const current = await this.requestAgentObservation(binding, "status", {});
       if (binding.tabId !== tabId) {
         throw new RuntimeProtocolError("INVALID_REQUEST", "Agent tab changed during selection");
       }

package/server/tab-close-confirmation.test.ts

@@ -0,0 +1,97 @@
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { createRuntimeOwner } from "./runtime-owner";
+
+type Owner = Awaited<ReturnType<typeof createRuntimeOwner>>;
+type Owned = Parameters<Owner["request"]>[0];
+
+beforeEach(() => vi.useFakeTimers());
+afterEach(() => vi.useRealTimers());
+
+async function fixture(lingerSnapshots: number | null) {
+  const owner = await createRuntimeOwner({ virtualDisplay: false, nativeVideo: false });
+  const state = { ids: ["root", "closing"], closing: false, polls: 0, next: 0 };
+  const native = {
+    targets: vi.fn(async () => {
+      if (state.closing && lingerSnapshots !== null && state.polls++ >= lingerSnapshots) {
+        state.ids = state.ids.filter((id) => id !== "closing");
+      } else if (state.closing && lingerSnapshots === null) {
+        state.polls++;
+      }
+      return state.ids.map((targetId) => ({ targetId, title: targetId, url: "about:blank" }));
+    }),
+    closeTarget: vi.fn(async () => {
+      state.closing = true;
+    }),
+    createTarget: vi.fn(async () => {
+      const id = `new-${++state.next}`;
+      state.ids.unshift(id);
+      return id;
+    }),
+    selectTarget: vi.fn(async () => {}),
+  };
+  const owned = {
+    runtimeId: "review-runtime",
+    runtime: native,
+    rootTargetId: "root",
+    runtimeOptions: {},
+    tabs: new Map(),
+    tabOrder: ["root", "closing"],
+    display: null,
+    displayNotice: null,
+  } as unknown as Owned;
+  return { owner, owned, native, state };
+}
+
+it("confirms an acknowledged close only after the target disappears without replay", async () => {
+  const f = await fixture(2);
+  const pending = f.owner.request(f.owned, "tabs.close", { targetId: "closing" });
+  await vi.runAllTimersAsync();
+  await expect(pending).resolves.toBeNull();
+  expect(f.native.closeTarget).toHaveBeenCalledTimes(1);
+  expect(f.state.polls).toBe(3);
+  expect(
+    ((await f.owner.request(f.owned, "tabs.list", null)) as { targetId: string }[]).map(
+      (x) => x.targetId,
+    ),
+  ).toEqual(["root"]);
+});
+
+it("fails explicitly, without replaying close or reordering, when the target never disappears", async () => {
+  const f = await fixture(null);
+  const outcome = f.owner.request(f.owned, "tabs.close", { targetId: "closing" }).then(
+    () => "ok",
+    (error) => String(error),
+  );
+  await vi.runAllTimersAsync();
+  expect(await outcome).toContain(
+    "CdpUnknownOutcomeError: Browser tab close could not be confirmed",
+  );
+  expect(f.native.closeTarget).toHaveBeenCalledTimes(1);
+  expect(f.state.polls).toBe(20);
+  const ids = (await f.owner.request(f.owned, "tabs.list", null)) as { targetId: string }[];
+  expect(ids.map((tab) => tab.targetId)).toEqual(["root", "closing"]);
+});
+
+it("retains known ordering across unordered snapshots and appends explicit creations", async () => {
+  const f = await fixture(null);
+  f.state.ids = ["third", "closing", "root"];
+  const ids = async () =>
+    ((await f.owner.request(f.owned, "tabs.list", null)) as { targetId: string }[]).map(
+      (x) => x.targetId,
+    );
+  expect(await ids()).toEqual(["root", "closing", "third"]);
+  f.state.ids = ["closing", "root", "third"];
+  expect(await ids()).toEqual(["root", "closing", "third"]);
+  await f.owner.request(f.owned, "tabs.create", null);
+  await f.owner.request(f.owned, "tabs.create", null);
+  expect(await ids()).toEqual(["root", "closing", "third", "new-1", "new-2"]);
+});
+
+it("preserves the existing last-tab refusal", async () => {
+  const f = await fixture(null);
+  f.state.ids = ["root"];
+  await expect(f.owner.request(f.owned, "tabs.close", { targetId: "root" })).rejects.toThrow(
+    "last browser tab",
+  );
+  expect(f.native.closeTarget).not.toHaveBeenCalled();
+});