@wenrwa/marketplace-cli 0.7.1 → 0.7.3

package/dist/__tests__/bridge-browser-relay.test.js

@@ -62,7 +62,10 @@ class FakeBrowserDriver {
     }
     async back() { }
     async forward() { }
-    async reload() { }
+    reloadCalls = 0;
+    async reload() {
+        this.reloadCalls += 1;
+    }
     onFrame(cb) {
         this.frameCb = cb;
     }
@@ -1120,3 +1123,80 @@ describe('relay client — browser no-consumer sweep (cbs-14)', () => {
         await closeRelay(relay.wss);
     });
 });
+describe('relay client — browser tabs (cvt-07)', () => {
+    async function boot(extra = {}) {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = {};
+        let clock = 1_000;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            nowFn: () => clock,
+            createBrowserDriver: ({ sessionId }) => {
+                const d = new FakeBrowserDriver();
+                drivers[sessionId] = d;
+                return d;
+            },
+            ...extra,
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        const auth = await q.next();
+        const settle = () => new Promise((r) => setTimeout(r, 20));
+        const open = async (sessionId, url) => {
+            ws.send(JSON.stringify({ t: 'browser-open', sessionId, url }));
+            await settle();
+        };
+        return {
+            relay, handle, ws, q, auth, drivers, open, settle,
+            advance: (ms) => { clock += ms; },
+            done: async () => { handle.close(); await closeRelay(relay.wss); },
+        };
+    }
+    it('advertises its capabilities in the auth frame (and nothing when it has none)', async () => {
+        const withCaps = await boot({ capabilities: ['browser-tabs'] });
+        expect(withCaps.auth).toEqual({ v: 1, relayToken: 'tok', caps: ['browser-tabs'] });
+        await withCaps.done();
+        const without = await boot();
+        expect(without.auth).toEqual({ v: 1, relayToken: 'tok' });
+        await without.done();
+    });
+    it('two pane sessions are two independent tabs: reload and close reach only their own', async () => {
+        const t = await boot();
+        await t.open('browser:c1:pane-a', 'https://a.example');
+        await t.open('browser:c1:pane-b', 'https://b.example');
+        const a = t.drivers['browser:c1:pane-a'];
+        const b = t.drivers['browser:c1:pane-b'];
+        expect(a.startCalls).toEqual(['https://a.example']);
+        expect(b.startCalls).toEqual(['https://b.example']);
+        t.ws.send(JSON.stringify({ t: 'browser-reload', sessionId: 'browser:c1:pane-a' }));
+        await t.settle();
+        expect(a.reloadCalls).toBe(1);
+        expect(b.reloadCalls).toBe(0);
+        t.ws.send(JSON.stringify({ t: 'browser-close', sessionId: 'browser:c1:pane-b' }));
+        await t.settle();
+        expect(b.stopCalls).toBe(1);
+        expect(a.stopCalls).toBe(0);
+        await t.done();
+    });
+    it('at the tab cap, opening one more puts the stalest tab to sleep (tab-evicted)', async () => {
+        const t = await boot({ maxBrowserTabs: 2 });
+        await t.open('browser:c1:p1', 'https://one.example');
+        t.advance(1_000);
+        await t.open('browser:c1:p2', 'https://two.example');
+        t.advance(1_000);
+        // p1 is being watched (an ack) — p2 is now the stalest.
+        t.ws.send(JSON.stringify({ t: 'browser-frame-ack', sessionId: 'browser:c1:p1', seq: 1 }));
+        await t.settle();
+        t.advance(1_000);
+        await t.open('browser:c1:p3', 'https://three.example');
+        expect(t.drivers['browser:c1:p2'].sleepCalls).toEqual(['tab-evicted']);
+        expect(t.drivers['browser:c1:p1'].sleepCalls).toEqual([]);
+        expect(t.drivers['browser:c1:p3'].startCalls).toEqual(['https://three.example']);
+        const evicted = await t.q.next();
+        expect(evicted).toEqual({ t: 'browser-state', sessionId: 'browser:c1:p2', state: 'asleep', reason: 'tab-evicted' });
+        await t.done();
+    });
+});

package/dist/__tests__/bridge-browser-tabs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bridge-browser-tabs.test.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cvt-07 — each cloud Browser pane is its own TAB in the box's one browser.
+ *
+ * Two drivers sharing one browserHost.ts against a faked multi-target CDP
+ * endpoint that behaves like Chromium's flattened sessions: every page target
+ * gets its own CDP session id, screencast frames carry that session id, and a
+ * navigation/reload repaints ONLY the target it was sent to.
+ *
+ * docs/prd/canvas-tools.md (module 7) + issues/cvt-07-cloud-browser-tabs.md.
+ */
+const browserDriver_1 = require("../bridge/browserDriver");
+const browserHost_1 = require("../bridge/browserHost");
+class FakeChildProcess {
+    killCount = 0;
+    stderr = { on: () => { } };
+    exitHandlers = [];
+    on(event, cb) {
+        if (event === 'exit')
+            this.exitHandlers.push(cb);
+    }
+    kill() {
+        this.killCount += 1;
+    }
+    emitExit(code, signal = null) {
+        for (const cb of this.exitHandlers)
+            cb(code, signal);
+    }
+}
+/** A fake Chromium DevTools endpoint with real per-target state: which URL
+ *  each page shows, and which CDP session drives which target. */
+class FakeChromium {
+    sent = [];
+    pages = new Map([['page-initial', { url: 'about:blank' }]]);
+    sessions = new Map(); // cdp session id -> target id
+    nextTarget = 1;
+    nextSession = 1;
+    onMessage = null;
+    onCloseCb = null;
+    transport = {
+        send: (data) => {
+            const msg = JSON.parse(data);
+            this.sent.push(msg);
+            const result = this.handle(msg);
+            queueMicrotask(() => this.onMessage?.(JSON.stringify({ id: msg.id, result })));
+        },
+        close: () => {
+            queueMicrotask(() => this.onCloseCb?.(undefined));
+        },
+        on: (event, cb) => {
+            if (event === 'message')
+                this.onMessage = cb;
+            else if (event === 'close')
+                this.onCloseCb = cb;
+        },
+    };
+    handle(msg) {
+        const target = msg.sessionId ? this.sessions.get(msg.sessionId) : undefined;
+        switch (msg.method) {
+            case 'Target.getTargets':
+                return { targetInfos: [...this.pages.keys()].map((targetId) => ({ targetId, type: 'page' })) };
+            case 'Target.createTarget': {
+                const targetId = `page-${this.nextTarget++}`;
+                this.pages.set(targetId, { url: msg.params.url });
+                return { targetId };
+            }
+            case 'Target.attachToTarget': {
+                const sessionId = `cdp-${this.nextSession++}`;
+                this.sessions.set(sessionId, msg.params.targetId);
+                return { sessionId };
+            }
+            case 'Target.closeTarget':
+                this.pages.delete(msg.params.targetId);
+                return { success: true };
+            case 'Page.navigate':
+                if (target)
+                    this.pages.get(target).url = msg.params.url;
+                if (msg.sessionId)
+                    this.repaint(msg.sessionId);
+                return { frameId: 'f' };
+            case 'Page.reload':
+                if (msg.sessionId)
+                    this.repaint(msg.sessionId);
+                return {};
+            case 'Page.captureScreenshot':
+                return { data: `shot:${target ? this.pages.get(target)?.url : '?'}` };
+            default:
+                return {};
+        }
+    }
+    /** Chromium repaints the target a command was sent to — and only it. */
+    repaint(cdpSessionId) {
+        const target = this.sessions.get(cdpSessionId);
+        const url = this.pages.get(target)?.url;
+        queueMicrotask(() => this.onMessage?.(JSON.stringify({
+            method: 'Page.screencastFrame',
+            sessionId: cdpSessionId,
+            params: { sessionId: 1, data: `paint:${url}`, metadata: { deviceWidth: 1280, deviceHeight: 800 } },
+        })));
+    }
+    calls(method) {
+        return this.sent.filter((m) => m.method === method);
+    }
+}
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+function setup() {
+    const chromium = new FakeChromium();
+    const proc = new FakeChildProcess();
+    let launches = 0;
+    const launchChromiumFn = () => {
+        launches += 1;
+        return { proc, wsUrl: Promise.resolve('ws://fake-devtools') };
+    };
+    const host = (0, browserHost_1.createBrowserHost)({ launchChromiumFn, wsFactory: () => chromium.transport });
+    const noTimer = { setIntervalFn: () => 'h', clearIntervalFn: () => { } };
+    const tab = () => {
+        const driver = (0, browserDriver_1.createBrowserDriver)({ host, ...noTimer });
+        const frames = [];
+        driver.onFrame((f) => {
+            frames.push(f);
+            driver.ackFrame();
+        });
+        return { driver, frames };
+    };
+    return { chromium, proc, host, tab, launches: () => launches };
+}
+describe('browser tabs (cvt-07)', () => {
+    it('two panes share ONE Chromium and each gets its own page target', async () => {
+        const { chromium, host, tab, launches } = setup();
+        const a = tab();
+        const b = tab();
+        await Promise.all([a.driver.start('https://a.example'), b.driver.start('https://b.example')]);
+        expect(launches()).toBe(1);
+        expect(host.leaseCount).toBe(2);
+        // The first tab claims Chromium's launch page; the second creates its own.
+        expect(chromium.calls('Target.createTarget')).toHaveLength(1);
+        expect([...chromium.pages.values()].map((p) => p.url).sort()).toEqual(['https://a.example', 'https://b.example']);
+    });
+    it('navigates independently: each pane only ever sees its own site', async () => {
+        const { tab } = setup();
+        const a = tab();
+        const b = tab();
+        await a.driver.start('https://a.example');
+        await b.driver.start('https://b.example');
+        await flush();
+        await a.driver.navigate('https://a.example/next');
+        await flush();
+        expect(a.frames.map((f) => f.data).every((d) => d.includes('a.example'))).toBe(true);
+        expect(b.frames.map((f) => f.data).every((d) => d.includes('b.example'))).toBe(true);
+        expect(a.frames.some((f) => f.data.includes('a.example/next'))).toBe(true);
+    });
+    it('reloading one pane emits no frames for the other', async () => {
+        const { chromium, tab } = setup();
+        const a = tab();
+        const b = tab();
+        await a.driver.start('https://a.example');
+        await b.driver.start('https://b.example');
+        await flush();
+        const aBefore = a.frames.length;
+        const bBefore = b.frames.length;
+        await a.driver.reload();
+        await flush();
+        expect(a.frames.length).toBeGreaterThan(aBefore);
+        expect(b.frames.length).toBe(bBefore);
+        // The reload went to A's CDP session only.
+        const reloads = chromium.calls('Page.reload');
+        expect(reloads).toHaveLength(1);
+        expect(chromium.sessions.get(reloads[0].sessionId)).not.toBe(chromium.sessions.get(chromium.calls('Page.navigate').find((n) => n.params.url === 'https://b.example').sessionId));
+    });
+    it('closing a pane closes only its tab; the last tab closed kills Chromium', async () => {
+        const { chromium, proc, host, tab } = setup();
+        const a = tab();
+        const b = tab();
+        const bStates = [];
+        b.driver.onState((s) => bStates.push(s.state));
+        await a.driver.start('https://a.example');
+        await b.driver.start('https://b.example');
+        a.driver.sleep('closed-by-pane');
+        await flush();
+        expect(proc.killCount).toBe(0);
+        expect(host.leaseCount).toBe(1);
+        expect([...chromium.pages.values()].map((p) => p.url)).toEqual(['https://b.example']);
+        expect(bStates).not.toContain('asleep');
+        expect(bStates).not.toContain('closed');
+        b.driver.stop();
+        expect(proc.killCount).toBe(1);
+        expect(host.leaseCount).toBe(0);
+    });
+    it('a Chromium crash closes every tab, and the next pane relaunches it', async () => {
+        const { proc, tab, launches } = setup();
+        const a = tab();
+        const b = tab();
+        const states = [];
+        a.driver.onState((s) => states.push(`a:${s.state}`));
+        b.driver.onState((s) => states.push(`b:${s.state}`));
+        await a.driver.start('https://a.example');
+        await b.driver.start('https://b.example');
+        proc.emitExit(1);
+        expect(states).toContain('a:closed');
+        expect(states).toContain('b:closed');
+        const c = tab();
+        await c.driver.start('https://c.example');
+        expect(launches()).toBe(2);
+    });
+});

package/dist/__tests__/claude-session-history.test.js

@@ -80,3 +80,17 @@ describe('hasClaudeSessionHistory', () => {
         expect(result).toBe(true);
     });
 });
+describe('a registered folder with a trailing slash (2026-10-04 "Session ID … is already in use")', () => {
+    it('slugs exactly like the same folder without the slash', () => {
+        expect((0, claudeSessionHistory_1.claudeProjectSlug)('/Users/me/Wenrwa Projects/Site/')).toBe((0, claudeSessionHistory_1.claudeProjectSlug)('/Users/me/Wenrwa Projects/Site'));
+        expect((0, claudeSessionHistory_1.claudeProjectSlug)('/Users/me/Wenrwa Projects/Site/')).toBe('-Users-me-Wenrwa-Projects-Site');
+    });
+    it('finds the agent transcript, so the launch resumes instead of re-creating the session', () => {
+        const seen = [];
+        const found = (0, claudeSessionHistory_1.hasAgentSessionHistory)('/Users/me/Wenrwa Projects/Site/', 'abc', {
+            env: { CLAUDE_CONFIG_DIR: '/cfg' },
+            existsSync: (p) => { seen.push(String(p)); return String(p) === '/cfg/projects/-Users-me-Wenrwa-Projects-Site/abc.jsonl'; },
+        });
+        expect(found).toBe(true);
+    });
+});

package/dist/bridge/browserDriver.d.ts

@@ -37,6 +37,7 @@
  */
 import { ChromiumLaunchHandle } from './chromiumLauncher';
 import { CdpTransportLike } from './cdpClient';
+import type { BrowserHost } from './browserHost';
 import { BrowserInputEvent, BrowserSessionState } from './browserFrames';
 /** container -> pane screencast frame, minus the wire envelope (`t`,
  *  `sessionId`) — the driver doesn't know the relay session id; the caller
@@ -228,6 +229,13 @@ export interface BrowserDriverOpts {
      *  log line (frames delivered, screencast vs capture split, drops) every
      *  N frames processed, never per-frame. Default 50. */
     summaryFrameInterval?: number;
+    /** cvt-07: the box's shared Chromium (browserHost.ts). When set, this
+     *  driver is ONE TAB in that process — it leases the browser connection,
+     *  creates (or claims the spare) page target, and on stop()/sleep() closes
+     *  only its own target; the host kills Chromium when the last tab goes.
+     *  Absent → the pre-cvt-07 behaviour: this driver launches and owns its
+     *  own Chromium (launchChromiumFn/wsFactory above). */
+    host?: BrowserHost;
 }
 /** Default real transport: wraps a `ws` WebSocket connected to the
  *  Chromium DevTools endpoint. Never exercised by tests (they inject

package/dist/bridge/browserDriver.js

@@ -137,6 +137,9 @@ function createBrowserDriver(opts = {}) {
     const summaryFrameInterval = opts.summaryFrameInterval ?? 50;
     let cdp = null;
     let childProc = null;
+    // cvt-07: set only in shared-host (tab) mode — see BrowserDriverOpts.host.
+    let hostLease = null;
+    const unsubscribers = [];
     let pageTargetId = null;
     let targetSessionId = null;
     let seq = 0;
@@ -238,6 +241,19 @@ function createBrowserDriver(opts = {}) {
         if (stopped)
             return;
         stopped = true;
+        // cvt-07: a tab never closes the shared connection or kills the shared
+        // process — it closes its own target and hands its lease back (the host
+        // kills Chromium when the last lease goes).
+        if (opts.host) {
+            for (const off of unsubscribers.splice(0))
+                off();
+            const lease = hostLease;
+            if (lease && pageTargetId) {
+                void lease.cdp.send('Target.closeTarget', { targetId: pageTargetId }).catch(() => { });
+            }
+            lease?.release();
+            return;
+        }
         try {
             cdp?.close();
         }
@@ -299,28 +315,55 @@ function createBrowserDriver(opts = {}) {
     }
     async function start(url) {
         emitState({ state: 'opening' });
-        const { proc, wsUrl } = launchChromiumFn({ chromiumPath, userDataDir, width, height });
-        childProc = proc;
-        proc.on('exit', (code, signal) => {
-            handleClosed(`chromium-exit code=${code ?? 'null'} signal=${signal ?? 'null'}`);
-        });
-        proc.on('error', (err) => {
-            handleClosed(`chromium-error ${err instanceof Error ? err.message : String(err)}`);
-        });
-        const browserWsUrl = await wsUrl;
-        const transport = wsFactory(browserWsUrl);
-        const client = (0, cdpClient_1.createCdpClient)(transport);
-        cdp = client;
-        client.onClose((info) => {
-            handleClosed(info?.reason ? `cdp-closed:${info.reason}` : 'cdp-closed');
-        });
-        client.onEvent('Target.targetInfoChanged', (params) => {
+        let client;
+        if (opts.host) {
+            // cvt-07: one tab in the box's shared Chromium.
+            const lease = await opts.host.acquire();
+            if (stopped) {
+                // stop()/sleep() landed while the lease was being acquired.
+                lease.release();
+                return;
+            }
+            hostLease = lease;
+            client = lease.cdp;
+            cdp = client;
+            lease.onClosed((reason) => handleClosed(reason));
+        }
+        else {
+            const { proc, wsUrl } = launchChromiumFn({ chromiumPath, userDataDir, width, height });
+            childProc = proc;
+            proc.on('exit', (code, signal) => {
+                handleClosed(`chromium-exit code=${code ?? 'null'} signal=${signal ?? 'null'}`);
+            });
+            proc.on('error', (err) => {
+                handleClosed(`chromium-error ${err instanceof Error ? err.message : String(err)}`);
+            });
+            const browserWsUrl = await wsUrl;
+            const transport = wsFactory(browserWsUrl);
+            client = (0, cdpClient_1.createCdpClient)(transport);
+            cdp = client;
+            client.onClose((info) => {
+                handleClosed(info?.reason ? `cdp-closed:${info.reason}` : 'cdp-closed');
+            });
+        }
+        unsubscribers.push(client.onEvent('Target.targetInfoChanged', (params) => {
             const info = params.targetInfo;
             if (!info || !pageTargetId || info.targetId !== pageTargetId)
                 return;
             emitState({ state: 'open', url: info.url, title: info.title });
-        });
-        client.onEvent('Page.screencastFrame', (params) => {
+        }));
+        // cvt-07: the tab itself went away (crash, window.close()) — only THIS
+        // tab is terminal; its siblings in the shared browser are untouched.
+        unsubscribers.push(client.onEvent('Target.detachedFromTarget', (params) => {
+            if (targetSessionId && params.sessionId === targetSessionId)
+                handleClosed('target-detached');
+        }));
+        unsubscribers.push(client.onEvent('Page.screencastFrame', (params, cdpSessionId) => {
+            // cvt-07: on a shared connection every tab's screencast arrives here —
+            // only this tab's frames are ours. (A frame without a session id can
+            // only come from a non-flattened, single-tab connection.)
+            if (cdpSessionId && cdpSessionId !== targetSessionId)
+                return;
             // cbs-14: defensive — Page.stopScreencast (sent by pause()) should
             // already suppress these at the source, but a frame already in
             // flight when we asked Chromium to stop is possible; drop it rather
@@ -346,21 +389,35 @@ function createBrowserDriver(opts = {}) {
                 w: metadata.deviceWidth ?? width,
                 h: metadata.deviceHeight ?? height,
             });
-        });
-        const { targetInfos } = await client.send('Target.getTargets');
-        const existingPage = targetInfos.find((t) => t.type === 'page');
-        if (existingPage) {
-            pageTargetId = existingPage.targetId;
+        }));
+        if (hostLease) {
+            // cvt-07: the first tab claims the page Chromium launched with; every
+            // other tab gets a target of its own.
+            const spare = await hostLease.takeSparePage();
+            pageTargetId = spare ?? (await client.send('Target.createTarget', { url: 'about:blank' })).targetId;
         }
         else {
-            const created = await client.send('Target.createTarget', { url: 'about:blank' });
-            pageTargetId = created.targetId;
+            const { targetInfos } = await client.send('Target.getTargets');
+            const existingPage = targetInfos.find((t) => t.type === 'page');
+            if (existingPage) {
+                pageTargetId = existingPage.targetId;
+            }
+            else {
+                const created = await client.send('Target.createTarget', { url: 'about:blank' });
+                pageTargetId = created.targetId;
+            }
         }
         const attached = await client.send('Target.attachToTarget', {
             targetId: pageTargetId,
             flatten: true,
         });
         targetSessionId = attached.sessionId;
+        if (stopped && hostLease) {
+            // cvt-07: closed while the tab was still being created — teardown()
+            // ran before the target existed, so close it here or it leaks.
+            void client.send('Target.closeTarget', { targetId: pageTargetId }).catch(() => { });
+            return;
+        }
         await client.send('Page.enable', {}, targetSessionId);
         // The launcher's --hide-scrollbars only governs the REAL window; the
         // moment we emulate a viewport (setDeviceMetricsOverride, below/resize)

package/dist/bridge/browserHost.d.ts

@@ -0,0 +1,54 @@
+/**
+ * cvt-07 — the box's ONE headless Chromium, shared by every Browser pane.
+ *
+ * (docs/prd/canvas-tools.md module 7, issues/cvt-07-cloud-browser-tabs.md)
+ * Before cvt-07 each browser driver launched its own Chromium, and the arena
+ * only ever opened one session per box (`browser:<containerId>`), so two
+ * cloud Browser panes fought over one page. Now every Browser pane is its own
+ * relay session (`browser:<containerId>:<paneId>`) and its own TAB (CDP page
+ * target) in this one process: same box, same cost, one profile.
+ *
+ * This module owns only the PROCESS + the browser-level CDP connection,
+ * reference-counted by lease:
+ *   - the first acquire() launches Chromium and connects; concurrent
+ *     acquires during the launch share it;
+ *   - each lease may claim the spare `about:blank` page Chromium starts with
+ *     (so the first tab doesn't leave an idle extra renderer behind);
+ *   - the last release() kills Chromium (exactly what a single driver's
+ *     stop()/sleep() did before — no orphaned process, no idle memory);
+ *   - a Chromium exit / CDP close tells EVERY live lease (each tab goes to
+ *     its terminal state), and the next acquire() relaunches.
+ * Targets, screencasts and input stay in browserDriver.ts — one driver per tab.
+ */
+import { ChromiumLaunchHandle } from './chromiumLauncher';
+import { CdpClient, CdpTransportLike } from './cdpClient';
+export interface BrowserHostLease {
+    cdp: CdpClient;
+    /** Claims the page target Chromium opened at launch, once, for the first
+     *  tab that asks. Null when it is already taken (or there is none) — the
+     *  caller then creates its own target. */
+    takeSparePage(): Promise<string | null>;
+    /** Fires once if the shared process/connection dies under this lease. */
+    onClosed(cb: (reason: string) => void): void;
+    /** Gives the lease back. The last release kills Chromium. Idempotent. */
+    release(): void;
+}
+export interface BrowserHost {
+    acquire(): Promise<BrowserHostLease>;
+    /** Live leases (== open tabs). For tests and the summary log. */
+    readonly leaseCount: number;
+}
+export interface BrowserHostOpts {
+    chromiumPath?: string;
+    userDataDir?: string;
+    width?: number;
+    height?: number;
+    launchChromiumFn?: (opts: {
+        chromiumPath?: string;
+        userDataDir?: string;
+        width?: number;
+        height?: number;
+    }) => ChromiumLaunchHandle;
+    wsFactory: (url: string) => CdpTransportLike;
+}
+export declare function createBrowserHost(opts: BrowserHostOpts): BrowserHost;

package/dist/bridge/browserHost.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserHost = createBrowserHost;
+/**
+ * cvt-07 — the box's ONE headless Chromium, shared by every Browser pane.
+ *
+ * (docs/prd/canvas-tools.md module 7, issues/cvt-07-cloud-browser-tabs.md)
+ * Before cvt-07 each browser driver launched its own Chromium, and the arena
+ * only ever opened one session per box (`browser:<containerId>`), so two
+ * cloud Browser panes fought over one page. Now every Browser pane is its own
+ * relay session (`browser:<containerId>:<paneId>`) and its own TAB (CDP page
+ * target) in this one process: same box, same cost, one profile.
+ *
+ * This module owns only the PROCESS + the browser-level CDP connection,
+ * reference-counted by lease:
+ *   - the first acquire() launches Chromium and connects; concurrent
+ *     acquires during the launch share it;
+ *   - each lease may claim the spare `about:blank` page Chromium starts with
+ *     (so the first tab doesn't leave an idle extra renderer behind);
+ *   - the last release() kills Chromium (exactly what a single driver's
+ *     stop()/sleep() did before — no orphaned process, no idle memory);
+ *   - a Chromium exit / CDP close tells EVERY live lease (each tab goes to
+ *     its terminal state), and the next acquire() relaunches.
+ * Targets, screencasts and input stay in browserDriver.ts — one driver per tab.
+ */
+const chromiumLauncher_1 = require("./chromiumLauncher");
+const cdpClient_1 = require("./cdpClient");
+function createBrowserHost(opts) {
+    const launchChromiumFn = opts.launchChromiumFn ?? chromiumLauncher_1.launchChromium;
+    let running = null;
+    let launching = null;
+    const die = (r, reason) => {
+        if (r.dead)
+            return;
+        r.dead = true;
+        if (running === r)
+            running = null;
+        const leases = [...r.leases];
+        r.leases.clear();
+        for (const l of leases) {
+            l.released = true;
+            for (const cb of l.closedCbs)
+                cb(reason);
+        }
+    };
+    const kill = (r) => {
+        if (r.dead)
+            return;
+        r.dead = true;
+        if (running === r)
+            running = null;
+        try {
+            r.cdp.close();
+        }
+        catch { /* best-effort */ }
+        try {
+            r.proc.kill();
+        }
+        catch { /* best-effort */ }
+    };
+    async function launch() {
+        const { proc, wsUrl } = launchChromiumFn({
+            chromiumPath: opts.chromiumPath,
+            userDataDir: opts.userDataDir,
+            width: opts.width,
+            height: opts.height,
+        });
+        // Registered before awaiting wsUrl so an exit during startup is seen.
+        let r = null;
+        let earlyExit = null;
+        proc.on('exit', (code, signal) => {
+            const reason = `chromium-exit code=${code ?? 'null'} signal=${signal ?? 'null'}`;
+            if (r)
+                die(r, reason);
+            else
+                earlyExit = reason;
+        });
+        proc.on('error', (err) => {
+            const reason = `chromium-error ${err instanceof Error ? err.message : String(err)}`;
+            if (r)
+                die(r, reason);
+            else
+                earlyExit = reason;
+        });
+        const url = await wsUrl;
+        if (earlyExit)
+            throw new Error(earlyExit);
+        const cdp = (0, cdpClient_1.createCdpClient)(opts.wsFactory(url));
+        r = { proc, cdp, spareTaken: false, leases: new Set(), dead: false };
+        const self = r;
+        cdp.onClose((info) => die(self, info?.reason ? `cdp-closed:${info.reason}` : 'cdp-closed'));
+        return r;
+    }
+    async function acquire() {
+        let r = running && !running.dead ? running : null;
+        if (!r) {
+            if (!launching) {
+                launching = launch().finally(() => { launching = null; });
+            }
+            r = await launching;
+            if (r.dead)
+                throw new Error('chromium exited during launch');
+            running = r;
+        }
+        const rec = { closedCbs: [], released: false };
+        r.leases.add(rec);
+        const owner = r;
+        return {
+            cdp: owner.cdp,
+            async takeSparePage() {
+                if (owner.spareTaken || owner.dead)
+                    return null;
+                owner.spareTaken = true;
+                const { targetInfos } = await owner.cdp.send('Target.getTargets');
+                return targetInfos.find((t) => t.type === 'page')?.targetId ?? null;
+            },
+            onClosed(cb) {
+                rec.closedCbs.push(cb);
+            },
+            release() {
+                if (rec.released)
+                    return;
+                rec.released = true;
+                owner.leases.delete(rec);
+                if (owner.leases.size === 0)
+                    kill(owner);
+            },
+        };
+    }
+    return {
+        acquire,
+        get leaseCount() {
+            return running && !running.dead ? running.leases.size : 0;
+        },
+    };
+}

package/dist/bridge/claudeSessionHistory.js

@@ -67,7 +67,13 @@ const path = __importStar(require("path"));
 /** Claude Code's project-directory naming rule — see module doc for the
  *  empirical verification. */
 function claudeProjectSlug(cwd) {
-    return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+    // Claude Code names the folder after the cwd WITHOUT a trailing slash. The
+    // local folder registry stores paths with one ("…/MyProject/"), which made
+    // the slug end in "-", missed the agent's transcript, and launched
+    // `--session-id <existing id>` → "Session ID … is already in use" on every
+    // reopen (2026-10-04). Normalise first.
+    const normalized = cwd.length > 1 ? cwd.replace(/\/+$/, '') : cwd;
+    return normalized.replace(/[^a-zA-Z0-9]/g, '-');
 }
 /** Where Claude Code keeps its config + session files: `$CLAUDE_CONFIG_DIR`
  *  when set (the hosted image's persistent-volume path), else `~/.claude`

package/dist/bridge/relayClient.d.ts

@@ -27,6 +27,14 @@ export declare const SESSION_NOT_RELAY_OWNED = "SESSION_NOT_RELAY_OWNED";
  * terminal it did not start — the test names each one for the same reason.
  */
 export declare const SESSION_ADDRESSED_FRAMES: ReadonlySet<string>;
+/** cvt-07: what this bridge advertises in its auth frame. `browser-tabs` = a
+ *  distinct browser sessionId is a distinct TAB in one shared Chromium, and
+ *  `browser-close`/`browser-reload` are understood. The relay keeps old
+ *  images (no caps) on the single default session. */
+export declare const BRIDGE_CAP_BROWSER_TABS = "browser-tabs";
+/** cvt-07: max live browser tabs per box — the arena's Browser-pane cap (4
+ *  per canvas). A fifth open evicts the tab nobody has looked at longest. */
+export declare const DEFAULT_MAX_BROWSER_TABS = 4;
 /** pucc-04 workspace-scoped git credential, resolved + injected by the relay. */
 export interface InjectedGitCredential {
     token: string;
@@ -594,6 +602,11 @@ export interface RelayClientOpts {
      *  idempotent pause() calls — see browserDriver.pause()'s doc comment),
      *  so a short cadence costs nothing. Default 5_000ms. */
     browserConsumerCheckIntervalMs?: number;
+    /** cvt-07: capabilities advertised to the relay in the auth frame (e.g.
+     *  BRIDGE_CAP_BROWSER_TABS). Absent → none (the pre-cvt-07 auth frame). */
+    capabilities?: readonly string[];
+    /** cvt-07: max live browser tabs (default DEFAULT_MAX_BROWSER_TABS). */
+    maxBrowserTabs?: number;
     /** Test/observability hooks. */
     onConnect?: () => void;
     /**

package/dist/bridge/relayClient.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_ADDRESSED_FRAMES = exports.SESSION_NOT_RELAY_OWNED = exports.LAUNCH_COMMAND_MISSING = void 0;
+exports.DEFAULT_MAX_BROWSER_TABS = exports.BRIDGE_CAP_BROWSER_TABS = exports.SESSION_ADDRESSED_FRAMES = exports.SESSION_NOT_RELAY_OWNED = exports.LAUNCH_COMMAND_MISSING = void 0;
 exports.assembleSessionEnv = assembleSessionEnv;
 exports.formatHealthLine = formatHealthLine;
 exports.formatDisconnectLine = formatDisconnectLine;
@@ -136,7 +136,16 @@ exports.SESSION_ADDRESSED_FRAMES = new Set([
     'browser-input', 'browser-frame-ack', 'browser-resize', 'browser-sleep',
     // Terminal attach writes next to a session — same consent boundary.
     'attach-file',
+    'browser-close', 'browser-reload',
 ]);
+/** cvt-07: what this bridge advertises in its auth frame. `browser-tabs` = a
+ *  distinct browser sessionId is a distinct TAB in one shared Chromium, and
+ *  `browser-close`/`browser-reload` are understood. The relay keeps old
+ *  images (no caps) on the single default session. */
+exports.BRIDGE_CAP_BROWSER_TABS = 'browser-tabs';
+/** cvt-07: max live browser tabs per box — the arena's Browser-pane cap (4
+ *  per canvas). A fifth open evicts the tab nobody has looked at longest. */
+exports.DEFAULT_MAX_BROWSER_TABS = 4;
 /**
  * pucc-14 — assemble the per-session PTY env for a workspace-scoped `open`.
  *
@@ -507,6 +516,29 @@ function startRelayClient(opts) {
     function sleepBrowserSession(sessionId, reason) {
         browserDrivers.get(sessionId)?.sleep(reason);
     }
+    /** cvt-07: before opening one more tab at the cap, put the tab with the
+     *  stalest consumer signal to sleep (its pane shows asleep + Wake). */
+    function evictBrowserTabIfFull() {
+        const max = opts.maxBrowserTabs ?? exports.DEFAULT_MAX_BROWSER_TABS;
+        while (browserDrivers.size >= max) {
+            let victim = null;
+            let oldest = Infinity;
+            for (const sid of browserDrivers.keys()) {
+                const at = browserLastConsumerAt.get(sid) ?? -Infinity;
+                if (at < oldest) {
+                    oldest = at;
+                    victim = sid;
+                }
+            }
+            if (!victim)
+                return;
+            sleepBrowserSession(victim, 'tab-evicted');
+            // A driver whose sleep didn't retire it synchronously must not wedge
+            // this loop.
+            if (browserDrivers.has(victim))
+                browserDrivers.delete(victim);
+        }
+    }
     // pucc-14 login_valid report. Container-level (not per session): the ONE
     // shared login on the volume. `lastLoginValid` persists across reconnects so
     // the poll only re-emits on a genuine change; each fresh connect force-emits
@@ -837,7 +869,11 @@ function startRelayClient(opts) {
         };
         socket.on('pong', markLinkAlive);
         socket.on('open', () => {
-            send(socket, { v: PROTOCOL_VERSION, relayToken: opts.relayToken });
+            send(socket, {
+                v: PROTOCOL_VERSION,
+                relayToken: opts.relayToken,
+                ...(opts.capabilities?.length ? { caps: [...opts.capabilities] } : {}),
+            });
             connected = true;
             startHeartbeat();
             // twr-06: `attempt` reset + `onConnect` moved OFF this handler — the
@@ -1595,6 +1631,7 @@ function startRelayClient(opts) {
                             }
                             break;
                         }
+                        evictBrowserTabIfFull(); // cvt-07
                         const driver = opts.createBrowserDriver({ sessionId });
                         browserDrivers.set(sessionId, driver);
                         browserDriverUrls.set(sessionId, url);
@@ -1728,6 +1765,21 @@ function startRelayClient(opts) {
                         // the map by the first sleep's onState handler above).
                         sleepBrowserSession(frame.sessionId, 'sleep');
                         break;
+                    case 'browser-close':
+                        // cvt-07: the pane was closed — close its tab (stop(): terminal
+                        // 'closed', and in shared-host mode only this target goes; the
+                        // host kills Chromium when the last tab closes). Safe no-op for
+                        // an unknown session.
+                        browserDrivers.get(frame.sessionId)?.stop();
+                        break;
+                    case 'browser-reload':
+                        // cvt-07: reload exactly this tab. A live consumer asked, so it
+                        // also counts as one (and un-pauses capture to show the result).
+                        if (browserLastConsumerAt.has(frame.sessionId))
+                            browserLastConsumerAt.set(frame.sessionId, now());
+                        browserDrivers.get(frame.sessionId)?.resume().catch(() => { });
+                        browserDrivers.get(frame.sessionId)?.reload().catch(() => { });
+                        break;
                     case 'companion-allow': {
                         // bws-08 — session-less tenant-boundary control frame (see
                         // companionFrames.ts's doc comment). Validated with the runtime

package/dist/commands/bridge.js

@@ -63,6 +63,7 @@ const sessionManager_1 = require("../bridge/sessionManager");
 const server_1 = require("../bridge/server");
 const relayClient_1 = require("../bridge/relayClient");
 const browserDriver_1 = require("../bridge/browserDriver");
+const browserHost_1 = require("../bridge/browserHost");
 const browserIdle_1 = require("../bridge/browserIdle");
 const loginStatus_1 = require("../bridge/loginStatus");
 const realPty_1 = require("../bridge/realPty");
@@ -571,6 +572,8 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // does not).
             rm: rmCheckoutDir,
         });
+        // cvt-07: the box's one shared Chromium, created lazily by the first tab.
+        let browserHost;
         (0, relayClient_1.startRelayClient)({
             relayUrl: relayMode.relayUrl,
             relayToken: relayMode.relayToken,
@@ -866,10 +869,18 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // either way. An old image without Chromium (or any other launch
             // failure) therefore degrades to "that one browser session failed to
             // open" — never a bridge crash, never a broken terminal pane.
+            //
+            // cvt-07: every browser session is a TAB in ONE shared Chromium
+            // (browserHost.ts) — one process, one profile, launched by the first
+            // tab and killed when the last one closes. Advertised to the relay as
+            // BRIDGE_CAP_BROWSER_TABS below so it may give each Browser pane its
+            // own session.
             createBrowserDriver: () => {
                 const { chromiumPath, userDataDir } = buildBrowserDriverOptions();
-                return (0, browserDriver_1.createBrowserDriver)({ chromiumPath, userDataDir });
+                browserHost ??= (0, browserHost_1.createBrowserHost)({ chromiumPath, userDataDir, wsFactory: (u) => (0, browserDriver_1.createDefaultTransport)(u) });
+                return (0, browserDriver_1.createBrowserDriver)({ chromiumPath, userDataDir, host: browserHost });
             },
+            capabilities: [relayClient_1.BRIDGE_CAP_BROWSER_TABS],
             // bws-08 — the companion port forwarder (docs/prd/
             // browser-with-sound-in-the-container.md D10). Constructed ONCE,
             // same injection posture as createBrowserDriver above: relayClient.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "CLI tool for the Wenrwa Agent Marketplace \u2014 monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",