@parall/daemon 1.45.0 → 1.47.0

package/dist/clip-runtime/browser-target-registry.js

@@ -0,0 +1,297 @@
+import { sleep } from './subprocess.js';
+/**
+ * BrowserTargetRegistry — binds every browser command to a page target OWNED by
+ * the profile's bb-browser account, so no command can fall through to
+ * bb-browser's account-blind global routing.
+ *
+ * WHY. bb-browser-pro 0.15.0 resolves a tab-less command via
+ * `ensurePageTarget(undefined)` → global `currentTargetId` → `targets[0]`
+ * (verified in its daemon source; `request.account` is never consulted). Chrome
+ * is launched with a literal `about:blank` positional tab in the DEFAULT
+ * browser context — no account cookies, no account proxy — and nothing ever
+ * closes it, so it IS `targets[0]` on a fresh Chromium. Worse, the daemon's own
+ * tab-less `tab_list` warm-up is dispatched through `ensurePageTarget` too and
+ * pins the global `currentTargetId` to that blank page. Any agent command sent
+ * without an explicit `tabId` (navigate/get/click/screenshot/eval/...) then
+ * executes against a cookie-less, proxy-less page — including real-IP egress
+ * for proxy-configured profiles. The registry closes this by resolving an
+ * OWNED target (per `tab_list`'s per-tab `account` attribution) and stamping
+ * its full CDP targetId on every tab-addressed command.
+ *
+ * Ownership ground truth is bb-browser's own `tab_list` attribution (targetId →
+ * account, derived from its BrowserContext bookkeeping), so a recreated tab —
+ * `tab_new {account}` routes through `createTabInContext` → `ensureContext` —
+ * always lands in the profile's BrowserContext with its cookies re-injected,
+ * never the default context.
+ */
+/**
+ * Thrown when a command's target cannot be bound to a profile-owned page: a
+ * caller-supplied ref that is not the profile's own tab (foreign tab, numeric
+ * global index, stale id), or an owned page that cannot be (re)created. The
+ * command is NEVER retargeted at another page — fail closed.
+ */
+export class BrowserTargetError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'BrowserTargetError';
+    }
+}
+export class BrowserTargetRegistry {
+    host;
+    opts;
+    // Deliberately STATELESS: ownership is recomputed from bb-browser's live
+    // `tab_list` attribution on every resolve. There is no cached binding to go
+    // stale, nothing to invalidate on restart/reset, and a resolve can never
+    // return a tab that isn't owned RIGHT NOW.
+    constructor(host, opts = {}) {
+        this.host = host;
+        this.opts = opts;
+    }
+    /** `tab_list` rows owned by the account (per-tab `account` attribution). */
+    async ownedTabs(account) {
+        const list = await this.host.sendCommand({ method: 'tab_list', account });
+        const rows = Array.isArray(list.tabs)
+            ? list.tabs
+            : [];
+        const owned = [];
+        for (const row of rows) {
+            if (row?.account !== account)
+                continue;
+            const targetId = typeof row.tabId === 'string' && row.tabId ? row.tabId : undefined;
+            if (!targetId)
+                continue;
+            owned.push({
+                targetId,
+                shortId: row.tab === undefined ? undefined : String(row.tab),
+                url: typeof row.url === 'string' ? row.url : undefined,
+                active: row.active === true,
+            });
+        }
+        return owned;
+    }
+    /**
+     * Resolve the full CDP targetId a command must run against.
+     *
+     * With `ref` (caller-supplied `tabId`/`tab`): it must be one of the account's
+     * OWN tabs (full targetId or short id) — anything else throws
+     * BrowserTargetError. Numeric refs are rejected outright: bb-browser resolves
+     * bare numbers as indices into the GLOBAL page-target array, which can address
+     * another context's page.
+     *
+     * Without `ref`: the owned tab Chrome marks active, else the first owned
+     * tab, else a fresh `about:blank` created INSIDE the account's
+     * BrowserContext (never the default context). Stateless — derived from the
+     * live tab_list every time.
+     */
+    async resolveCommandTarget(account, ref) {
+        if (ref !== undefined && ref !== null && ref !== '') {
+            return this.resolveExplicitRef(account, ref);
+        }
+        const owned = await this.ownedTabs(account);
+        const pick = owned.find((t) => t.active) ?? owned[0];
+        if (pick)
+            return pick.targetId;
+        return this.createOwnedTab(account);
+    }
+    /**
+     * Validate + canonicalize a caller-supplied tab ref against owned tabs only.
+     * The ref is matched as a string against owned full/short ids and NEVER
+     * forwarded raw — so bb-browser's numeric-index fallback (which indexes into
+     * the GLOBAL page array, any context) is unreachable.
+     */
+    async resolveExplicitRef(account, ref) {
+        const wanted = String(ref);
+        const owned = await this.ownedTabs(account);
+        const match = owned.find((t) => t.targetId === wanted || t.shortId === wanted);
+        if (!match) {
+            const indexHint = /^\d+$/.test(wanted)
+                ? ' (numeric tab indices are not supported — pass the tab id returned by tab_list/tab_new)'
+                : '';
+            throw new BrowserTargetError(`tab ${wanted} does not belong to browser profile ${account} — commands are bound to the profile's own pages${indexHint}`, 'BROWSER_TARGET_FOREIGN');
+        }
+        return match.targetId;
+    }
+    /**
+     * Ensure the account owns at least one page tab, returning its targetId. A
+     * fresh account (or one whose pages were all closed) gets an `about:blank`
+     * tab created in ITS BrowserContext via `tab_new {account}` — bb-browser's
+     * `createTabInContext` re-activates the context (cookies re-injected) when it
+     * was disposed, so recovery never lands in the default context.
+     */
+    async ensureOwnedTab(account) {
+        const owned = await this.ownedTabs(account);
+        const existing = owned.find((t) => t.active) ?? owned[0];
+        if (existing)
+            return existing.targetId;
+        return this.createOwnedTab(account);
+    }
+    async createOwnedTab(account) {
+        const created = await this.host.sendCommand({
+            method: 'tab_new',
+            account,
+            url: 'about:blank',
+        });
+        const targetId = typeof created.tabId === 'string' && created.tabId ? created.tabId : undefined;
+        if (targetId)
+            return targetId;
+        // tab_new responded without a usable tabId — re-derive from ownership rather
+        // than guess (never fall back to an unowned page).
+        const owned = await this.ownedTabs(account);
+        const pick = owned.find((t) => t.active) ?? owned[0];
+        if (!pick) {
+            throw new BrowserTargetError(`could not create a page for browser profile ${account} in its own context`, 'BROWSER_TARGET_UNAVAILABLE');
+        }
+        return pick.targetId;
+    }
+    /** Owned tab currently on `host` (www-tolerant), optionally only a specific ref. */
+    async findOwnedTabOnHost(account, host, onlyTargetId) {
+        const owned = await this.ownedTabs(account);
+        for (const tab of owned) {
+            if (onlyTargetId !== undefined && tab.targetId !== onlyTargetId)
+                continue;
+            if (!tab.url)
+                continue;
+            try {
+                if (hostsMatch(new URL(tab.url).host, host))
+                    return tab.targetId;
+            }
+            catch {
+                /* non-URL tab (about:blank etc.) — skip */
+            }
+        }
+        return undefined;
+    }
+    /** Whether any owned tab is already on `url` (same resource, http→https tolerant). */
+    async findOwnedTabMatchingUrl(account, url) {
+        const expected = comparableUrl(url);
+        if (!expected)
+            return undefined;
+        const owned = await this.ownedTabs(account);
+        for (const tab of owned) {
+            if (!tab.url)
+                continue;
+            const actual = comparableUrl(tab.url);
+            if (!actual)
+                continue;
+            const sameResource = hostsMatch(actual.host, expected.host) && actual.target === expected.target;
+            const sameProtocol = actual.protocol === expected.protocol;
+            const redirectedUpgrade = expected.protocol === 'http:' && actual.protocol === 'https:';
+            if (sameResource && (sameProtocol || redirectedUpgrade))
+                return tab.targetId;
+        }
+        return undefined;
+    }
+    /**
+     * Account-scoped tab-by-domain resolution for `eval {domain}` (bb-browser's
+     * own `resolveTabByDomain` is account-blind — the reason this exists). Two
+     * properties the bare `tab_new` + eval approach lacked, both caught on the
+     * staging closed-loop E2E (2026-06-04):
+     *
+     * 1. Reuse: an existing account tab already on the domain is reused instead
+     *    of opening a new tab per eval (upstream reuses matching tabs too).
+     * 2. Load wait: after creating a tab, wait for the navigation to commit
+     *    before eval — upstream waits (~10s poll + settle); without it the clip
+     *    script races `about:blank` and relative fetches fail
+     *    ("Failed to parse URL from /hot.json").
+     */
+    async resolveDomainTab(account, domain) {
+        const url = normalizeDomainUrl(domain);
+        let host = '';
+        try {
+            host = new URL(url).host;
+        }
+        catch {
+            /* fall through — tab_new with whatever bb-browser makes of it */
+        }
+        if (host) {
+            const existing = await this.findOwnedTabOnHost(account, host);
+            if (existing !== undefined)
+                return existing;
+        }
+        const tab = await this.host.sendCommand({ method: 'tab_new', url, account });
+        const targetId = typeof tab.tabId === 'string' && tab.tabId ? tab.tabId : undefined;
+        if (targetId === undefined || !host)
+            return targetId;
+        // Wait for the created tab to actually reach the domain (navigation
+        // committed). Mirrors upstream resolveTabByDomain's bounded wait + settle.
+        let committed = false;
+        const deadline = Date.now() + (this.opts.commitTimeoutMs ?? 10_000);
+        while (Date.now() < deadline) {
+            if ((await this.findOwnedTabOnHost(account, host, targetId)) !== undefined) {
+                committed = true;
+                break;
+            }
+            await sleep(this.opts.commitPollMs ?? 300);
+        }
+        if (!committed) {
+            // The tab never confirmed it reached the domain within the deadline — its
+            // document is still about:blank / a partial load. Returning it would let a
+            // subsequent eval run on the WRONG page. CLOSE it so it can't linger as an
+            // owned tab a later ref-less resolve would pick, then fail closed.
+            await this.closeTabBestEffort(account, targetId);
+            throw new BrowserTargetError(`domain ${domain} page did not commit navigation in browser profile ${account}`, 'BROWSER_TARGET_UNAVAILABLE');
+        }
+        await sleep(this.opts.commitSettleMs ?? 750); // post-commit settle (upstream uses a flat 2s)
+        return targetId;
+    }
+    /** Close a tab we created but could not commit, so it does not linger as a
+     *  residual owned tab. Best-effort — a close failure (already gone / rejected)
+     *  is swallowed. bb-browser's close command is `close` (→ Target.closeTarget). */
+    async closeTabBestEffort(account, targetId) {
+        try {
+            await this.host.sendCommand({ method: 'close', tabId: targetId, account });
+        }
+        catch {
+            /* the tab may already be gone / bb-browser rejected the close — ignore */
+        }
+    }
+}
+/**
+ * Commands that take no page target at all — everything else is tab-addressed
+ * and MUST carry an owned tabId. `tab_new`, `site_info`, and the `site_*` listing
+ * commands resolve/create their page inside the account's context upstream
+ * (createTabInContext / account-scoped adapter execution), so they pass `account`
+ * instead of a pinned tab. NOTE `tab_list` IS dispatched through bb-browser's
+ * `ensurePageTarget` (its global-current-tab side effect is harmless once every
+ * real command pins its own target). `site_run` is deliberately NOT tab-less:
+ * the manager resolves the adapter's domain via site_info and pins an owned tab
+ * (or fails closed for a domain-less adapter), closing the old global-current-tab
+ * fallthrough — see BrowserProfileManager.buildCommandRequest.
+ */
+export const TABLESS_COMMANDS = new Set([
+    'account_list',
+    'account_create',
+    'account_delete',
+    'account_info',
+    'tab_list',
+    'tab_new',
+    'site_list',
+    'site_search',
+    'site_info',
+]);
+/** Host comparison tolerant of a `www.` prefix on either side. */
+export function hostsMatch(a, b) {
+    const norm = (h) => h.toLowerCase().replace(/^www\./, '');
+    return norm(a) === norm(b);
+}
+export function normalizeDomainUrl(domain) {
+    const trimmed = domain.trim();
+    if (!trimmed)
+        return 'about:blank';
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+export function comparableUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return {
+            protocol: parsed.protocol,
+            host: parsed.host,
+            target: `${parsed.pathname}${parsed.search}${parsed.hash}`,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/clip-runtime/browser-viewer-streamer.d.ts

@@ -1,3 +1,4 @@
+import type { BrowserTargetRegistry } from './browser-target-registry.js';
 /** Optional managed TURN relay config carried on a `stream.start` command. */
 export interface ViewerTurnConfig {
     url: string;
@@ -21,13 +22,19 @@ export interface ViewerStreamerHost {
         method: string;
         account?: string;
     }): Promise<Record<string, unknown>>;
-    ensureAccount(account: string): Promise<boolean>;
+    /** First-use preparation (desired-proxy reconcile + readiness), shared with the
+     *  agent-invoke path — the viewer's first stream/nav on a hydrated account must
+     *  reconcile the proxy + verify readiness too, not just confirm the account
+     *  exists. Idempotent: the steady path after first use is cheap. */
+    prepareForUse(account: string): Promise<void>;
     withDaemonRecovery<T>(operation: () => Promise<T>, label: string): Promise<T>;
     /** cdpHost/cdpPort from the bb-browser daemon `GET /status`. */
     cdpEndpoint(): Promise<{
         host: string;
         port: number;
     }>;
+    /** Shared owned-target resolution (same registry the agent-invoke path pins with). */
+    targets: BrowserTargetRegistry;
 }
 /**
  * bb-viewer's /command control plane is UNAUTHENTICATED, so on the shared agents
@@ -165,25 +172,17 @@ export declare class BrowserViewerStreamer {
     private resolveAccountPageCdpUrl;
     /**
      * Full CDP targetId of the profile account's active page tab (the owned tab
-     * Chrome marks active, else the first owned tab). If the account owns no
-     * page tab yet, open `about:blank` for it first (mirrors the agent-invoke
-     * path's "always give a fresh account an owned tab" rule).
+     * Chrome marks active, else the first owned tab; a tab-less account gets an
+     * `about:blank` created inside its own context first). Shared with the
+     * agent-invoke path via BrowserTargetRegistry — one ownership implementation.
      */
     private accountActivePageTargetId;
-    /**
-     * Full CDP targetId (`tabId`) of the account's active page tab: the owned tab
-     * Chrome marks `active` when it belongs to this account, else the first owned
-     * tab (the global active flag is account-blind — another profile's tab may
-     * hold it, which must not leak here).
-     */
-    private firstAccountPageTargetId;
     /**
      * Full CDP targetId for a specific account tab, addressed by the bb-browser
-     * short tab id (`tab`) or full target id (`tabId`). Used by stream.switch.
+     * short tab id (`tab`) or full target id (`tabId`). Throws on tabs the
+     * profile does not own (BrowserTargetError). Used by stream.switch.
      */
     private accountTabTargetId;
-    /** `tab_list {account}` rows, typed to the fields we read (tabId/tab/account/active). */
-    private accountTabs;
     /**
      * Spawn a bb-viewer streamer for the profile and wait until healthy. Binary
      * is PRLL_BB_VIEWER_BIN (our image sets it to /usr/local/bin/bb-viewer),

package/dist/clip-runtime/browser-viewer-streamer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-viewer-streamer.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/browser-viewer-streamer.ts"],"names":[],"mappings":"AAsCA,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAcD;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE;QAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpF,gFAAgF;IAChF,kBAAkB,CAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GACtE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACpC,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD,kBAAkB,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC9E,gEAAgE;IAChE,WAAW,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACxD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,gBAAgB,EAAE,MAAM,GAAG,SAAS,GACnC,OAAO,CAGT;AAED,qBAAa,qBAAqB;IAiBpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAbjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoC;IAO9D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAI5D,OAAO,CAAC,QAAQ,CAAS;gBAEI,IAAI,EAAE,kBAAkB;IAErD;;;;;OAKG;IACG,mBAAmB,CACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,CAAC,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAuCnC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,UAAU;IAwBlB;;;;OAIG;YACW,iBAAiB;IA+C/B;;;;OAIG;YACW,kBAAkB;IAgBhC;;;;;;;;;;OAUG;YACW,iBAAiB;IAuB/B;;;;;;;;OAQG;YACW,kBAAkB;IAuBhC;;;;;;OAMG;YACW,cAAc;IAiC5B;;;;;;;OAOG;YACW,kBAAkB;IAqBhC;;;;;;;;;;;;;;;;;;;;OAoBG;YACW,gBAAgB;IA6C9B;;;;;;;;;;;;;;;;;;OAkBG;YACW,wBAAwB;IAetC;;;;;OAKG;YACW,yBAAyB;IAevC;;;;;OAKG;YACW,wBAAwB;IAatC;;;OAGG;YACW,kBAAkB;IAehC,yFAAyF;YAC3E,WAAW;IAgBzB;;;;;OAKG;YACW,aAAa;IAiH3B;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAqBjB;;;;OAIG;YACW,eAAe;IA+B7B;;;;;OAKG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQ5C;;;OAGG;IACH,QAAQ,IAAI,IAAI;CAMjB"}
+{"version":3,"file":"browser-viewer-streamer.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/browser-viewer-streamer.ts"],"names":[],"mappings":"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"}

package/dist/clip-runtime/browser-viewer-streamer.js

@@ -332,7 +332,7 @@ export class BrowserViewerStreamer {
             }
         }
         return this.host.withDaemonRecovery(async () => {
-            await this.host.ensureAccount(profileId);
+            await this.host.prepareForUse(profileId);
             const request = { ...(input ?? {}) };
             if (command === 'open' || command === 'tab_new') {
                 assertViewerNavigableUrl(request.url);
@@ -375,7 +375,7 @@ export class BrowserViewerStreamer {
      *    is the per-tab attribution we filter on (reused by findAccountTabOnHost).
      */
     async resolveAccountPageCdpUrl(profileId, tabRef) {
-        await this.host.ensureAccount(profileId);
+        await this.host.prepareForUse(profileId);
         const { host, port } = await this.host.cdpEndpoint();
         const targetId = tabRef !== undefined
             ? await this.accountTabTargetId(profileId, tabRef)
@@ -384,72 +384,20 @@ export class BrowserViewerStreamer {
     }
     /**
      * Full CDP targetId of the profile account's active page tab (the owned tab
-     * Chrome marks active, else the first owned tab). If the account owns no
-     * page tab yet, open `about:blank` for it first (mirrors the agent-invoke
-     * path's "always give a fresh account an owned tab" rule).
+     * Chrome marks active, else the first owned tab; a tab-less account gets an
+     * `about:blank` created inside its own context first). Shared with the
+     * agent-invoke path via BrowserTargetRegistry — one ownership implementation.
      */
-    async accountActivePageTargetId(profileId) {
-        let targetId = await this.firstAccountPageTargetId(profileId);
-        if (targetId !== undefined)
-            return targetId;
-        await this.host.sendBrowserCommand({
-            method: 'tab_new',
-            account: profileId,
-            url: 'about:blank',
-        });
-        targetId = await this.firstAccountPageTargetId(profileId);
-        if (targetId === undefined) {
-            throw new Error(`no page tab found for profile account ${profileId}`);
-        }
-        return targetId;
-    }
-    /**
-     * Full CDP targetId (`tabId`) of the account's active page tab: the owned tab
-     * Chrome marks `active` when it belongs to this account, else the first owned
-     * tab (the global active flag is account-blind — another profile's tab may
-     * hold it, which must not leak here).
-     */
-    async firstAccountPageTargetId(profileId) {
-        const tabs = await this.accountTabs(profileId);
-        let firstOwned;
-        for (const t of tabs) {
-            if (t.account !== profileId)
-                continue;
-            const tabId = t.tabId;
-            if (typeof tabId !== 'string' || !tabId)
-                continue;
-            if (t.active === true)
-                return tabId;
-            firstOwned ??= tabId;
-        }
-        return firstOwned;
+    accountActivePageTargetId(profileId) {
+        return this.host.targets.resolveCommandTarget(profileId);
     }
     /**
      * Full CDP targetId for a specific account tab, addressed by the bb-browser
-     * short tab id (`tab`) or full target id (`tabId`). Used by stream.switch.
+     * short tab id (`tab`) or full target id (`tabId`). Throws on tabs the
+     * profile does not own (BrowserTargetError). Used by stream.switch.
      */
-    async accountTabTargetId(profileId, tabRef) {
-        const ref = String(tabRef);
-        const tabs = await this.accountTabs(profileId);
-        for (const t of tabs) {
-            if (t.account !== profileId)
-                continue;
-            const tabId = typeof t.tabId === 'string' ? t.tabId : undefined;
-            const shortTab = t.tab === undefined ? undefined : String(t.tab);
-            if ((tabId && tabId === ref) || (shortTab && shortTab === ref)) {
-                if (!tabId)
-                    break;
-                return tabId;
-            }
-        }
-        throw new Error(`tab ${ref} not found for profile account ${profileId}`);
-    }
-    /** `tab_list {account}` rows, typed to the fields we read (tabId/tab/account/active). */
-    async accountTabs(profileId) {
-        const list = await this.host.sendBrowserCommand({ method: 'tab_list', account: profileId });
-        return Array.isArray(list.tabs)
-            ? list.tabs
-            : [];
+    accountTabTargetId(profileId, tabRef) {
+        return this.host.targets.resolveCommandTarget(profileId, tabRef);
     }
     // ---- bb-viewer streamer lifecycle ----
     /**

package/dist/daemon-main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon-main.d.ts","sourceRoot":"","sources":["../src/daemon-main.ts"],"names":[],"mappings":";AAyBA,MAAM,MAAM,oBAAoB,GAAG;IACjC,sBAAsB,EAAE,OAAO,CAAC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA4KF,wBAAsB,cAAc,CAClC,SAAS,EAAE,oBAAoB,EAC/B,IAAI,WAAwB,GAC3B,OAAO,CAAC,IAAI,CAAC,CASf"}
+{"version":3,"file":"daemon-main.d.ts","sourceRoot":"","sources":["../src/daemon-main.ts"],"names":[],"mappings":";AA0BA,MAAM,MAAM,oBAAoB,GAAG;IACjC,sBAAsB,EAAE,OAAO,CAAC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA8KF,wBAAsB,cAAc,CAClC,SAAS,EAAE,oBAAoB,EAC/B,IAAI,WAAwB,GAC3B,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/daemon-main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createLogger, createOtelLogger, initAgentTelemetry, } from '@parall/agent-core';
+import { configureHttpKeepAlive, createLogger, createOtelLogger, initAgentTelemetry, } from '@parall/agent-core';
 import { ParallClient } from '@parall/sdk';
 import { runCLI } from './cli.js';
 import { resolveBundleDir, resolveClaudeDaemonConfig, resolveWsUrl, } from './config.js';
@@ -75,6 +75,8 @@ async function runForever(config, client, log, signal, updater, gate) {
     }
 }
 async function main(bootstrap) {
+    // Before any fetch: long-lived HTTP connections for control-plane calls.
+    configureHttpKeepAlive();
     const config = resolveClaudeDaemonConfig(process.env);
     const telemetry = await initAgentTelemetry('parall-daemon', 'daemon');
     log = createOtelLogger('daemon', 'daemon');

package/dist/local-control.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Local (same-machine) control plane for the BYOC daemon — the ONLY human
+ * control surface for local browser profiles per
+ * docs/engineering-design/daemon-control-authorization-design.md §7.1.
+ *
+ * Transport: a per-user Unix domain socket under the daemon config dir
+ * (`<daemonConfigDir>/run/control.sock`), directory mode 0700 + socket mode
+ * 0600, so only the same OS user (the person who installed the daemon) can
+ * connect. The Parall Desktop shell — Electron main, never the renderer — is
+ * the intended client. The trust boundary is deliberately the OS user account:
+ * anything running as that user already owns `config.json` (the mck_), so the
+ * socket adds no new exposure; the platform-identity check (requester ==
+ * machines.created_by) is enforced by the supervisor's handler on top.
+ *
+ * Protocol: newline-delimited JSON, one request per line, one response per
+ * line, over a short-lived connection:
+ *   → {"id":"1","command":"profile.open","profile_id":"brp_x","requester_user_id":"usr_y"}
+ *   ← {"id":"1","ok":true,"result":{...}}
+ *   ← {"id":"1","ok":false,"error":{"code":"OWNER_MISMATCH","message":"..."}}
+ * Unknown fields are ignored (forward compat); unknown commands are rejected.
+ * Windows support (named pipe) is deliberately deferred — the Desktop daemon
+ * module is darwin-only today (design §7.1).
+ */
+export type LocalProfileAction = 'open' | 'stop' | 'reset';
+/** Typed failure a handler may throw; anything else maps to INTERNAL. */
+export declare class LocalControlError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface LocalControlHandlers {
+    /** Liveness + capability probe; the result rides back verbatim. */
+    ping(): Promise<Record<string, unknown>>;
+    /** Drive one local browser profile. Resolves when the action completed. */
+    profileControl(action: LocalProfileAction, profileId: string, requesterUserId: string): Promise<void>;
+}
+/** Socket path SSOT — the Desktop shell derives the same path from the shared
+ *  config dir (PRLL_DAEMON_CONFIG_DIR namespacing keeps staging/prod apart). */
+export declare function localControlSocketPath(env?: NodeJS.ProcessEnv): string;
+export interface LocalControlServerOptions {
+    socketPath: string;
+    handlers: LocalControlHandlers;
+    log: {
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string): void;
+    };
+}
+export declare class LocalControlServer {
+    private readonly opts;
+    private server;
+    private readonly sockets;
+    constructor(opts: LocalControlServerOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleConnection;
+    private handleLine;
+    private reply;
+}
+//# sourceMappingURL=local-control.d.ts.map

package/dist/local-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-control.d.ts","sourceRoot":"","sources":["../src/local-control.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE3D,yEAAyE;AACzE,qBAAa,iBAAkB,SAAQ,KAAK;IAExC,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM;CAKlB;AAED,MAAM,WAAW,oBAAoB;IACnC,mEAAmE;IACnE,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,2EAA2E;IAC3E,cAAc,CACZ,MAAM,EAAE,kBAAkB,EAC1B,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CAAC;CAClB;AAWD;gFACgF;AAChF,wBAAgB,sBAAsB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAEnF;AA6BD,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,GAAG,EAAE;QAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CACrF;AAED,qBAAa,kBAAkB;IAIjB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHjC,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;gBAEpB,IAAI,EAAE,yBAAyB;IAEtD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkEtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAc3B,OAAO,CAAC,gBAAgB;YA0BV,UAAU;IAuDxB,OAAO,CAAC,KAAK;CAiBd"}