@parall/daemon 1.32.0 → 1.33.0

package/dist/clip-runtime/process-manager.js

@@ -1,11 +1,16 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { execFileSync } from 'node:child_process';
 import { ClipProcess, ClipCommandError, } from './process.js';
+import { findBunBinary } from './bun-resolver.js';
+import { BROWSER_CAPABILITY_NAME, BROWSER_CAPABILITY_PACKAGE, browserCapabilityCommands, isBrowserDependencyName, } from './browser-dependency.js';
+import { HubCommandError } from './hub-client.js';
 export class ClipProcessManager {
     bunPath;
     clipsDir;
     dataDir;
+    browserProfileManager;
+    hubClient;
+    ensureInstalled;
     processes = new Map();
     startingUp = new Map();
     statuses = new Map();
@@ -17,6 +22,13 @@ export class ClipProcessManager {
         this.bunPath = opts.bunPath ?? '';
         this.clipsDir = opts.clipsDir;
         this.dataDir = opts.dataDir;
+        this.browserProfileManager = opts.browserProfileManager;
+        this.hubClient = opts.hubClient;
+        this.ensureInstalled = opts.ensureInstalled;
+    }
+    /** True when this daemon can host BrowserProfiles (serve inbound hub browser invokes). */
+    canHostBrowser() {
+        return this.browserProfileManager != null;
     }
     /** Backward-compat: set a single status listener (wraps addStatusListener). */
     set onStatusChange(fn) {
@@ -68,17 +80,26 @@ export class ClipProcessManager {
             this.setStatus(config.name, 'sleeping', 'registered');
         }
     }
+    async replaceClipConfig(config) {
+        this.registerClip(config);
+        await this.stopClip(config.name);
+        // An in-flight cold start may have resolved ensureInstalled() for the old
+        // config while stopClip was waiting. Re-apply the desired config after the
+        // stop window so the next lazy spawn uses the server-declared state.
+        this.registerClip(config);
+    }
     async unregisterClip(name) {
         this.shuttingDown.add(name);
         try {
-            const startup = this.startingUp.get(name);
-            if (startup) {
-                this.startingUp.delete(name);
-                await startup.then((proc) => proc.stop()).catch(() => { });
-            }
-            if (this.processes.has(name)) {
-                await this.stopClip(name);
+            const startupStops = [];
+            for (const [key, startup] of this.startingUp) {
+                if (!this.processKeyBelongsToName(key, name))
+                    continue;
+                this.startingUp.delete(key);
+                startupStops.push(startup.then((proc) => proc.stop()).catch(() => { }));
             }
+            await Promise.allSettled(startupStops);
+            await this.stopClip(name);
             this.clipConfigs.delete(name);
             this.statuses.delete(name);
         }
@@ -92,11 +113,27 @@ export class ClipProcessManager {
     async stopClip(name) {
         this.shuttingDown.add(name);
         try {
-            const proc = this.processes.get(name);
-            if (!proc)
+            // Also tear down any same-name shards still in their cold-start window.
+            // Without this an in-flight startup would complete and re-register into
+            // this.processes after stopClip returns, defeating the explicit stop.
+            const startupStops = [];
+            for (const [key, startup] of this.startingUp) {
+                if (!this.processKeyBelongsToName(key, name))
+                    continue;
+                this.startingUp.delete(key);
+                startupStops.push(startup.then((proc) => proc.stop()).catch(() => { }));
+            }
+            const stops = [];
+            for (const [key, proc] of this.processes) {
+                if (!this.processKeyBelongsToName(key, name))
+                    continue;
+                stops.push(proc.stop().finally(() => {
+                    this.processes.delete(key);
+                }));
+            }
+            if (stops.length === 0 && startupStops.length === 0)
                 return;
-            await proc.stop();
-            this.processes.delete(name);
+            await Promise.allSettled([...startupStops, ...stops]);
             this.setStatus(name, 'sleeping', 'stopped');
         }
         finally {
@@ -105,11 +142,19 @@ export class ClipProcessManager {
     }
     async stopAll() {
         // Mark all clips as shutting down before any async work
-        for (const name of this.processes.keys())
+        const names = new Set();
+        for (const key of this.processes.keys())
+            names.add(this.processNameFromKey(key));
+        for (const key of this.startingUp.keys())
+            names.add(this.processNameFromKey(key));
+        for (const name of names)
             this.shuttingDown.add(name);
-        for (const name of this.startingUp.keys())
-            this.shuttingDown.add(name);
-        const stops = Array.from(this.processes.keys()).map((name) => this.stopClip(name));
+        const stops = [];
+        for (const [key, proc] of this.processes) {
+            stops.push(proc.stop().finally(() => {
+                this.processes.delete(key);
+            }));
+        }
         // Also abort any in-flight startups (register window)
         for (const [, startup] of this.startingUp) {
             stops.push(startup.then((proc) => proc.stop()).catch(() => { }));
@@ -125,38 +170,40 @@ export class ClipProcessManager {
      * Application-level errors (ClipCommandError) are NOT retried.
      * Corresponds to Pinix ProcessManager.Invoke().
      */
-    async invoke(name, command, input) {
+    async invoke(name, command, input, context = {}) {
+        const key = this.processKey(name, context);
         try {
-            const proc = await this.ensureProcess(name);
+            const proc = await this.ensureProcess(name, context);
             const result = await proc.invoke(command, input);
             return result.output;
         }
         catch (err) {
             if (err instanceof ClipCommandError)
                 throw err;
-            const old = this.processes.get(name);
+            const old = this.processes.get(key);
             if (old?.alive())
                 await old.stop().catch(() => { });
-            this.processes.delete(name);
-            const proc = await this.ensureProcess(name);
+            this.processes.delete(key);
+            const proc = await this.ensureProcess(name, context);
             const result = await proc.invoke(command, input);
             return result.output;
         }
     }
-    async invokeStream(name, command, input, onChunk) {
+    async invokeStream(name, command, input, onChunk, context = {}) {
+        const key = this.processKey(name, context);
         try {
-            const proc = await this.ensureProcess(name);
+            const proc = await this.ensureProcess(name, context);
             const result = await proc.invokeStream(command, input, onChunk);
             return result.output;
         }
         catch (err) {
             if (err instanceof ClipCommandError)
                 throw err;
-            const old = this.processes.get(name);
+            const old = this.processes.get(key);
             if (old?.alive())
                 await old.stop().catch(() => { });
-            this.processes.delete(name);
-            const proc = await this.ensureProcess(name);
+            this.processes.delete(key);
+            const proc = await this.ensureProcess(name, context);
             const result = await proc.invokeStream(command, input, onChunk);
             return result.output;
         }
@@ -175,12 +222,29 @@ export class ClipProcessManager {
         return { status: entry.status, message: entry.message };
     }
     isRunning(name) {
-        const proc = this.processes.get(name);
-        return proc !== undefined && proc.alive();
+        for (const [key, proc] of this.processes) {
+            if (this.processKeyBelongsToName(key, name) && proc.alive())
+                return true;
+        }
+        return false;
     }
     getRegisteredClips() {
         return Array.from(this.clipConfigs.values());
     }
+    /**
+     * Clips this daemon advertises to the hub as a provider: the locally
+     * installed clips plus, when this machine hosts BrowserProfiles, a synthetic
+     * "browser" capability so the hub can route cross-machine browser invokes
+     * here. The browser capability has no local subprocess — it is served by
+     * invokeBrowserCapability() against bb-browser.
+     */
+    getProviderClips() {
+        const clips = this.getRegisteredClips();
+        if (this.canHostBrowser()) {
+            clips.push(browserCapabilityConfig());
+        }
+        return clips;
+    }
     /**
      * Load clip configs from the clips directory.
      * Reads clip-config.json if present, or scans subdirectories for clip.json files.
@@ -210,11 +274,20 @@ export class ClipProcessManager {
             // Try clip.json first, fall back to package.json
             const clipJsonPath = path.join(clipDir, 'clip.json');
             const pkgJsonPath = path.join(clipDir, 'package.json');
+            // Key by the install-directory alias, NOT the manifest name. The
+            // installer writes to clipsDir/{org alias}/ and the install-time
+            // registration (supervisor handleClipInstall) keys by that alias — the
+            // hub routes org invokes by it (sess.clips[alias]). Preferring
+            // clipJson.name here re-keyed clips by their package name
+            // ("@pinix/reddit") after a daemon restart, so org-alias invokes
+            // ("reddit") failed with "no online provider" until reinstall (caught
+            // on the staging closed-loop E2E, 2026-06-04). The manifest/package
+            // identity stays on `package`.
             if (fs.existsSync(clipJsonPath)) {
                 try {
                     const clipJson = JSON.parse(fs.readFileSync(clipJsonPath, 'utf-8'));
                     this.registerClip({
-                        name: clipJson.name || entry.name,
+                        name: entry.name,
                         package: clipJson.name,
                         version: clipJson.version,
                         source: clipDir,
@@ -229,7 +302,7 @@ export class ClipProcessManager {
                 try {
                     const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
                     this.registerClip({
-                        name: pkgJson.name || entry.name,
+                        name: entry.name,
                         package: pkgJson.name,
                         version: pkgJson.version,
                         source: clipDir,
@@ -243,40 +316,54 @@ export class ClipProcessManager {
         }
     }
     // --- internal ---
-    async ensureProcess(name) {
+    async ensureProcess(name, context = {}) {
         if (this.shuttingDown.has(name)) {
             throw new Error(`clip "${name}" is shutting down`);
         }
-        const existing = this.processes.get(name);
+        const key = this.processKey(name, context);
+        const existing = this.processes.get(key);
         if (existing && existing.alive())
             return existing;
         // Deduplicate concurrent cold-start requests
-        const inflight = this.startingUp.get(name);
+        const inflight = this.startingUp.get(key);
         if (inflight)
             return inflight;
-        const config = this.clipConfigs.get(name);
-        if (!config)
-            throw new Error(`clip "${name}" not registered`);
-        const startup = this.spawnProcess(config);
-        this.startingUp.set(name, startup);
+        const startup = (async () => {
+            let config = this.clipConfigs.get(name);
+            if (!config)
+                throw new Error(`clip "${name}" not registered`);
+            if (this.ensureInstalled) {
+                config = await this.ensureInstalled(config);
+                this.clipConfigs.set(name, config);
+            }
+            return this.spawnProcess(config, context);
+        })();
+        this.startingUp.set(key, startup);
         try {
             return await startup;
         }
         finally {
-            this.startingUp.delete(name);
+            this.startingUp.delete(key);
         }
     }
-    async spawnProcess(config) {
-        const proc = new ClipProcess(config);
-        const clipDataDir = this.ensureClipDataDir(config);
-        proc.spawn(this.resolveBun(), {
+    async spawnProcess(config, context) {
+        const proc = new ClipProcess(config, context, (clipName, command, input, invokeContext) => this.invokeDependency(clipName, command, input, invokeContext));
+        const clipDataDir = this.ensureClipDataDir(config, context);
+        const bunPath = this.resolveBun();
+        proc.spawn(bunPath, {
             PINIX_DATA_DIR: clipDataDir,
+            PRLL_CLIP_ID: context.clipId ?? '',
+            // Expose the embedded bun's directory on the clip's PATH so a clip that
+            // shells out to `bun` by name resolves it — the daemon's launchd PATH
+            // does not include Frameworks/. Symmetric with installDeps(); relies on
+            // the embedded binary being named `bun` (Frameworks/bun).
+            PATH: `${path.dirname(bunPath)}${path.delimiter}${process.env.PATH ?? ''}`,
         });
         this.setStatus(config.name, 'running', 'starting');
         try {
             await proc.waitReady();
             // Only expose to concurrent callers after registration completes
-            this.processes.set(config.name, proc);
+            this.processes.set(this.processKey(config.name, context), proc);
             this.setStatus(config.name, 'running', 'ready');
             // Always cache manifest so Provider registrations have commands
             const manifest = proc.getManifest();
@@ -292,7 +379,7 @@ export class ClipProcessManager {
         }
         // Monitor process exit in background
         proc.waitDone().then(() => {
-            this.removeIfSame(config.name, proc);
+            this.removeIfSame(config.name, proc, context);
             const exitErr = proc.getError();
             if (exitErr) {
                 this.setStatus(config.name, 'error', exitErr.message);
@@ -303,16 +390,91 @@ export class ClipProcessManager {
         });
         return proc;
     }
-    ensureClipDataDir(config) {
-        const dir = path.join(this.dataDir, config.name);
+    ensureClipDataDir(config, context = {}) {
+        const dir = path.join(this.dataDir, config.name, context.clipId ?? 'default');
         fs.mkdirSync(dir, { recursive: true });
         return dir;
     }
-    removeIfSame(name, proc) {
-        if (this.processes.get(name) === proc) {
-            this.processes.delete(name);
+    removeIfSame(name, proc, context = {}) {
+        const key = this.processKey(name, context);
+        if (this.processes.get(key) === proc) {
+            this.processes.delete(key);
         }
     }
+    processKey(name, context = {}) {
+        return context.clipId ? `${name}::${context.clipId}` : name;
+    }
+    processKeyBelongsToName(key, name) {
+        return key === name || key.startsWith(`${name}::`);
+    }
+    processNameFromKey(key) {
+        const marker = key.indexOf('::');
+        return marker === -1 ? key : key.slice(0, marker);
+    }
+    /**
+     * Execution-side nested dependency invoke (from a child clip's IPC). The
+     * browser slot is resolved UNIQUELY via the hub: read the Clip's binding
+     * (GetBindings), then forward the invoke through the hub (Invoke) to the bound
+     * BrowserProfile's host. No local shortcut, no fallback — unbound is rejected.
+     * The execution daemon never verifies clip_token; the hub does.
+     * See docs/engineering-design/browser-profile-clip-integration.md §11.3.
+     */
+    async invokeDependency(clipName, command, input, context) {
+        if (!isBrowserDependencyName(clipName)) {
+            throw new Error(`clip dependency "${clipName}" is not supported`);
+        }
+        const clipId = context.clipId;
+        if (!clipId) {
+            // Without the executing Clip identity we cannot resolve the binding. The
+            // process key shards by clipId, so this should not happen for a
+            // browser-bound Clip.
+            throw new ClipCommandError('browser dependency requires a clip binding');
+        }
+        const hub = this.hubClient?.();
+        if (!hub) {
+            throw new Error('browser dependency runtime is not configured (no hub client)');
+        }
+        const bindings = await hub.getBindings(clipId);
+        const binding = bindings[BROWSER_CAPABILITY_NAME];
+        if (!binding || !binding.clipToken) {
+            // Unbound browser slot: surface as a clip-level error so the calling clip
+            // gets a recoverable rejection instead of a process crash.
+            throw new ClipCommandError(`clip "${clipId}" has no browser binding`, 'CLIP_PROFILE_UNBOUND');
+        }
+        try {
+            return await hub.invoke(BROWSER_CAPABILITY_NAME, command, input, binding.clipToken);
+        }
+        catch (err) {
+            // A hub-flagged application error (e.g. BROWSER_COMMAND_ERROR) is a
+            // recoverable clip-level rejection; translate it so the calling clip is
+            // not torn down. Transport/internal errors propagate as fatal.
+            if (err instanceof HubCommandError) {
+                throw new ClipCommandError(err.message, err.code);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Host-side browser capability handler (inbound hub InvokeCommand for the
+     * synthetic "browser" clip). The hub forwards clip_token as the PLAINTEXT
+     * browser_profile_id, which the host daemon uses directly as the bb-browser
+     * account. Only daemons that host BrowserProfiles register this capability.
+     * See docs/engineering-design/browser-profile-clip-integration.md §11.2.
+     */
+    async invokeBrowserCapability(clipToken, command, input) {
+        if (!this.browserProfileManager) {
+            throw new Error('browser capability is not hosted on this machine');
+        }
+        if (!clipToken) {
+            throw new ClipCommandError('browser invoke missing profile identity (clip_token)');
+        }
+        return this.browserProfileManager.invoke({
+            profileId: clipToken,
+            account: clipToken,
+            command,
+            input,
+        });
+    }
     setStatus(name, status, message) {
         this.statuses.set(name, { status, message, since: new Date() });
         for (const fn of this.statusListeners) {
@@ -325,30 +487,25 @@ export class ClipProcessManager {
         }
     }
 }
-function findBunBinary() {
-    const isWindows = process.platform === 'win32';
-    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');
+/**
+ * Synthetic ClipConfig for the host-side "browser" capability. It has no local
+ * subprocess (no `path` to spawn); the hub routes browser invokes here and they
+ * are served by ClipProcessManager.invokeBrowserCapability() against bb-browser.
+ */
+function browserCapabilityConfig() {
+    return {
+        name: BROWSER_CAPABILITY_NAME,
+        package: BROWSER_CAPABILITY_PACKAGE,
+        version: '0.15.0',
+        source: BROWSER_CAPABILITY_PACKAGE,
+        path: '',
+        manifest: {
+            name: BROWSER_CAPABILITY_NAME,
+            package: BROWSER_CAPABILITY_PACKAGE,
+            version: '0.15.0',
+            description: 'Profile-bound browser capability (bb-browser-pro)',
+            commands: browserCapabilityCommands().map((c) => c.name),
+            commandDetails: browserCapabilityCommands(),
+        },
+    };
 }

package/dist/clip-runtime/process.d.ts

@@ -12,11 +12,24 @@ export interface InvokeEvent {
 export interface InvokeResult {
     output: unknown;
 }
+export interface ClipInvokeContext {
+    /**
+     * The executing Clip id. It shards the process pool and fixes the caller
+     * identity for nested dependency invokes, so the execution side can resolve
+     * the Clip's browser binding via the hub. Browser
+     * profile / account identity is NOT carried here — it is resolved from the
+     * hub binding (GetBindings) and rides on clip_token end-to-end.
+     */
+    clipId?: string;
+}
+export type DependencyInvokeResolver = (clipName: string, command: string, input: unknown, context: ClipInvokeContext) => Promise<unknown>;
 export declare class ClipCommandError extends Error {
     readonly code?: string;
     constructor(message: string, code?: string);
 }
 export declare class ClipProcess {
+    private readonly context;
+    private readonly dependencyResolver?;
     readonly clip: ClipConfig;
     private child;
     private reader;
@@ -32,7 +45,7 @@ export declare class ClipProcess {
     private doneDeferred;
     private doneResolved;
     private exitError;
-    constructor(clip: ClipConfig);
+    constructor(clip: ClipConfig, context?: ClipInvokeContext, dependencyResolver?: DependencyInvokeResolver | undefined);
     /**
      * Spawn the Bun subprocess and start the IPC read loop.
      * Corresponds to Pinix startLocked().
@@ -51,6 +64,7 @@ export declare class ClipProcess {
     private handleRegister;
     private dispatchInvokeEvent;
     private handleData;
+    private handleDependencyInvoke;
     private send;
     private signalReady;
     private finish;

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

@@ -1 +1 @@
-{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/process.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,aAAa,EAInB,MAAM,eAAe,CAAC;AAevB,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC;AAEjE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;gBACX,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM;CAK3C;AAgBD,qBAAa,WAAW;IACtB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAE1B,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,MAAM,CAA6B;IAE3C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,OAAO,CAAmD;IAClE,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAoB;gBAEzB,IAAI,EAAE,UAAU;IAI5B;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAwCnD,SAAS,CAAC,SAAS,GAAE,MAAiC,GAAG,OAAO,CAAC,IAAI,CAAC;IAe5E,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAInB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;IAI/D,YAAY,CAChB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GACjC,OAAO,CAAC,YAAY,CAAC;IA2DlB,IAAI,CAAC,SAAS,GAAE,MAA6B,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBnE,KAAK,IAAI,OAAO;IAShB,WAAW,IAAI,aAAa,GAAG,IAAI;IAInC,QAAQ,IAAI,KAAK,GAAG,SAAS;YAMf,QAAQ;IAWtB,OAAO,CAAC,aAAa;IA6CrB,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,UAAU;YASJ,IAAI;IAKlB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,MAAM;IAiCd,OAAO,CAAC,KAAK;CAOd"}
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../src/clip-runtime/process.ts"],"names":[],"mappings":"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"}

package/dist/clip-runtime/process.js

@@ -2,7 +2,8 @@ import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { clearAllProviderCreds } from '../runtimes.js';
 import { NdjsonReader, NdjsonWriter, MessageType } from './ipc.js';
-import { manifestFromIpc, enrichManifest, resolveEntrypoint, } from './manifest.js';
+import { enrichManifest, manifestFromIpc, resolveEntrypoint, } from './manifest.js';
+import { manifestDeclaresBrowserDependency, manifestMapsDependencyToBrowser, } from './browser-dependency.js';
 const CLIP_REGISTER_TIMEOUT_MS = 10_000;
 const CLIP_STOP_TIMEOUT_MS = 5_000;
 function sanitizeEnvForClip(extra) {
@@ -32,6 +33,8 @@ function makeDeferred() {
     return { promise, resolve, reject };
 }
 export class ClipProcess {
+    context;
+    dependencyResolver;
     clip;
     child = null;
     reader = null;
@@ -47,7 +50,9 @@ export class ClipProcess {
     doneDeferred = makeDeferred();
     doneResolved = false;
     exitError;
-    constructor(clip) {
+    constructor(clip, context = {}, dependencyResolver) {
+        this.context = context;
+        this.dependencyResolver = dependencyResolver;
         this.clip = clip;
     }
     /**
@@ -231,20 +236,27 @@ export class ClipProcess {
                 this.handleData(msg);
                 break;
             case MessageType.ListClips:
-                // Clip-to-clip list request — respond with empty for now (Phase 2)
+                // Advertise the "browser" dependency to the child whenever its manifest
+                // declares it. Binding resolution + cross-machine routing happen at
+                // invoke time via the hub (GetBindings → Invoke); an unbound or
+                // unavailable profile surfaces as an invoke-time error, not here.
                 this.send({
                     id: msg.id,
                     type: MessageType.ListClipsResult,
-                    clips: [],
+                    clips: this.context.clipId && manifestDeclaresBrowserDependency(this.manifest)
+                        ? [
+                            {
+                                name: 'browser',
+                                package: '@pinixai/bb-browser-pro',
+                                version: '0.15.0',
+                                description: 'Profile-bound browser capability',
+                            },
+                        ]
+                        : [],
                 }).catch(() => { });
                 break;
             case MessageType.Invoke:
-                // Clip-to-clip invoke — not routed in Phase 1
-                this.send({
-                    id: msg.id,
-                    type: MessageType.Error,
-                    error: 'clip-to-clip invoke not supported yet',
-                }).catch(() => { });
+                void this.handleDependencyInvoke(msg);
                 break;
             case MessageType.Heartbeat:
                 break;
@@ -291,6 +303,8 @@ export class ClipProcess {
             event.output = msg.output;
         if (msg.error)
             event.error = { message: msg.error };
+        if (msg.processExit || msg.process_exit)
+            event.processExit = true;
         callback(event);
     }
     handleData(msg) {
@@ -301,6 +315,55 @@ export class ClipProcess {
             error: 'data operations not implemented yet',
         }).catch(() => { });
     }
+    async handleDependencyInvoke(msg) {
+        const dependencyName = msg.clip ?? msg.alias ?? '';
+        if (!msg.id) {
+            console.warn(`[clip:${this.clip.name}] dependency invoke missing id`);
+            return;
+        }
+        if (!dependencyName || !msg.command) {
+            await this.send({
+                id: msg.id,
+                type: MessageType.Error,
+                error: 'dependency clip and command are required',
+            }).catch(() => { });
+            return;
+        }
+        if (!manifestMapsDependencyToBrowser(this.manifest, dependencyName)) {
+            await this.send({
+                id: msg.id,
+                type: MessageType.Error,
+                error: 'browser dependency is not declared by this clip',
+            }).catch(() => { });
+            return;
+        }
+        if (!this.dependencyResolver) {
+            await this.send({
+                id: msg.id,
+                type: MessageType.Error,
+                error: 'clip dependency invoke is not configured',
+            }).catch(() => { });
+            return;
+        }
+        try {
+            const output = await this.dependencyResolver('browser', msg.command, msg.input ?? {}, this.context);
+            await this.send({
+                id: msg.id,
+                type: MessageType.Result,
+                output,
+            });
+        }
+        catch (err) {
+            const isCommandError = err instanceof ClipCommandError;
+            await this.send({
+                id: msg.id,
+                type: MessageType.Error,
+                error: err instanceof Error ? err.message : String(err),
+                processExit: !isCommandError,
+                process_exit: !isCommandError,
+            }).catch(() => { });
+        }
+    }
     async send(msg) {
         if (!this.writer)
             throw new Error('writer not initialized');

package/dist/config.d.ts

@@ -54,6 +54,15 @@ export type ClaudeDaemonConfig = {
     /** Disable self-update entirely (K8s env auto-disables). */
     updateDisabled: boolean;
 };
+/**
+ * Root dir for all on-disk daemon state: `config.json`, the self-update
+ * `bundle/` overlay (versions + current symlink + update-state.json), and
+ * bridge-bin resolution all derive from this single path. `PRLL_DAEMON_CONFIG_DIR`
+ * overrides it so multiple daemons can coexist on one host without colliding —
+ * e.g. a staging desktop install points its launchd agent at
+ * `~/.parall-daemon-staging` while prod keeps the default `~/.parall-daemon`.
+ * Unset → default (no behavior change for existing single-env installs).
+ */
 export declare function daemonConfigDir(env?: NodeJS.ProcessEnv): string;
 export declare function daemonConfigPath(env?: NodeJS.ProcessEnv): string;
 export declare function resolveClaudeDaemonConfig(env?: NodeJS.ProcessEnv): ClaudeDaemonConfig;