@parall/daemon 1.32.0 → 1.33.0

package/dist/clip-runtime/browser-profile-manager.js

@@ -0,0 +1,595 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import * as net from 'node:net';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const BB_BROWSER_DAEMON_START_TIMEOUT_MS = 15_000;
+class BrowserCommandError extends Error {
+    method;
+    account;
+    constructor(message, method, account) {
+        super(message);
+        this.method = method;
+        this.account = account;
+        this.name = 'BrowserCommandError';
+    }
+}
+export class BrowserProfileManager {
+    opts;
+    daemon = null;
+    starting = null;
+    restarting = null;
+    ensuredAccounts = new Set();
+    ensuringAccounts = new Map();
+    reportedStatuses = new Map();
+    constructor(opts) {
+        this.opts = opts;
+        mkdirSync(this.opts.homeDir, { recursive: true });
+    }
+    async invoke({ profileId, account, command, input }) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        if (!account)
+            throw new Error('browser account is required');
+        try {
+            await this.withDaemonRecovery(() => this.prepareInvokeAccount(account), `prepare invoke ${command} for ${profileId}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+        let request;
+        try {
+            request = await this.buildCommandRequest(account, command, input);
+        }
+        catch (err) {
+            if (isRecoverableBrowserDaemonError(err)) {
+                await this.recoverInvokeAvailability(`build invoke ${command} for ${profileId}`, profileId, err);
+            }
+            throw err;
+        }
+        try {
+            // Do not replay arbitrary forwarded browser commands: click/type/eval can
+            // have user-visible side effects if Chrome consumed the first attempt.
+            const result = await this.sendCommand(request);
+            this.reportStatus(profileId, 'running');
+            return result;
+        }
+        catch (err) {
+            if (isRecoverableBrowserDaemonError(err)) {
+                await this.recoverInvokeAvailability(`invoke ${command} for ${profileId}`, profileId, err);
+            }
+            throw err;
+        }
+    }
+    async ensureRuntime(profileId) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        try {
+            await this.withDaemonRecovery(() => this.ensureAccount(profileId), `ensure runtime for ${profileId}`);
+            this.reportStatus(profileId, 'running');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+    }
+    async openProfile(profileId, startUrl) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        // Explicit lifecycle actions must always report their outcome: the server
+        // resets the profile to `pending` on the API call, so a deduped repeat of
+        // our previous report (same status+message marker) would leave the profile
+        // stuck in pending forever. Clearing the marker keeps the dedup for the
+        // chatty invoke path while making lifecycle outcomes authoritative.
+        this.reportedStatuses.delete(profileId);
+        const url = normalizeStartUrl(startUrl);
+        let prepareResult = {
+            accountCreated: false,
+            accountExistedBeforePrepare: true,
+        };
+        let firstAccountExistedBeforePrepare;
+        let recoveredDuringPrepare = false;
+        try {
+            prepareResult = await this.withDaemonRecovery(() => this.prepareOpenProfile(profileId, url, (exists) => {
+                firstAccountExistedBeforePrepare ??= exists;
+            }), `prepare open profile ${profileId}`, () => {
+                recoveredDuringPrepare = true;
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+        try {
+            await this.openProfileTabOnce(profileId, url, prepareResult.accountCreated, recoveredDuringPrepare, firstAccountExistedBeforePrepare ?? prepareResult.accountExistedBeforePrepare);
+            this.reportStatus(profileId, 'running');
+        }
+        catch (err) {
+            if (isRecoverableBrowserDaemonError(err)) {
+                await this.restartDaemon(`open profile ${profileId}`, err);
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+    }
+    async stopProfile(profileId) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        this.reportedStatuses.delete(profileId); // see openProfile — lifecycle outcomes always report
+        // bb-browser-pro does not expose a single-account "dispose context" command.
+        // Server-side stopped status is the authority that gates future invokes.
+        this.reportStatus(profileId, 'stopped');
+    }
+    async resetProfile(profileId) {
+        if (!profileId)
+            throw new Error('browser profile id is required');
+        this.reportedStatuses.delete(profileId); // see openProfile — lifecycle outcomes always report
+        try {
+            await this.withDaemonRecovery(() => this.resetProfileOnce(profileId), `reset profile ${profileId}`);
+            this.reportStatus(profileId, 'stopped');
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.reportStatus(profileId, 'error', message);
+            throw err;
+        }
+    }
+    async stop() {
+        const daemon = this.daemon;
+        this.daemon = null;
+        this.starting = null;
+        this.ensuredAccounts.clear();
+        this.ensuringAccounts.clear();
+        this.reportedStatuses.clear();
+        if (!daemon)
+            return;
+        try {
+            await this.post('/shutdown', daemon, undefined, 3_000);
+        }
+        catch {
+            /* best-effort */
+        }
+        if (daemon.child.exitCode === null && daemon.child.signalCode === null) {
+            daemon.child.kill('SIGTERM');
+        }
+    }
+    async prepareOpenProfile(profileId, url, recordAccountExists) {
+        const accountExistedBeforePrepare = await this.accountExists(profileId);
+        recordAccountExists?.(accountExistedBeforePrepare);
+        const accountCreated = await this.ensureAccount(profileId, url !== 'about:blank' ? url : undefined);
+        await this.sendCommand({ method: 'tab_list', account: profileId });
+        return { accountCreated, accountExistedBeforePrepare };
+    }
+    async openProfileTabOnce(profileId, url, accountCreated, recoveredDuringPrepare, accountExistedBeforePrepare) {
+        if (accountCreated)
+            return;
+        if (recoveredDuringPrepare && !accountExistedBeforePrepare) {
+            if (url === 'about:blank')
+                return;
+            const host = safeUrlHost(url);
+            if (host && (await this.findAccountTabOnHost(profileId, host)) !== undefined)
+                return;
+        }
+        await this.sendCommand({ method: 'tab_new', account: profileId, url });
+    }
+    async resetProfileOnce(profileId) {
+        if (await this.accountExists(profileId)) {
+            await this.sendCommand({ method: 'account_delete', account: profileId });
+        }
+        this.ensuredAccounts.delete(profileId);
+    }
+    async prepareInvokeAccount(account) {
+        await this.ensureAccount(account);
+        await this.sendCommand({ method: 'tab_list', account });
+    }
+    async recoverInvokeAvailability(label, profileId, err) {
+        try {
+            await this.restartDaemon(label, err);
+            this.reportStatus(profileId, 'running');
+        }
+        catch (restartErr) {
+            const message = restartErr instanceof Error ? restartErr.message : String(restartErr);
+            this.reportStatus(profileId, 'error', message);
+            throw restartErr;
+        }
+    }
+    async accountExists(account) {
+        try {
+            await this.sendCommand({ method: 'account_info', account });
+            return true;
+        }
+        catch (err) {
+            if (isBrowserAccountInfoUnauthenticatedError(err))
+                return true;
+            if (isBrowserAccountNotFoundError(err))
+                return false;
+            throw err;
+        }
+    }
+    async buildCommandRequest(account, command, input) {
+        const body = input && typeof input === 'object' && !Array.isArray(input)
+            ? { ...input }
+            : { value: input };
+        const request = body;
+        request.method = command;
+        request.account = account;
+        if (command === 'eval' && typeof request.domain === 'string' && request.tabId === undefined) {
+            const tabRef = await this.resolveAccountDomainTab(account, request.domain);
+            if (tabRef !== undefined)
+                request.tabId = tabRef;
+        }
+        return request;
+    }
+    /**
+     * Account-scoped version of bb-browser's `resolveTabByDomain` (which is
+     * account-blind — the reason for this daemon-side preselection workaround).
+     * 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 resolveAccountDomainTab(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.findAccountTabOnHost(account, host);
+            if (existing !== undefined)
+                return existing;
+        }
+        const tab = await this.sendCommand({ method: 'tab_new', url, account });
+        const tabRef = (tab?.tab ?? tab?.tabId);
+        if (tabRef === undefined || !host)
+            return tabRef;
+        // Wait for the created tab to actually reach the domain (navigation
+        // committed). Mirrors upstream resolveTabByDomain's bounded wait + settle.
+        const deadline = Date.now() + 10_000;
+        while (Date.now() < deadline) {
+            const found = await this.findAccountTabOnHost(account, host, tabRef);
+            if (found !== undefined)
+                break;
+            await sleep(300);
+        }
+        await sleep(750); // post-commit settle (upstream uses a flat 2s)
+        return tabRef;
+    }
+    /** Find an account-owned tab whose URL host matches (optionally a specific tab). */
+    async findAccountTabOnHost(account, host, onlyTabRef) {
+        const list = await this.sendCommand({ method: 'tab_list', account });
+        const tabs = Array.isArray(list.tabs)
+            ? list.tabs
+            : [];
+        for (const t of tabs) {
+            if (t?.account !== account)
+                continue;
+            const ref = (t.tab ?? t.tabId);
+            if (onlyTabRef !== undefined && ref !== onlyTabRef && t.tabId !== onlyTabRef)
+                continue;
+            if (typeof t.url !== 'string')
+                continue;
+            try {
+                if (hostsMatch(new URL(t.url).host, host))
+                    return ref;
+            }
+            catch {
+                /* non-URL tab (about:blank etc.) — skip */
+            }
+        }
+        return undefined;
+    }
+    async ensureAccount(account, accountUrl) {
+        if (this.ensuredAccounts.has(account))
+            return false;
+        const inflight = this.ensuringAccounts.get(account);
+        if (inflight)
+            return inflight;
+        const ensure = (async () => {
+            let accountCreated = false;
+            try {
+                await this.sendCommand({ method: 'account_info', account });
+            }
+            catch (err) {
+                if (!isBrowserAccountInfoUnauthenticatedError(err)) {
+                    if (!isBrowserAccountNotFoundError(err))
+                        throw err;
+                    await this.sendCommand({
+                        method: 'account_create',
+                        account,
+                        ...(accountUrl ? { accountUrl } : {}),
+                    });
+                    accountCreated = true;
+                }
+            }
+            if (!accountUrl) {
+                await this.ensureAccountOwnedTab(account);
+            }
+            this.ensuredAccounts.add(account);
+            return accountCreated;
+        })();
+        this.ensuringAccounts.set(account, ensure);
+        try {
+            return await ensure;
+        }
+        finally {
+            this.ensuringAccounts.delete(account);
+        }
+    }
+    async ensureAccountOwnedTab(account) {
+        const list = await this.sendCommand({ method: 'tab_list', account });
+        const tabs = Array.isArray(list.tabs)
+            ? list.tabs
+            : [];
+        if (tabs.some((tab) => tab?.account === account))
+            return;
+        await this.sendCommand({ method: 'tab_new', account, url: 'about:blank' });
+    }
+    reportStatus(profileId, status, errorMsg) {
+        const marker = `${status}\u0000${errorMsg ?? ''}`;
+        if (this.reportedStatuses.get(profileId) === marker)
+            return;
+        this.reportedStatuses.set(profileId, marker);
+        this.opts.reportStatus?.(profileId, status, errorMsg);
+    }
+    async sendCommand(request) {
+        const daemon = await this.ensureDaemon();
+        const response = await this.post('/command', daemon, request, 30_000);
+        if (response.error) {
+            throw new BrowserCommandError(response.error.message || 'bb-browser command failed', request.method, request.account);
+        }
+        return response.result ?? {};
+    }
+    async ensureDaemon() {
+        if (this.restarting)
+            await this.restarting;
+        if (this.daemon &&
+            this.daemon.child.exitCode === null &&
+            this.daemon.child.signalCode === null) {
+            return this.daemon;
+        }
+        if (this.starting)
+            return this.starting;
+        this.starting = this.startDaemon();
+        try {
+            this.daemon = await this.starting;
+            return this.daemon;
+        }
+        finally {
+            this.starting = null;
+        }
+    }
+    async withDaemonRecovery(operation, label, onRecovered) {
+        try {
+            return await operation();
+        }
+        catch (err) {
+            if (!isRecoverableBrowserDaemonError(err))
+                throw err;
+            await this.restartDaemon(label, err);
+            onRecovered?.();
+            return operation();
+        }
+    }
+    async restartDaemon(label, err) {
+        if (this.restarting)
+            return this.restarting;
+        this.restarting = this.restartDaemonOnce(label, err);
+        try {
+            await this.restarting;
+        }
+        finally {
+            this.restarting = null;
+        }
+    }
+    async restartDaemonOnce(label, err) {
+        const daemon = this.daemon;
+        this.daemon = null;
+        this.starting = null;
+        this.ensuredAccounts.clear();
+        this.ensuringAccounts.clear();
+        this.opts.log.warn(`[bb-browser] ${label} hit a disconnected Chrome/CDP session; restarting bb-browser-daemon (${formatErrorForLog(err)})`);
+        if (!daemon)
+            return;
+        try {
+            await this.post('/shutdown', daemon, undefined, 3_000);
+        }
+        catch {
+            /* best-effort */
+        }
+        if (daemon.child.exitCode === null && daemon.child.signalCode === null) {
+            daemon.child.kill('SIGTERM');
+        }
+    }
+    async startDaemon() {
+        const host = '127.0.0.1';
+        const port = await findFreePort();
+        const token = randomToken();
+        const daemonPath = resolveBbBrowserDaemonPath();
+        const child = spawn(process.execPath, [daemonPath, '--host', host, '--port', String(port), '--token', token], {
+            env: {
+                ...process.env,
+                BB_BROWSER_HOME: this.opts.homeDir,
+            },
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        // A spawn/exec failure (ENOENT, EACCES, …) emits 'error' on the child, which
+        // — with no listener — Node re-throws as an uncaught exception and crashes
+        // the daemon. Capture it so startup fails through the normal path instead.
+        let childError = null;
+        child.once('error', (err) => {
+            childError = err;
+        });
+        child.stderr?.on('data', (chunk) => {
+            const text = chunk.toString('utf8').trim();
+            if (text)
+                this.opts.log.warn(`[bb-browser] ${text}`);
+        });
+        const state = { child, host, port, token };
+        const deadline = Date.now() + BB_BROWSER_DAEMON_START_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            if (childError) {
+                throw childError;
+            }
+            if (child.exitCode !== null || child.signalCode !== null) {
+                throw new Error(`bb-browser-daemon exited during startup`);
+            }
+            try {
+                await this.post('/status', state, undefined, 2_000);
+                this.opts.log.info(`[bb-browser] daemon ready at ${host}:${port}`);
+                return state;
+            }
+            catch {
+                await sleep(200);
+            }
+        }
+        child.kill('SIGTERM');
+        throw new Error('bb-browser-daemon did not start in time');
+    }
+    async post(pathName, daemon, body, timeoutMs = 10_000) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const resp = await fetch(`http://${daemon.host}:${daemon.port}${pathName}`, {
+                method: pathName === '/status' ? 'GET' : 'POST',
+                headers: {
+                    Authorization: `Bearer ${daemon.token}`,
+                    ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await resp.text();
+            if (!resp.ok) {
+                throw new Error(`bb-browser ${pathName} returned ${resp.status}: ${text}`);
+            }
+            return (text ? JSON.parse(text) : {});
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/** Host comparison tolerant of a `www.` prefix on either side. */
+function hostsMatch(a, b) {
+    const norm = (h) => h.toLowerCase().replace(/^www\./, '');
+    return norm(a) === norm(b);
+}
+function normalizeDomainUrl(domain) {
+    const trimmed = domain.trim();
+    if (!trimmed)
+        return 'about:blank';
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+function normalizeStartUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return 'about:blank';
+    if (trimmed === 'about:blank')
+        return trimmed;
+    return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+function isBrowserAccountNotFoundError(err) {
+    if (!(err instanceof BrowserCommandError) || err.method !== 'account_info')
+        return false;
+    const message = err.message.trim().toLowerCase();
+    if (!message)
+        return false;
+    const notFound = message === 'not found' ||
+        message.includes('account not found') ||
+        message.includes('account does not exist') ||
+        message.includes('unknown account') ||
+        message.includes('missing account') ||
+        // bb-browser-pro 0.15.x interpolates the account name into the message:
+        // `Account "<id>" not found`. Without this arm the matcher misses the
+        // real daemon's format entirely, so account_create never runs and every
+        // open of a fresh profile fails (caught on staging E2E 2026-06-04 with a
+        // real local daemon + Chrome).
+        /^account\s+"[^"]*"\s+not found\b/.test(message);
+    return notFound;
+}
+function isBrowserAccountInfoUnauthenticatedError(err) {
+    if (!(err instanceof BrowserCommandError) || err.method !== 'account_info')
+        return false;
+    const message = err.message.trim().toLowerCase();
+    return message.includes('not logged in') || message.includes('not authenticated');
+}
+function isRecoverableBrowserDaemonError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const lower = message.toLowerCase();
+    return (lower.includes('chrome not connected') ||
+        lower.includes('cdp at 127.0.0.1') ||
+        (lower.includes('bb-browser /command returned 503') &&
+            (lower.includes('chrome') || lower.includes('cdp'))));
+}
+function safeUrlHost(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return '';
+    }
+}
+function formatErrorForLog(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.replace(/\s+/g, ' ').slice(0, 300);
+}
+function resolveBbBrowserDaemonPath() {
+    // Bundle channels (CDN self-update, desktop, npm bin — all run the flat
+    // esbuild artifact with NO node_modules) ship bb-browser as a sibling flat
+    // artifact (scripts/bundle-daemon.mjs). Prefer it; fall through to normal
+    // package resolution for dev/dist runs. Without this, every bundle-delivered
+    // daemon failed browser profiles with "Cannot find module
+    // '@pinixai/bb-browser-pro/package.json'" (desktop staging, 2026-06-04).
+    const sibling = path.join(path.dirname(fileURLToPath(import.meta.url)), 'bb-browser-daemon.js');
+    if (existsSync(sibling))
+        return sibling;
+    const require = createRequire(import.meta.url);
+    const pkgPath = require.resolve('@pinixai/bb-browser-pro/package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const rel = typeof pkg.bin === 'string' ? pkg.bin : (pkg.bin?.['bb-browser-daemon'] ?? './dist/daemon.js');
+    const full = path.resolve(path.dirname(pkgPath), rel);
+    if (!existsSync(full)) {
+        throw new Error(`bb-browser-daemon entrypoint not found at ${full}`);
+    }
+    return full;
+}
+async function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            server.close(() => {
+                if (address && typeof address === 'object') {
+                    resolve(address.port);
+                }
+                else {
+                    reject(new Error('failed to allocate free port'));
+                }
+            });
+        });
+    });
+}
+function randomToken() {
+    return randomBytes(16).toString('hex');
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/clip-runtime/bun-resolver.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Bun binary resolution — shared by the clip process manager (which spawns
+ * `bun run <entry> --ipc`) and the clip installer (which runs `bun install`).
+ *
+ * Resolution order, embedded-first:
+ *   1. Embedded bun shipped alongside the daemon's node binary. In a packaged
+ *      desktop app the daemon is launched via `Frameworks/parall-node`, so
+ *      `dirname(process.execPath)` is the `Frameworks/` dir and the embedded
+ *      bun sits right beside it. electron-builder stages it under the CANONICAL
+ *      name `Frameworks/bun` (node stays `parall-node` since the daemon only
+ *      invokes node by absolute path, whereas bun must also be discoverable by
+ *      name on the child PATH for clip postinstall hooks / clips that shell out
+ *      to `bun`). This is the reliable path for users who never installed Bun.
+ *   2. User-level installs (`~/.bun/bin`, Homebrew) — for dev / CLI daemons.
+ *   3. PATH lookup (`which` / `where.exe`).
+ *
+ * A non-packaged or npm-CLI daemon runs from the system node, so the sibling
+ * `bun` does not exist and resolution falls through to the install candidates.
+ * The launchd-managed daemon inherits a minimal PATH
+ * (`/usr/bin:/bin:/usr/sbin:/sbin`) that contains neither `bun` nor `npm`,
+ * which is exactly why resolving an absolute path (not relying on PATH) matters.
+ */
+export declare function findBunBinary(): string;
+//# sourceMappingURL=bun-resolver.d.ts.map

package/dist/clip-runtime/bun-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun-resolver.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/bun-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAMH,wBAAgB,aAAa,IAAI,MAAM,CAgCtC"}

package/dist/clip-runtime/bun-resolver.js

@@ -0,0 +1,58 @@
+/**
+ * Bun binary resolution — shared by the clip process manager (which spawns
+ * `bun run <entry> --ipc`) and the clip installer (which runs `bun install`).
+ *
+ * Resolution order, embedded-first:
+ *   1. Embedded bun shipped alongside the daemon's node binary. In a packaged
+ *      desktop app the daemon is launched via `Frameworks/parall-node`, so
+ *      `dirname(process.execPath)` is the `Frameworks/` dir and the embedded
+ *      bun sits right beside it. electron-builder stages it under the CANONICAL
+ *      name `Frameworks/bun` (node stays `parall-node` since the daemon only
+ *      invokes node by absolute path, whereas bun must also be discoverable by
+ *      name on the child PATH for clip postinstall hooks / clips that shell out
+ *      to `bun`). This is the reliable path for users who never installed Bun.
+ *   2. User-level installs (`~/.bun/bin`, Homebrew) — for dev / CLI daemons.
+ *   3. PATH lookup (`which` / `where.exe`).
+ *
+ * A non-packaged or npm-CLI daemon runs from the system node, so the sibling
+ * `bun` does not exist and resolution falls through to the install candidates.
+ * The launchd-managed daemon inherits a minimal PATH
+ * (`/usr/bin:/bin:/usr/sbin:/sbin`) that contains neither `bun` nor `npm`,
+ * which is exactly why resolving an absolute path (not relying on PATH) matters.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+export function findBunBinary() {
+    const isWindows = process.platform === 'win32';
+    const binName = isWindows ? 'bun.exe' : 'bun';
+    // 1. Embedded bun — sibling of the daemon's node binary in a packaged app
+    //    (staged as parall-bun-${arch}, landed as Frameworks/bun).
+    const embedded = path.join(path.dirname(process.execPath), binName);
+    if (fs.existsSync(embedded))
+        return embedded;
+    if (!isWindows) {
+        const candidates = [
+            path.join(process.env.HOME || '', '.bun', 'bin', 'bun'),
+            '/usr/local/bin/bun',
+            '/opt/homebrew/bin/bun',
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+    }
+    // PATH lookup — platform-aware
+    const lookupCmd = isWindows ? 'where.exe' : 'which';
+    const lookupArg = isWindows ? 'bun.exe' : 'bun';
+    try {
+        const result = execFileSync(lookupCmd, [lookupArg], { encoding: 'utf-8' }).trim();
+        const firstLine = result.split('\n')[0]?.trim();
+        if (firstLine)
+            return firstLine;
+    }
+    catch {
+        // not found in PATH
+    }
+    throw new Error('bun binary not found — install Bun (https://bun.sh) or set bunPath option');
+}

package/dist/clip-runtime/clip-installer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clip-installer.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/clip-installer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAcH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,8HAA8H;IAC9H,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAcD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAgCxD;AAicD,wBAAsB,WAAW,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAiE9E;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/E"}
+{"version":3,"file":"clip-installer.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/clip-installer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAeH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,8HAA8H;IAC9H,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,UAAU,YAAY;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAcD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAgCxD;AAyeD,wBAAsB,WAAW,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAiE9E;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/E"}