@web-auto/camo 0.1.23 → 0.1.25

package/src/services/browser-service/internal/BrowserSession.input.test.js

@@ -277,6 +277,39 @@ test('mouseWheel retries with refreshed active page after timeout', async () =>
         restoreTimeout();
     }
 });
+test('mouseWheel prefers interactive viewport metrics for anchor clamping', async () => {
+    const restoreTimeout = setEnv('CAMO_INPUT_ACTION_TIMEOUT_MS', '80');
+    const restoreAttempts = setEnv('CAMO_INPUT_ACTION_MAX_ATTEMPTS', '1');
+    const restoreDelay = setEnv('CAMO_INPUT_RECOVERY_DELAY_MS', '0');
+    const restoreBringToFrontTimeout = setEnv('CAMO_INPUT_RECOVERY_BRING_TO_FRONT_TIMEOUT_MS', '50');
+    const restoreReadySettle = setEnv('CAMO_INPUT_READY_SETTLE_MS', '0');
+    try {
+        const moves = [];
+        const page = {
+            isClosed: () => false,
+            viewportSize: () => ({ width: 1280, height: 720 }),
+            evaluate: async () => ({ innerWidth: 2560, innerHeight: 1440, visualWidth: 2560, visualHeight: 1440 }),
+            bringToFront: async () => { },
+            waitForTimeout: async () => { },
+            mouse: {
+                move: async (x, y) => {
+                    moves.push([x, y]);
+                },
+                wheel: async () => { },
+            },
+        };
+        const session = createSessionWithPage(page);
+        await session.mouseWheel({ deltaY: 360, anchorX: 2564, anchorY: 228 });
+        assert.deepEqual(moves, [[2559, 228]]);
+    }
+    finally {
+        restoreReadySettle();
+        restoreBringToFrontTimeout();
+        restoreDelay();
+        restoreAttempts();
+        restoreTimeout();
+    }
+});
 test('mouseWheel falls back to keyboard paging when wheel keeps timing out', async () => {
     const restoreTimeout = setEnv('CAMO_INPUT_ACTION_TIMEOUT_MS', '80');
     const restoreAttempts = setEnv('CAMO_INPUT_ACTION_MAX_ATTEMPTS', '1');

package/src/services/browser-service/internal/BrowserSession.js

@@ -37,6 +37,7 @@ export class BrowserSession {
     exitNotified = false;
     constructor(options) {
         this.options = options;
+        this.maxTabs = Math.max(5, Math.floor(Number(options.maxTabs ?? 5) || 5));
         const profileId = options.profileId || 'default';
         const root = resolveProfilesRoot();
         this.profileDir = path.join(root, profileId);
@@ -69,6 +70,7 @@ export class BrowserSession {
             recordLastKnownUrl: (url) => { if (url)
                 this.lastKnownUrl = url; },
             isHeadless: () => this.options.headless === true,
+            getMaxTabs: () => this.maxTabs,
         });
         this.navigation = new BrowserSessionNavigation({
             ensurePrimaryPage: () => this.pageManager.ensurePrimaryPage(),
@@ -147,7 +149,10 @@ export class BrowserSession {
         const existing = this.context.pages();
         this.page = existing.length ? existing[0] : await this.context.newPage();
         this.setupPageHooks(this.page);
-        this.context.on('page', (p) => this.setupPageHooks(p));
+        this.context.on('page', (p) => {
+            this.setupPageHooks(p);
+            this.enforceMaxTabs();
+        });
         if (this.viewportManager.isFollowingWindow()) {
             await this.viewportManager.refreshFromWindow(this.page).catch(() => { });
         }
@@ -158,6 +163,33 @@ export class BrowserSession {
     setupPageHooks(page) {
         this.pageHooks.setupPageHooks(page);
     }
+
+    async enforceMaxTabs() {
+        try {
+            const ctx = this.context;
+            if (!ctx) return;
+            const pages = ctx.pages().filter((p) => !p.isClosed());
+            if (pages.length <= this.maxTabs) return;
+            const activePage = this.getActivePage();
+            const excess = pages.length - this.maxTabs;
+            const closable = pages
+                .filter((p) => p !== activePage)
+                .sort((a, b) => {
+                    const aUrl = a.url() || '';
+                    const bUrl = b.url() || '';
+                    const aScore = (aUrl.includes('captcha') || aUrl === 'about:blank') ? 1 : 0;
+                    const bScore = (bUrl.includes('captcha') || bUrl === 'about:blank') ? 1 : 0;
+                    if (aScore !== bScore) return bScore - aScore;
+                    return 0;
+                });
+            const toClose = closable.slice(0, Math.min(excess, closable.length));
+            for (const page of toClose) {
+                try {
+                    await page.close({ runBeforeUnload: false });
+                } catch { /* ignore */ }
+            }
+        } catch { /* ignore enforcement errors */ }
+    }
     addRuntimeEventObserver(observer) {
         return this.runtimeEvents.addObserver(observer);
     }
@@ -301,4 +333,4 @@ export class BrowserSession {
         this.onExit?.(this.options.profileId);
     }
 }
-//# sourceMappingURL=BrowserSession.js.map
+//# sourceMappingURL=BrowserSession.js.map

package/src/services/browser-service/internal/browser-session/input-ops.js

@@ -1,4 +1,30 @@
 import { isTimeoutLikeError } from './utils.js';
+
+async function readInteractiveViewport(page) {
+    const fallback = page.viewportSize?.() || null;
+    try {
+        const metrics = await page.evaluate(() => ({
+            innerWidth: Number(window.innerWidth || 0),
+            innerHeight: Number(window.innerHeight || 0),
+            visualWidth: Number(window.visualViewport?.width || 0),
+            visualHeight: Number(window.visualViewport?.height || 0),
+        }));
+        const width = Math.max(Number(metrics?.innerWidth || 0), Number(metrics?.visualWidth || 0), Number(fallback?.width || 0));
+        const height = Math.max(Number(metrics?.innerHeight || 0), Number(metrics?.visualHeight || 0), Number(fallback?.height || 0));
+        if (Number.isFinite(width) && width > 1 && Number.isFinite(height) && height > 1) {
+            return {
+                width: Math.round(width),
+                height: Math.round(height),
+            };
+        }
+    }
+    catch { }
+    return {
+        width: Math.max(1, Number(fallback?.width || 1280)),
+        height: Math.max(1, Number(fallback?.height || 720)),
+    };
+}
+
 export class BrowserSessionInputOps {
     ensurePrimaryPage;
     ensureInputReady;
@@ -89,7 +115,7 @@ export class BrowserSessionInputOps {
             }
             try {
                 await this.runInputAction(page, 'mouse:wheel', async (activePage) => {
-                    const viewport = activePage.viewportSize();
+                    const viewport = await readInteractiveViewport(activePage);
                     const moveX = Number.isFinite(normalizedAnchorX)
                         ? Math.max(1, Math.min(Math.max(1, Number(viewport?.width || 1280) - 1), Math.round(normalizedAnchorX)))
                         : Math.max(1, Math.floor(((viewport?.width || 1280) * 0.5)));

package/src/services/browser-service/internal/browser-session/page-management.js

@@ -3,9 +3,122 @@ import { ensurePageRuntime } from '../pageRuntime.js';
 import { resolveNavigationWaitUntil, normalizeUrl, shouldSkipBringToFront } from './utils.js';
 export class BrowserSessionPageManagement {
     deps;
+    trackedPages = [];
+    trackedPageListeners = new WeakSet();
+    trackedPageState = new WeakMap();
+    static NEW_PAGE_FORCE_ALIVE_MS = 15_000;
+    static ACTIVE_PAGE_FORCE_ALIVE_MS = 5_000;
     constructor(deps) {
         this.deps = deps;
     }
+    safeIsClosed(page) {
+        if (!page)
+            return true;
+        try {
+            return page.isClosed();
+        }
+        catch {
+            return true;
+        }
+    }
+    markTrackedPage(page, forceAliveMs = 0) {
+        if (!page)
+            return null;
+        const prev = this.trackedPageState.get(page);
+        const next = {
+            closed: false,
+            forceAliveUntil: Math.max(Number(prev?.forceAliveUntil || 0), forceAliveMs > 0 ? Date.now() + forceAliveMs : 0),
+        };
+        this.trackedPageState.set(page, next);
+        return page;
+    }
+    isTrackedPageAlive(page) {
+        if (!page)
+            return false;
+        const state = this.trackedPageState.get(page);
+        if (state?.closed === true)
+            return false;
+        if (!this.safeIsClosed(page))
+            return true;
+        return Number(state?.forceAliveUntil || 0) > Date.now();
+    }
+    rememberPage(page, options = {}) {
+        if (!page)
+            return null;
+        this.markTrackedPage(page, Math.max(0, Number(options.forceAliveMs || 0) || 0));
+        if (this.safeIsClosed(page) && !this.isTrackedPageAlive(page))
+            return null;
+        if (!this.trackedPages.includes(page)) {
+            this.trackedPages.push(page);
+        }
+        if (typeof page.on === 'function' && !this.trackedPageListeners.has(page)) {
+            page.on('close', () => {
+                this.trackedPageState.set(page, {
+                    closed: true,
+                    forceAliveUntil: 0,
+                });
+                this.trackedPages = this.trackedPages.filter((item) => item !== page && !item.isClosed());
+            });
+            this.trackedPageListeners.add(page);
+        }
+        return page;
+    }
+    collectPages(ctx) {
+        const active = this.deps.getActivePage();
+        if (active) {
+            this.rememberPage(active, {
+                forceAliveMs: BrowserSessionPageManagement.ACTIVE_PAGE_FORCE_ALIVE_MS,
+            });
+        }
+        const merged = [...ctx.pages(), ...this.trackedPages, ...(active ? [active] : [])];
+        const seen = new Set();
+        const pages = [];
+        for (const page of merged) {
+            const tracked = this.trackedPages.includes(page) || page === active;
+            const alive = tracked ? this.isTrackedPageAlive(page) : !this.safeIsClosed(page);
+            if (!page || !alive || seen.has(page))
+                continue;
+            seen.add(page);
+            pages.push(page);
+            this.rememberPage(page);
+        }
+        this.trackedPages = this.trackedPages.filter((page) => page && this.isTrackedPageAlive(page));
+        return pages;
+    }
+    async openPageViaContext(ctx, beforeCount) {
+        try {
+            const page = this.rememberPage(await ctx.newPage(), {
+                forceAliveMs: BrowserSessionPageManagement.NEW_PAGE_FORCE_ALIVE_MS,
+            });
+            await page.waitForLoadState('domcontentloaded', { timeout: 1500 }).catch(() => null);
+            const after = this.collectPages(ctx).length;
+            if (after > beforeCount) {
+                return page;
+            }
+        }
+        catch {
+            // Fall through to shortcut-based creation below.
+        }
+        return null;
+    }
+    async openPageViaShortcut(ctx, opener, shortcut, beforeCount) {
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+            const waitPage = ctx.waitForEvent('page', { timeout: 1200 }).catch(() => null);
+            await opener.keyboard.press(shortcut).catch(() => null);
+            const page = this.rememberPage(await waitPage, {
+                forceAliveMs: BrowserSessionPageManagement.NEW_PAGE_FORCE_ALIVE_MS,
+            });
+            const pagesNow = this.collectPages(ctx);
+            const after = pagesNow.length;
+            if (page && after > beforeCount)
+                return page;
+            if (!page && after > beforeCount) {
+                return pagesNow[pagesNow.length - 1] || null;
+            }
+            await new Promise((r) => setTimeout(r, 250));
+        }
+        return null;
+    }
     tryOsNewTabShortcut() {
         if (this.deps.isHeadless())
             return false;
@@ -24,6 +137,7 @@ export class BrowserSessionPageManagement {
         const ctx = this.deps.ensureContext();
         const existing = this.deps.getActivePage();
         if (existing) {
+            this.rememberPage(existing);
             try {
                 await this.deps.ensurePageViewport(existing);
             }
@@ -32,7 +146,9 @@ export class BrowserSessionPageManagement {
             }
             return existing;
         }
-        const page = await ctx.newPage();
+        const page = this.rememberPage(await ctx.newPage(), {
+            forceAliveMs: BrowserSessionPageManagement.NEW_PAGE_FORCE_ALIVE_MS,
+        });
         this.deps.setActivePage(page);
         this.deps.setupPageHooks(page);
         try {
@@ -58,7 +174,7 @@ export class BrowserSessionPageManagement {
     }
     listPages() {
         const ctx = this.deps.ensureContext();
-        const pages = ctx.pages().filter((p) => !p.isClosed());
+        const pages = this.collectPages(ctx);
         const active = this.deps.getActivePage();
         return pages.map((p, index) => ({
             index,
@@ -66,9 +182,16 @@ export class BrowserSessionPageManagement {
             active: active === p,
         }));
     }
-    async newPage(url, options = {}) {
-        const ctx = this.deps.ensureContext();
-        const isMac = process.platform === 'darwin';
+  async newPage(url, options = {}) {
+    const ctx = this.deps.ensureContext();
+    const maxTabs = typeof this.deps.getMaxTabs === 'function' ? this.deps.getMaxTabs() : null;
+    if (Number.isFinite(maxTabs) && maxTabs >= 1) {
+      const pages = this.collectPages(ctx);
+      if (pages.length >= maxTabs) {
+        throw new Error(`max_tabs_exceeded:${maxTabs}`);
+      }
+    }
+    const isMac = process.platform === 'darwin';
         const shortcut = isMac ? 'Meta+t' : 'Control+t';
         let page = null;
         const opener = this.deps.getActivePage() || ctx.pages()[0];
@@ -77,29 +200,23 @@ export class BrowserSessionPageManagement {
         if (!shouldSkipBringToFront()) {
             await opener.bringToFront().catch(() => null);
         }
-        const before = ctx.pages().filter((p) => !p.isClosed()).length;
-        for (let attempt = 1; attempt <= 3; attempt += 1) {
-            const waitPage = ctx.waitForEvent('page', { timeout: 8000 }).catch(() => null);
-            await opener.keyboard.press(shortcut).catch(() => null);
-            page = await waitPage;
-            const pagesNow = ctx.pages().filter((p) => !p.isClosed());
-            const after = pagesNow.length;
-            if (page && after > before)
-                break;
-            if (!page && after > before) {
-                page = pagesNow[pagesNow.length - 1] || null;
-                break;
-            }
-            await new Promise((r) => setTimeout(r, 250));
+        const before = this.collectPages(ctx).length;
+        if (!options?.strictShortcut) {
+            page = await this.openPageViaContext(ctx, before);
         }
-        let after = ctx.pages().filter((p) => !p.isClosed()).length;
+        if (!page) {
+            page = await this.openPageViaShortcut(ctx, opener, shortcut, before);
+        }
+        let after = this.collectPages(ctx).length;
         if (!page || after <= before) {
-            const waitPage = ctx.waitForEvent('page', { timeout: 8000 }).catch(() => null);
+            const waitPage = ctx.waitForEvent('page', { timeout: 1200 }).catch(() => null);
             const osShortcutOk = this.tryOsNewTabShortcut();
             if (osShortcutOk) {
-                page = await waitPage;
+                page = this.rememberPage(await waitPage, {
+                    forceAliveMs: BrowserSessionPageManagement.NEW_PAGE_FORCE_ALIVE_MS,
+                });
             }
-            const pagesNow = ctx.pages().filter((p) => !p.isClosed());
+            const pagesNow = this.collectPages(ctx);
             after = pagesNow.length;
             if (!page && after > before) {
                 page = pagesNow[pagesNow.length - 1] || null;
@@ -107,16 +224,10 @@ export class BrowserSessionPageManagement {
         }
         if (!page || after <= before) {
             if (!options?.strictShortcut) {
-                try {
-                    page = await ctx.newPage();
-                    await page.waitForLoadState('domcontentloaded', { timeout: 8000 }).catch(() => null);
-                }
-                catch {
-                    // ignore fallback errors
-                }
-                after = ctx.pages().filter((p) => !p.isClosed()).length;
+                page = await this.openPageViaContext(ctx, before);
+                after = this.collectPages(ctx).length;
                 if (!page && after > before) {
-                    const pagesNow = ctx.pages().filter((p) => !p.isClosed());
+                    const pagesNow = this.collectPages(ctx);
                     page = pagesNow[pagesNow.length - 1] || null;
                 }
             }
@@ -125,6 +236,9 @@ export class BrowserSessionPageManagement {
             throw new Error('new_tab_failed');
         }
         this.deps.setupPageHooks(page);
+        this.rememberPage(page, {
+            forceAliveMs: BrowserSessionPageManagement.NEW_PAGE_FORCE_ALIVE_MS,
+        });
         this.deps.setActivePage(page);
         try {
             await this.deps.ensurePageViewport(page);
@@ -151,12 +265,12 @@ export class BrowserSessionPageManagement {
             await ensurePageRuntime(page);
             this.deps.recordLastKnownUrl(url);
         }
-        const pages = ctx.pages().filter((p) => !p.isClosed());
+        const pages = this.collectPages(ctx);
         return { index: Math.max(0, pages.indexOf(page)), url: page.url() };
     }
     async switchPage(index) {
         const ctx = this.deps.ensureContext();
-        const pages = ctx.pages().filter((p) => !p.isClosed());
+        const pages = this.collectPages(ctx);
         const idx = Number(index);
         if (!Number.isFinite(idx) || idx < 0 || idx >= pages.length) {
             throw new Error(`invalid_page_index: ${index}`);
@@ -183,7 +297,7 @@ export class BrowserSessionPageManagement {
     }
     async closePage(index) {
         const ctx = this.deps.ensureContext();
-        const pages = ctx.pages().filter((p) => !p.isClosed());
+        const pages = this.collectPages(ctx);
         if (pages.length === 0) {
             return { closedIndex: -1, activeIndex: -1, total: 0 };
         }
@@ -194,8 +308,10 @@ export class BrowserSessionPageManagement {
             throw new Error(`invalid_page_index: ${index}`);
         }
         const page = pages[closedIndex];
+        this.trackedPageState.set(page, { closed: true, forceAliveUntil: 0 });
         await page.close().catch(() => { });
-        const remaining = ctx.pages().filter((p) => !p.isClosed());
+        this.trackedPages = this.trackedPages.filter((item) => item !== page && !item.isClosed());
+        const remaining = this.collectPages(ctx);
         const nextIndex = remaining.length === 0 ? -1 : Math.min(Math.max(0, closedIndex - 1), remaining.length - 1);
         if (nextIndex >= 0) {
             const nextPage = remaining[nextIndex];

package/src/services/browser-service/internal/browser-session/page-management.test.js

@@ -0,0 +1,148 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { BrowserSessionPageManagement } from './page-management.js';
+
+function createPage(label) {
+    const page = {
+        label,
+        closed: false,
+        bringToFrontCalls: 0,
+        gotoCalls: [],
+        waitCalls: [],
+        keyboard: {
+            presses: [],
+            press: async (shortcut) => {
+                page.keyboard.presses.push(shortcut);
+            },
+        },
+        url: () => `https://example.com/${label}`,
+        isClosed() {
+            return this.closed;
+        },
+        async bringToFront() {
+            this.bringToFrontCalls += 1;
+        },
+        async waitForLoadState(_state, opts) {
+            this.waitCalls.push(Number(opts?.timeout || 0));
+        },
+        async goto(url) {
+            this.gotoCalls.push(url);
+        },
+    };
+    return page;
+}
+
+function createManagement({ pages, activePage, ctxNewPage, waitForEvent }) {
+    let currentActive = activePage;
+    const ctx = {
+        pages: () => pages,
+        newPage: ctxNewPage,
+        waitForEvent: waitForEvent || (async () => null),
+    };
+    const management = new BrowserSessionPageManagement({
+        ensureContext: () => ctx,
+        getActivePage: () => currentActive,
+        getCurrentUrl: () => currentActive?.url?.() || null,
+        setActivePage: (page) => {
+            currentActive = page ?? null;
+        },
+        setupPageHooks: () => { },
+        ensurePageViewport: async () => { },
+        maybeCenterPage: async () => { },
+        recordLastKnownUrl: () => { },
+        isHeadless: () => false,
+    });
+    return { management, getActivePage: () => currentActive };
+}
+
+test('newPage prefers direct context creation before shortcut retries', async () => {
+    const opener = createPage('opener');
+    const created = createPage('created');
+    const pages = [opener];
+    let ctxNewPageCalls = 0;
+    const { management, getActivePage } = createManagement({
+        pages,
+        activePage: opener,
+        ctxNewPage: async () => {
+            ctxNewPageCalls += 1;
+            pages.push(created);
+            return created;
+        },
+        waitForEvent: async () => {
+            throw new Error('shortcut path should not run');
+        },
+    });
+    const result = await management.newPage();
+    assert.equal(ctxNewPageCalls, 1);
+    assert.equal(opener.keyboard.presses.length, 0);
+    assert.equal(result.index, 1);
+    assert.equal(result.url, 'https://example.com/created');
+    assert.equal(getActivePage(), created);
+});
+
+test('newPage falls back to shortcut path in strictShortcut mode', async () => {
+    const opener = createPage('opener');
+    const created = createPage('created');
+    const pages = [opener];
+    let ctxNewPageCalls = 0;
+    const { management, getActivePage } = createManagement({
+        pages,
+        activePage: opener,
+        ctxNewPage: async () => {
+            ctxNewPageCalls += 1;
+            return created;
+        },
+        waitForEvent: async () => {
+            pages.push(created);
+            return created;
+        },
+    });
+    const result = await management.newPage(undefined, { strictShortcut: true });
+    assert.equal(ctxNewPageCalls, 0);
+    assert.ok(opener.keyboard.presses.length >= 1);
+    assert.equal(result.index, 1);
+    assert.equal(getActivePage(), created);
+});
+
+test('listPages keeps track of newly created pages even when context.pages stays stale', async () => {
+    const opener = createPage('opener');
+    const created = createPage('created');
+    const pages = [opener];
+    const { management, getActivePage } = createManagement({
+        pages,
+        activePage: opener,
+        ctxNewPage: async () => created,
+        waitForEvent: async () => null,
+    });
+    const result = await management.newPage();
+    assert.equal(result.index, 1);
+    assert.equal(result.url, 'https://example.com/created');
+    assert.equal(getActivePage(), created);
+    const listed = management.listPages();
+    assert.deepEqual(listed, [
+        { index: 0, url: 'https://example.com/opener', active: false },
+        { index: 1, url: 'https://example.com/created', active: true },
+    ]);
+});
+
+test('listPages keeps a just-created page visible briefly even if page reports closed immediately', async () => {
+    const opener = createPage('opener');
+    const created = createPage('created');
+    const pages = [opener];
+    const { management } = createManagement({
+        pages,
+        activePage: opener,
+        ctxNewPage: async () => {
+            created.closed = true;
+            return created;
+        },
+        waitForEvent: async () => null,
+    });
+    const result = await management.newPage();
+    assert.equal(result.index, 1);
+    const listed = management.listPages();
+    assert.deepEqual(listed, [
+        { index: 0, url: 'https://example.com/opener', active: false },
+        { index: 1, url: 'https://example.com/created', active: true },
+    ]);
+});

package/src/services/controller/controller.js

@@ -224,7 +224,7 @@ export class UiController {
     }
     const args = ['create', '--profile', payload.profile];
     if (payload.url) args.push('--url', payload.url);
-    if (payload.headless !== undefined) args.push('--headless', String(payload.headless));
+    if (payload.headless === false) args.push('--no-headless');
     if (payload.keepOpen !== undefined) args.push('--keep-open', String(payload.keepOpen));
     return this.runCliCommand('session-manager', args);
   }

package/src/services/controller/transport.js

@@ -21,11 +21,18 @@ export function createTransport({ env = process.env, defaults = {}, debugLog = n
       ? options.timeoutMs
       : 20000;
     const profileId = (args?.profileId || args?.profile || args?.sessionId || '').toString();
+    const senderMeta = {
+      source: String(options?.source || env.CAMO_COMMAND_SOURCE || 'controller').trim() || 'controller',
+      cwd: String(options?.cwd || env.CAMO_COMMAND_CWD || process.cwd()).trim() || process.cwd(),
+      pid: Number(options?.pid || env.CAMO_COMMAND_PID || process.pid) || process.pid,
+      ppid: Number(options?.ppid || env.CAMO_COMMAND_PPID || process.ppid) || process.ppid,
+      argv: Array.isArray(options?.argv) ? options.argv.map((item) => String(item)) : process.argv.slice(),
+    };
     debugLog?.('browserServiceCommand:start', { action, profileId, timeoutMs });
     const res = await fetch(`${getBrowserHttpBase()}/command`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action, args }),
+      body: JSON.stringify({ action, args, meta: { sender: senderMeta } }),
       signal: AbortSignal.timeout ? AbortSignal.timeout(timeoutMs) : undefined,
     });
 

package/src/utils/args.mjs

@@ -10,6 +10,7 @@ export function ensureUrlScheme(rawUrl) {
   if (typeof rawUrl !== 'string') return rawUrl;
   const trimmed = rawUrl.trim();
   if (!trimmed) return trimmed;
+  if (/^(about|chrome|file|data|blob|javascript):/i.test(trimmed)) return trimmed;
   if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed)) return trimmed;
   return `https://${trimmed}`;
 }

package/src/utils/browser-service.mjs

@@ -8,6 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { BROWSER_SERVICE_URL, loadConfig, setRepoRoot } from './config.mjs';
 import { touchSessionActivity } from '../lifecycle/session-registry.mjs';
 import { buildResolvedSessionView, resolveSessionViewByProfile } from '../lifecycle/session-view.mjs';
+import { buildCommandSenderMeta } from './command-log.mjs';
 
 const require = createRequire(import.meta.url);
 const DEFAULT_API_TIMEOUT_MS = 90000;
@@ -117,12 +118,23 @@ function shouldTrackSessionActivity(action, payload) {
 
 export async function callAPI(action, payload = {}, options = {}) {
   const timeoutMs = resolveApiTimeoutMs(options);
+  const senderMeta = buildCommandSenderMeta({
+    source: String(options?.source || payload?.__commandSource || 'browser-service-client').trim() || 'browser-service-client',
+    cwd: String(options?.cwd || payload?.__commandCwd || process.cwd()).trim() || process.cwd(),
+    pid: Number(options?.pid || payload?.__commandPid || process.pid) || process.pid,
+    ppid: Number(options?.ppid || payload?.__commandPpid || process.ppid) || process.ppid,
+    argv: Array.isArray(options?.argv)
+      ? options.argv
+      : Array.isArray(payload?.__commandArgv)
+        ? payload.__commandArgv
+        : process.argv.slice(),
+  });
   let r;
   try {
     r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action, args: payload }),
+      body: JSON.stringify({ action, args: payload, meta: { sender: senderMeta } }),
       signal: AbortSignal.timeout(timeoutMs),
     });
   } catch (error) {