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

package/README.md

@@ -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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-shared-browser",
-  "version": "1.2.2-next.241.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/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();
+});