@parall/daemon 1.45.0 → 1.47.0

package/dist/supervisor.js

@@ -4,11 +4,14 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { effectiveLLMSourceExplicit, llmSource } from '@parall/agent-core';
 import { ParallWs, } from '@parall/sdk';
+import { PUBLIC_PROXY_PROBE_FALLBACK_URL } from './clip-runtime/browser-readiness.js';
 import { installClip, parseSource } from './clip-runtime/clip-installer.js';
 import { parseIpcCommands } from './clip-runtime/manifest.js';
 import { BrowserProfilePool, ClipProcessManager, ClipProvider, HubClient, } from './clip-runtime/index.js';
 import { agentClaudeHomeFor, agentHomeDirFor, agentStateDirFor, agentWorkspaceDirFor, } from './config.js';
+import { reconcileBrowserProfiles as runBrowserProfileReconcile } from './browser-profile-reconcile.js';
 import { listDirectory } from './filesystem.js';
+import { startLocalProfileControl, } from './local-profile-control.js';
 import { ensureIsolatedHome, ensureSharedCredentialLink, } from './home-isolation.js';
 import { assertAgentKey, getRuntimeAdapter } from './runtimes.js';
 import { applyRuntimeBinaryEnv } from './runtime-bin-resolver.js';
@@ -97,6 +100,11 @@ export class DaemonSupervisor {
     running = false;
     machineId = null;
     machineOrgId = null;
+    // machines.created_by — the machine owner. The local control socket's profile
+    // commands are authorized against it (requester must BE the owner); kept
+    // fresh via bootstrap + refreshMachineConfig. Null until bootstrap → the
+    // local control plane fails closed.
+    machineCreatedBy = null;
     machineLlmSource = 'parall';
     // Whether this machine contributes its local clips as a hub provider. The
     // org admin toggles it via PATCH /machines/{id}/provider-enabled; default true.
@@ -115,6 +123,7 @@ export class DaemonSupervisor {
     // browserProfilePool replaces the old single browserProfileManager.
     healthGate = null;
     browserProfilePool = null;
+    localControl = null;
     clipManager = null;
     clipProvider = null;
     clipReconcileTimer = null;
@@ -178,6 +187,7 @@ export class DaemonSupervisor {
                         .catch((err) => this.log.warn(`browser profile status report failed: ${String(err)}`));
                 },
                 resolveProxy: (profileId) => this.resolveBrowserProfileProxy(profileId),
+                proxyProbeUrl: this.resolveBrowserProxyProbeUrl(),
             });
             this.clipManager = new ClipProcessManager({
                 clipsDir: path.join(this.config.rootStateDir, 'clips'),
@@ -212,6 +222,9 @@ export class DaemonSupervisor {
             await this.applyClipProviderState();
             this.startClipReconcileTimer();
         }
+        // Same-machine control plane (design daemon-control-authorization §7.1) —
+        // socket lifecycle + authorization live in local-profile-control.ts.
+        this.localControl = await startLocalProfileControl(this.localProfileControlDeps());
         // Report daemon version + self-update capability + detected runtime CLIs
         // via heartbeat (best-effort, off the critical path — detection spawns
         // `--version` probes). Capability tracks whether a service manager
@@ -357,6 +370,10 @@ export class DaemonSupervisor {
             }
             exits.push(this.terminateChild(state));
         }
+        if (this.localControl) {
+            exits.push(this.localControl.stop());
+            this.localControl = null;
+        }
         if (this.clipProvider) {
             exits.push(this.clipProvider.disconnect());
             this.clipProvider = null;
@@ -385,6 +402,7 @@ export class DaemonSupervisor {
                 const machine = await this.client.getMachineSelf();
                 this.machineId = machine.id;
                 this.machineOrgId = machine.org_id;
+                this.machineCreatedBy = machine.created_by ?? null;
                 this.machineLlmSource = machine.llm_source ?? 'parall';
                 this.machineProviderEnabled = machine.provider_enabled ?? true;
                 this.machineClipProviderUrl = machine.clip_provider_url ?? null;
@@ -517,195 +535,23 @@ export class DaemonSupervisor {
             throw err;
         }
     }
-    async reconcileBrowserProfiles() {
+    reconcileBrowserProfiles() {
+        // Coordination body extracted move-only to browser-profile-reconcile.ts (this
+        // file crossed the 2000-line ceiling). The op queue / pool lifecycle / wipe
+        // helper are injected so the behavior is byte-for-byte identical.
         const pool = this.browserProfilePool;
         if (!pool)
-            return;
-        // Snapshot the locally-live set BEFORE the server fetch. A profile opened via a
-        // WS lifecycle event DURING the fetch is NOT in this snapshot, so the negative
-        // convergence below (which is stale w.r.t. that open) can never release it.
-        // There is no periodic browser reconcile to re-open a wrongly-released profile —
-        // it only runs on startup / WS-hello — so a stale release would strand it until
-        // the next reconnect.
-        const activeBeforeList = new Set(pool.activeProfileIds());
-        // Also snapshot revives (open/ensure) queued but not yet a live manager: such a
-        // stale open is invisible to activeProfileIds() and would otherwise drain after a
-        // missed offline stop/delete and start a runtime the server no longer wants.
-        const pendingReviveBeforeList = new Set(this.browserProfilePendingRevives.keys());
-        // And ALL local profile state — per-profile homes AND legacy flat account files
-        // (the pool owns that storage layout). State with NO server row is a
-        // deleted/reassigned profile whose cookies/storage must be wiped from this host;
-        // a pre-upgrade profile never reopened after migration exists only as a legacy flat
-        // file, so home-only enumeration would miss it. Pre-fetch so state created during
-        // the fetch is left alone.
-        const localStateBeforeList = new Set(pool.localStateProfileIds());
-        let profiles;
-        try {
-            profiles = await this.client.listMachineBrowserProfiles();
-        }
-        catch (err) {
-            this.log.warn(`browser profile reconcile: list failed: ${String(err)}`);
-            return;
-        }
-        // The pool must still be the same instance after the await — stop() may have
-        // nulled/replaced it during a concurrent shutdown; bail rather than act on a
-        // torn-down pool (also avoids NPE-ing through Promise.allSettled into warnings).
-        if (this.browserProfilePool !== pool)
-            return;
-        // Converge local runtimes to the server's desired-live set (the server is the
-        // SSOT). The supervisor is the desired-state coordinator; the pool is the
-        // per-profile runtime registry. Every op here goes through
-        // enqueueBrowserProfileOp so all supervisor-originated profile work shares one
-        // ordering layer (the pool's own queue is the final per-profile mutex).
-        const desiredLive = new Set();
-        const serverIds = new Set(); // every byoc profile the server still lists (any status)
-        const serverResetGen = new Map();
-        const ops = [];
-        // reset_generation (server) is the SSOT for reset intent; the daemon's per-profile
-        // sidecar (read via pool.appliedResetGeneration) is only a local ack of "already
-        // wiped up to this generation". A missed reset (server newer than the local ack) must
-        // wipe local state BEFORE any open/ensure, so a reopen starts clean and never
-        // resurrects the cookies the reset cleared. Returns the server reset_generation to
-        // apply, or null if nothing is missed. Pure (no side effects).
-        const missedResetGen = (profileId) => {
-            const gen = serverResetGen.get(profileId) ?? 0;
-            return gen > pool.appliedResetGeneration(profileId) ? gen : null;
-        };
-        // Negative-path helper (a stopped profile with a missed reset): fence synchronously
-        // then enqueue a STANDALONE wipe. No revive follows, so a wipe failure simply leaves
-        // the profile fenced and the sidecar unwritten → the next reconcile retries (the
-        // SSOT reset_generation is still unapplied locally). Fail-closed by construction.
-        const enqueueResetWipeIfMissed = (profileId) => {
-            const gen = missedResetGen(profileId);
-            if (gen === null)
-                return false;
-            // Fence SYNCHRONOUSLY before the async wipe — same contract as the WS stop/reset
-            // path. On a machine-WS reconnect whose clip-provider stream stays live, a hub
-            // invoke could otherwise run on the stale runtime in the gap before the wipe op
-            // starts. (In the negative loop this re-asserts an already-set fence within the same
-            // synchronous iteration — atomic, no revive can observe an intermediate generation.)
-            pool.fence(profileId);
-            ops.push(this.enqueueBrowserProfileOp(profileId, () => pool.applyResetWipe(profileId, gen)));
-            return true;
-        };
-        for (const profile of profiles) {
-            // The daemon supervises only machine-bound (byoc) profiles; hosted profiles
-            // (null machine_id) run on the platform pool and are never owned by a daemon.
-            if (!profile.machine_id)
-                continue;
-            serverIds.add(profile.id);
-            serverResetGen.set(profile.id, profile.reset_generation ?? 0);
-            if (profile.status !== 'running' && profile.status !== 'pending')
-                continue;
-            desiredLive.add(profile.id);
-            // A missed reset must wipe SUCCESSFULLY before this profile is revived. Fence
-            // synchronously now (reject hub invokes in the gap before the queued wipe runs).
-            const wipeGen = missedResetGen(profile.id);
-            if (wipeGen !== null)
-                pool.fence(profile.id);
-            // Capture the fence generation AFTER any fence bump so a stop arriving while the op
-            // waits makes it skip as stale; carry the lifecycle generation so the daemon's
-            // `running` report is fenced server-side. Drive desired state through the CAPTURED
-            // pool (not enqueueBrowserProfileLifecycle, which re-reads this.browserProfilePool
-            // and would negative-ACK `error` for a pending profile if stop() nulled the field).
-            const sinceSeq = pool.stopSeqOf(profile.id);
-            const generation = profile.lifecycle_generation;
-            // forceStatusReport ONLY for a `pending` row: the daemon's last report may already be
-            // `running` (Chromium survived the WS drop), so a deduped repeat would leave the
-            // server stuck at `pending`. A `running` row keeps the normal dedup.
-            const forceStatusReport = profile.status === 'pending';
-            ops.push(this.enqueueBrowserProfileRevive(profile.id, async () => {
-                // Reset-before-open, FAIL-CLOSED: a missed reset must wipe successfully BEFORE
-                // the revive un-fences and reopens. If applyResetWipe throws, the await
-                // propagates and ensureRuntime is SKIPPED — the profile stays fenced (the wipe
-                // fenced it and the applied-reset sidecar was NOT written), so the next reconcile
-                // retries because the SSOT reset_generation is still unapplied locally. This
-                // ordering is expressed locally; the enqueueBrowserProfileOp queue contract (a
-                // rejected op does not block later ops) is intentionally unchanged. A failed
-                // wipe reports `error` (visible) and re-throws here, so ensureRuntime is skipped.
-                if (wipeGen !== null)
-                    await this.wipeBeforeRevive(pool, profile.id, wipeGen, generation);
-                // Reconnect recovery is liveness-only: ensure the runtime is live (account +
-                // tab) for both pending and running. The original open's `start_url` is NOT
-                // replayed (it rides only the live lifecycle event, not persisted); a `pending`
-                // profile whose open event the daemon missed comes up at the default page rather
-                // than a targetless `about:blank`. Persisting start_url is a separate follow-up.
-                await pool.ensureRuntime(profile.id, sinceSeq, generation, { forceStatusReport });
-            }));
-        }
-        // Negative convergence over everything locally known but NOT desired — active
-        // runtimes, queued revives (open/ensure not yet a manager), and local state (homes +
-        // legacy flat files) — all from the PRE-FETCH snapshots, so a profile that appeared
-        // DURING the fetch is left alone (no periodic reconcile would undo a wrong teardown).
-        const candidates = new Set([
-            ...activeBeforeList,
-            ...pendingReviveBeforeList,
-            ...localStateBeforeList,
-        ]);
-        for (const profileId of candidates) {
-            if (desiredLive.has(profileId))
-                continue;
-            const isActive = activeBeforeList.has(profileId);
-            const hasLocalState = localStateBeforeList.has(profileId);
-            // Pending-only revive (queued open/ensure, no runtime, no on-disk state at the
-            // pre-fetch snapshot): the synchronous fence alone neutralizes the stale open (it
-            // bumps stopSeq, so the queued revive skips as stale). Do NOT AWAIT a teardown — it
-            // would block behind the possibly-stuck queue and stall the whole reconcile (the
-            // queued-stale-open deadlock).
-            if (!isActive && !hasLocalState) {
-                pool.fence(profileId);
-                // Race: a pending-only revive can COMPLETE during the list fetch (create a manager
-                // + on-disk state) BEFORE this fence — the snapshot is then stale, so the fence
-                // alone leaves an orphaned runtime/disk the negative loop never converged. Converge
-                // it FIRE-AND-FORGET (NOT in `ops`: a still-stuck revive queue must not hang the
-                // reconcile; it runs once the queue drains — after the fenced open skips or
-                // completes — and is a no-op if nothing was created):
-                //   - deleted/reassigned    → wipeAbsent: the old host must keep no session data.
-                //   - present + missed reset → applyResetWipe: the completed open may have applied
-                //     only its event's (older) reset_generation, not the current one.
-                //   - present + stopped      → releaseRuntime: free the orphaned Chromium; a plain
-                //     stop keeps its cookies on disk.
-                let cleanup;
-                if (!serverIds.has(profileId)) {
-                    cleanup = pool.wipeAbsent(profileId);
-                }
-                else {
-                    const wipeGen = missedResetGen(profileId);
-                    cleanup =
-                        wipeGen !== null
-                            ? pool.applyResetWipe(profileId, wipeGen)
-                            : pool.releaseRuntime(profileId);
-                }
-                void cleanup.catch((err) => this.log.warn(`browser profile pending-revive cleanup failed for ${profileId}: ${String(err)}`));
-                continue;
-            }
-            if (!serverIds.has(profileId)) {
-                // Absent from the server list → deleted/reassigned → fence + wipe local state (the
-                // old host must not keep cookies/storage). No status report — server is the SSOT.
-                pool.fence(profileId);
-                ops.push(this.enqueueBrowserProfileOp(profileId, () => pool.wipeAbsent(profileId)));
-            }
-            else if (enqueueResetWipeIfMissed(profileId)) {
-                // Present (stopped) with a missed reset → fenced synchronously + wipe enqueued.
-            }
-            else if (isActive) {
-                // Present (stopped) but the runtime is still live → fence + release the runtime
-                // only; a plain stop keeps its cookies on disk.
-                pool.fence(profileId);
-                ops.push(this.enqueueBrowserProfileOp(profileId, () => pool.releaseRuntime(profileId)));
-            }
-            // else: present + stopped + on-disk state + no runtime + no missed reset → LEAVE
-            // ALONE (do NOT fence). Its stopped-fence is already held — the start-sequence
-            // pre-fence on a fresh daemon, or the persisted pool state on a WS reconnect — so a
-            // hub invoke is still rejected. Re-fencing here would bump stopSeq and drop an `open`
-            // that arrived during the list fetch (it captured an older sinceSeq, and the stale
-            // `stopped` snapshot doesn't reflect it yet), stranding the server at `pending`.
-        }
-        for (const result of await Promise.allSettled(ops)) {
-            if (result.status === 'rejected') {
-                this.log.warn(`browser profile reconcile op failed: ${String(result.reason)}`);
-            }
-        }
+            return Promise.resolve();
+        return runBrowserProfileReconcile({
+            pool,
+            currentPool: () => this.browserProfilePool,
+            client: this.client,
+            log: this.log,
+            enqueueOp: (id, op) => this.enqueueBrowserProfileOp(id, op),
+            enqueueRevive: (id, op) => this.enqueueBrowserProfileRevive(id, op),
+            wipeBeforeRevive: (p, id, rg, g) => this.wipeBeforeRevive(p, id, rg, g),
+            pendingReviveIds: () => new Set(this.browserProfilePendingRevives.keys()),
+        });
     }
     /**
      * Resolve a profile's outbound proxy for bb-browser account creation (BYOC).
@@ -731,6 +577,22 @@ export class DaemonSupervisor {
             password: profile.proxy_password ?? undefined,
         };
     }
+    /** Proxy readiness probe endpoint for BYOC profiles (browser-readiness.ts): an
+     *  explicit override, else the api-server's Parall-owned public `/generate_204`.
+     *  The probe navigates a sacrificial tab THROUGH the profile's proxy, so the
+     *  target must be public + proxy-resolvable — `config.apiUrl` is the public API
+     *  host for BYOC. Falls back to a well-known public 204 if apiUrl is unusable. */
+    resolveBrowserProxyProbeUrl() {
+        const override = process.env.PRLL_BROWSER_PROXY_PROBE_URL?.trim();
+        if (override)
+            return override;
+        try {
+            return new URL('/generate_204', this.config.apiUrl).toString();
+        }
+        catch {
+            return PUBLIC_PROXY_PROBE_FALLBACK_URL;
+        }
+    }
     // ---- Flat layout migration (self-hosted → daemon) ----
     /**
      * Detects a legacy flat state layout (no agents/ subdir) and migrates it
@@ -913,6 +775,20 @@ export class DaemonSupervisor {
         }
         catch (err) {
             this.log.warn(`browser profile lifecycle failed (profile=${data.profile_id}, action=${data.action}): ${String(err)}`);
+            // Negative-ACK backstop for open/reset failures that never reached the
+            // manager's own error report (pool queue rejection, unsafe id, disposal
+            // failure): without it the server row is stranded at `pending` with no
+            // error_msg and the user sees a silent timeout. The manager-level report
+            // (same status, message may differ) already carries the structured cause
+            // when it fired — a second update is idempotent on status. Deliberately
+            // NOT for `stop`: its desired state is durable and reconcile converges it.
+            if ((data.action === 'open' || data.action === 'reset') && this.running) {
+                await this.client
+                    .reportBrowserProfileStatus(data.profile_id, 'error', err instanceof Error ? err.message : String(err), data.generation)
+                    .catch((reportErr) => {
+                    this.log.warn(`browser profile lifecycle negative ACK failed for ${data.profile_id}: ${String(reportErr)}`);
+                });
+            }
         }
     }
     enqueueBrowserProfileLifecycle(data) {
@@ -946,6 +822,28 @@ export class DaemonSupervisor {
             ? this.enqueueBrowserProfileRevive(data.profile_id, op)
             : this.enqueueBrowserProfileOp(data.profile_id, op);
     }
+    /**
+     * What the supervisor lends the local control plane: identity, pool, queues.
+     * Getters, not values — owner and pool both change over the daemon's life
+     * (bootstrap / refresh / provider state), so the handler must read what is
+     * true AT CALL TIME; a snapshot could authorize against a stale owner.
+     *
+     * One definition, used by both `run()` and the authorization tests, so the
+     * matrix under test is wired exactly like production.
+     */
+    localProfileControlDeps() {
+        return {
+            log: this.log,
+            machineId: () => this.machineId,
+            orgId: () => this.machineOrgId,
+            owner: () => this.machineCreatedBy,
+            pool: () => this.browserProfilePool,
+            listProfiles: () => this.client.listMachineBrowserProfiles(),
+            enqueueRevive: (id, op) => this.enqueueBrowserProfileRevive(id, op),
+            enqueueOp: (id, op) => this.enqueueBrowserProfileOp(id, op),
+            wipeBeforeRevive: (pool, id, resetGen, gen) => this.wipeBeforeRevive(pool, id, resetGen, gen),
+        };
+    }
     enqueueBrowserProfileOp(profileId, op) {
         const previous = this.browserProfileOpQueues.get(profileId) ?? Promise.resolve();
         const next = previous
@@ -1307,6 +1205,11 @@ export class DaemonSupervisor {
     async refreshMachineConfig() {
         try {
             const machine = await this.client.getMachineSelf();
+            // Fail closed, exactly like bootstrap: an absent created_by means the
+            // server no longer proves an owner, so keeping the previous one would let
+            // a revoked user keep driving profiles over the local socket. No owner =>
+            // no local control, until a refresh proves one again.
+            this.machineCreatedBy = machine.created_by ?? null;
             const newSource = machine.llm_source ?? 'parall';
             if (newSource !== this.machineLlmSource) {
                 this.log.info(`machine config refreshed: llm_source ${this.machineLlmSource} → ${newSource}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/daemon",
-  "version": "1.45.0",
+  "version": "1.47.0",
   "description": "Parall local agent runtime — daemon supervisor + bridge runtimes, bundled as standalone JS files",
   "license": "MIT",
   "repository": {
@@ -32,14 +32,16 @@
   "dependencies": {
     "@aws-sdk/client-s3": "3.984.0",
     "@pinixai/bb-browser-pro": "0.15.0",
-    "@parall/agent-core": "1.45.0",
-    "@parall/sdk": "1.45.0",
-    "@parall/codex-agent": "1.45.0",
-    "@parall/claude-agent": "1.45.0",
-    "@parall/openclaw-agent": "1.45.0"
+    "ws": "^8.18.0",
+    "@parall/agent-core": "1.47.0",
+    "@parall/claude-agent": "1.47.0",
+    "@parall/openclaw-agent": "1.47.0",
+    "@parall/sdk": "1.47.0",
+    "@parall/codex-agent": "1.47.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.0",
     "esbuild": "^0.25.0",
     "typescript": "^5.7.0"
   },