@phnx-labs/agents-cli 1.22.70 → 1.22.72

package/dist/lib/browser/ipc.d.ts

@@ -3,6 +3,16 @@ import { BrowserService } from './service.js';
 import type { IPCRequest, IPCResponse } from './types.js';
 export interface IPCRequestOptions {
     autoStartDaemon?: boolean;
+    /**
+     * Opt-in client-side deadline in ms — most IPC actions (browser automation,
+     * long-running recordings) have no fixed budget and must NOT get one by
+     * default. Set explicitly for a request that genuinely has one, e.g.
+     * `request-self-update`, whose handler answers immediately (it kicks the
+     * install off in the background — see `triggerSelfUpdateInBackground`), so its
+     * client deadline (`DAEMON_SELF_UPDATE_TRIGGER_TIMEOUT_MS`) is a short
+     * "did the daemon accept the trigger?" bound, not a wait on the install.
+     */
+    timeoutMs?: number;
 }
 export declare class BrowserServiceNotRunningError extends Error {
     constructor();
@@ -148,6 +158,23 @@ export declare class BrowserIPCServer {
  * owns the shared process.
  */
 export declare function shouldRecommendDaemonRefresh(daemonVersion: string | undefined, clientVersion: string): boolean;
+/**
+ * Reconcile the running daemon's version with ours without evicting it. If the
+ * daemon is serving stale code, ask the daemon to run its OWN self-update path
+ * (`request-self-update`, same fail-closed check/install/verify/exit
+ * SelfUpdateService's periodic tick runs, self-update-service.ts) rather than
+ * telling a human to run `agents daemon restart` by hand. A browser client
+ * still owns neither the shared supervisor nor its sibling services, so
+ * version skew can never be permission for THIS client to stop or restart
+ * that process directly (PHNX-3605 holds) — it only asks the daemon to run a
+ * path the daemon already runs on its own schedule, which only exits once the
+ * daemon itself has verified the new version is good. If self-update declines
+ * (dev build, shadowed install, already current, or a real failure) this
+ * degrades to the same "nothing changed" outcome PHNX-3605 shipped.
+ */
+export declare function reconcileDaemonVersion(): Promise<void>;
+/** Test-only: `reconcileDaemonVersion` runs at most once per real process — this clears that latch so a test file can drive more than one branch. */
+export declare function resetVersionReconciliationForTest(): void;
 export declare function sendIPCRequest(request: IPCRequest, opts?: IPCRequestOptions): Promise<IPCResponse>;
 /**
  * Fill actor / launchId / sessionId from the calling process when the request
@@ -160,3 +187,10 @@ export declare function stampCallerIdentity(request: IPCRequest, env?: NodeJS.Pr
  * only the client process and IPC socket lifetime differ.
  */
 export declare function connectBrowserIPC(opts?: IPCRequestOptions): Promise<BrowserIPCConnection>;
+/**
+ * Exported (rather than kept module-private) so `ipc.test.ts` can drive the
+ * `opts.timeoutMs` client-side deadline directly against a raw `net.Server`
+ * test double that never responds — the hermetic way to prove the timeout
+ * actually fires without needing a slow real IPC action to provoke it.
+ */
+export declare function sendRawIPCRequest(request: IPCRequest, opts?: IPCRequestOptions): Promise<IPCResponse>;

package/dist/lib/browser/ipc.js

@@ -7,6 +7,8 @@ import { resolveBrowserTaskIdleMs } from '../device-config.js';
 import { getDaemonLogPath, isDaemonRunning, signalDaemonReload, startDaemon, } from '../daemon/daemon.js';
 import { getCliVersion } from '../version.js';
 import { compareVersions } from '../agent-spec/primitives.js';
+import { scheduleSelfUpdateExit, selfUpdateSyncDeclineReason, triggerSelfUpdateInBackground } from '../daemon/self-update-service.js';
+import { log as daemonLog } from '../daemon/daemon.js';
 import { isDaemonServiceEnabled, queueDaemonServiceRestart, setDaemonServiceEnabled, } from '../daemon-services.js';
 import { isFleetRemoteInvocation } from './remote-control.js';
 import { resolveCallerIdentity } from './caller-identity.js';
@@ -82,6 +84,17 @@ function isSameSocket(socketPath, expected) {
  * coming near the grace window.
  */
 const IPC_CLOSE_TIMEOUT_MS = 1_500;
+/**
+ * Client-side ceiling on the on-demand `request-self-update` call inside
+ * {@link reconcileDaemonVersion}. The daemon handler is DECOUPLED from the
+ * install — it kicks the self-update off in the background and answers
+ * immediately — so this only needs to be long enough to confirm the daemon
+ * ACCEPTED the trigger, never long enough to wait out a check/install/verify.
+ * It must stay short because a version-skewed browser verb routes through this
+ * reconcile on its way to the real request; a wedged or gone daemon degrades to
+ * the advisory PHNX-3605 shipped rather than stalling the verb.
+ */
+const DAEMON_SELF_UPDATE_TRIGGER_TIMEOUT_MS = 5_000;
 /**
  * How long {@link waitForBrowserService} waits for the browser service to come up before
  * failing loud (PHNX-3289).
@@ -655,6 +668,44 @@ export class BrowserIPCServer {
             case 'version': {
                 return { ok: true, version: getCliVersion() };
             }
+            // On-demand self-update, triggered by a client that noticed version
+            // skew (reconcileDaemonVersion below). DECOUPLED from the install
+            // (PHNX-3605): this handler MUST NOT await the check→download→install→
+            // verify, because it sits on the path of EVERY version-skewed
+            // `agents browser <verb>` (reconcileDaemonVersion → prepareIPC → here), so
+            // awaiting the whole thing would synchronously stall an ordinary browser
+            // verb for tens of seconds — worst case ~15 min — behind daemon
+            // housekeeping, exactly the client-stall PHNX-3605 exists to prevent.
+            // Instead: kick the self-update off in the BACKGROUND (bounded, and
+            // sharing the module-level in-flight guard so two triggers can't race a
+            // second install) and respond IMMEDIATELY that it was accepted. The daemon
+            // does install→verify→exit(0) on its own; the OS supervisor relaunches it
+            // and the browser reconnects. scheduleSelfUpdateExit (fired from the
+            // background continuation on a verified update) still delays the exit so
+            // this response has flushed to the socket first, and serializes against
+            // the periodic tick's own exit.
+            case 'request-self-update': {
+                // Instant, network-free decline gate FIRST (dev build / shadowed
+                // install), so a version-skewed browser client gets the PHNX-3605
+                // "nothing changed, not evicting" advisory immediately rather than a
+                // "triggered" it would never act on — reconcileDaemonVersion keys the
+                // advisory on !selfUpdateTriggered. Only a genuinely-eligible install is
+                // backgrounded below; the slow registry/download/install/verify never
+                // runs on this response path.
+                const declineReason = selfUpdateSyncDeclineReason();
+                if (declineReason) {
+                    return { ok: true, selfUpdateTriggered: false, reason: declineReason };
+                }
+                void triggerSelfUpdateInBackground({ log: daemonLog })
+                    .then((outcome) => {
+                    if (outcome.updated)
+                        scheduleSelfUpdateExit();
+                })
+                    .catch((err) => {
+                    daemonLog('ERROR', `self-update: background trigger failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                return { ok: true, selfUpdateTriggered: true };
+            }
             case 'show': {
                 // Task-less by design — see BrowserService.showUrl. Absent from both
                 // PAGE_CREATE_VERBS and PAGE_RESOLVE_VERBS, so bindTask never ran above
@@ -707,7 +758,7 @@ export class BrowserIPCServer {
                 // this box's own configured default (or 30 minutes when unset).
                 const idleMs = request.idleMinutes !== undefined
                     ? (request.idleMinutes === 0 ? null : request.idleMinutes * 60_000)
-                    : resolveBrowserTaskIdleMs();
+                    : await resolveBrowserTaskIdleMs();
                 const reaped = await this.service.reapAbandoned({ idleMs, dryRun: request.dryRun });
                 return { ok: true, reaped };
             }
@@ -1077,12 +1128,19 @@ export function shouldRecommendDaemonRefresh(daemonVersion, clientVersion) {
 }
 /**
  * Reconcile the running daemon's version with ours without evicting it. If the
- * daemon is serving stale code, surface the deliberate operator command once
- * and continue on the already-running service. A browser client owns neither
- * the shared supervisor nor its sibling services, so version skew can never be
- * permission to stop or restart that process (PHNX-3605).
+ * daemon is serving stale code, ask the daemon to run its OWN self-update path
+ * (`request-self-update`, same fail-closed check/install/verify/exit
+ * SelfUpdateService's periodic tick runs, self-update-service.ts) rather than
+ * telling a human to run `agents daemon restart` by hand. A browser client
+ * still owns neither the shared supervisor nor its sibling services, so
+ * version skew can never be permission for THIS client to stop or restart
+ * that process directly (PHNX-3605 holds) — it only asks the daemon to run a
+ * path the daemon already runs on its own schedule, which only exits once the
+ * daemon itself has verified the new version is good. If self-update declines
+ * (dev build, shadowed install, already current, or a real failure) this
+ * degrades to the same "nothing changed" outcome PHNX-3605 shipped.
  */
-async function reconcileDaemonVersion() {
+export async function reconcileDaemonVersion() {
     if (versionReconciledThisProcess)
         return;
     versionReconciledThisProcess = true;
@@ -1099,8 +1157,41 @@ async function reconcileDaemonVersion() {
     if (!shouldRecommendDaemonRefresh(daemon, client))
         return;
     process.stderr.write(`\nBrowser service is running on shared daemon ${daemon}, while this CLI is ${client}. `
-        + 'Continuing without evicting the daemon or its other services.\n'
-        + 'To load current daemon code when it is safe to interrupt every hosted service: agents daemon restart\n\n');
+        + 'Asking the daemon to self-update in the background (verify-then-exit; the OS supervisor relaunches it onto the new code)...\n');
+    try {
+        // SHORT timeout — the handler is decoupled from the install now (it kicks
+        // the self-update off in the background and answers at once), so this only
+        // waits for the daemon to CONFIRM it accepted the trigger, not for the
+        // install to finish. It must stay short so the real browser verb that
+        // triggered this reconcile proceeds promptly; a wedged/gone daemon degrades
+        // to the same advisory PHNX-3605 shipped.
+        const resp = await sendRawIPCRequest({ action: 'request-self-update' }, { autoStartDaemon: false, timeoutMs: DAEMON_SELF_UPDATE_TRIGGER_TIMEOUT_MS });
+        if (resp.selfUpdateTriggered) {
+            process.stderr.write('Daemon self-update requested — it verifies a newer version in the background and restarts if one is available. '
+                + 'Continuing without waiting.\n\n');
+        }
+        else {
+            // Two shapes reach here: a CURRENT daemon that ran the instant decline
+            // gate (dev build / shadowed install) and answered {selfUpdateTriggered:
+            // false, reason}, and an OLDER daemon that predates the field entirely and
+            // answered without it (no reason). Both degrade to the same non-evicting
+            // advisory PHNX-3605 shipped; only the lead sentence differs.
+            const declineDetail = resp.reason
+                ? `Daemon self-update declined (${resp.reason}). `
+                : 'Daemon did not accept the self-update request. ';
+            process.stderr.write(declineDetail
+                + 'Continuing without evicting the daemon or its other services. '
+                + 'To load current daemon code when it is safe to interrupt every hosted service: agents daemon restart\n\n');
+        }
+    }
+    catch (err) {
+        process.stderr.write(`Could not reach the daemon to request a self-update (${err instanceof Error ? err.message : String(err)}). `
+            + 'To load current daemon code when it is safe to interrupt every hosted service: agents daemon restart\n\n');
+    }
+}
+/** Test-only: `reconcileDaemonVersion` runs at most once per real process — this clears that latch so a test file can drive more than one branch. */
+export function resetVersionReconciliationForTest() {
+    versionReconciledThisProcess = false;
 }
 export async function sendIPCRequest(request, opts = {}) {
     // Stamp caller identity ONCE here so the 28+ call sites don't each have to.
@@ -1155,13 +1246,37 @@ export async function connectBrowserIPC(opts = {}) {
         });
     });
 }
-async function sendRawIPCRequest(request, opts = {}) {
+/**
+ * Exported (rather than kept module-private) so `ipc.test.ts` can drive the
+ * `opts.timeoutMs` client-side deadline directly against a raw `net.Server`
+ * test double that never responds — the hermetic way to prove the timeout
+ * actually fires without needing a slow real IPC action to provoke it.
+ */
+export async function sendRawIPCRequest(request, opts = {}) {
     const endpoint = getIpcEndpoint();
     const autoStartDaemon = opts.autoStartDaemon ?? true;
     await prepareIPC(request.action, opts);
     return new Promise((resolve, reject) => {
         const socket = net.createConnection(endpoint);
         let buffer = '';
+        let settled = false;
+        let deadline;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            if (deadline)
+                clearTimeout(deadline);
+            fn();
+        };
+        if (opts.timeoutMs) {
+            deadline = setTimeout(() => {
+                settle(() => {
+                    socket.destroy();
+                    reject(new Error(`IPC request '${request.action}' timed out after ${opts.timeoutMs}ms`));
+                });
+            }, opts.timeoutMs);
+        }
         socket.on('connect', () => {
             socket.write(JSON.stringify(request) + '\n');
         });
@@ -1170,21 +1285,27 @@ async function sendRawIPCRequest(request, opts = {}) {
             const idx = buffer.indexOf('\n');
             if (idx !== -1) {
                 const response = JSON.parse(buffer.slice(0, idx));
-                socket.end();
-                resolve(response);
+                settle(() => {
+                    socket.end();
+                    resolve(response);
+                });
             }
         });
         socket.on('error', (err) => {
-            if (!autoStartDaemon && (err.code === 'ENOENT' || err.code === 'ECONNREFUSED')) {
-                reject(new BrowserServiceNotRunningError());
-                return;
-            }
-            reject(new Error(`IPC error: ${err.message}`));
+            settle(() => {
+                if (!autoStartDaemon && (err.code === 'ENOENT' || err.code === 'ECONNREFUSED')) {
+                    reject(new BrowserServiceNotRunningError());
+                    return;
+                }
+                reject(new Error(`IPC error: ${err.message}`));
+            });
         });
         socket.on('close', () => {
-            if (!buffer.includes('\n')) {
-                reject(new Error('Connection closed before response'));
-            }
+            settle(() => {
+                if (!buffer.includes('\n')) {
+                    reject(new Error('Connection closed before response'));
+                }
+            });
         });
     });
 }

package/dist/lib/browser/types.d.ts

@@ -287,7 +287,7 @@ export interface ReapResult {
     /** Tasks left alone this pass: still live, still inside the idle window, or recording. */
     skipped: number;
 }
-export type IPCAction = 'start' | 'show' | 'gc' | 'record-start' | 'record-stop' | 'done' | 'stop' | 'status' | 'history' | 'navigate' | 'tab-add' | 'tab-focus' | 'tab-close' | 'tab-list' | 'evaluate' | 'screenshot' | 'pdf' | 'refs' | 'click' | 'type' | 'press' | 'hover' | 'scroll' | 'set-viewport' | 'set-device' | 'console' | 'errors' | 'requests' | 'response-body' | 'wait' | 'set-download-path' | 'wait-download' | 'upload' | 'getAppLogs' | 'version';
+export type IPCAction = 'start' | 'show' | 'gc' | 'record-start' | 'record-stop' | 'done' | 'stop' | 'status' | 'history' | 'navigate' | 'tab-add' | 'tab-focus' | 'tab-close' | 'tab-list' | 'evaluate' | 'screenshot' | 'pdf' | 'refs' | 'click' | 'type' | 'press' | 'hover' | 'scroll' | 'set-viewport' | 'set-device' | 'console' | 'errors' | 'requests' | 'response-body' | 'wait' | 'set-download-path' | 'wait-download' | 'upload' | 'getAppLogs' | 'version' | 'request-self-update';
 export interface IPCRequest {
     action: IPCAction;
     task?: string;
@@ -425,6 +425,8 @@ export interface IPCResponse {
     uploadMode?: 'input' | 'drop' | 'chooser';
     appLogs?: any[];
     version?: string;
+    selfUpdateTriggered?: boolean;
+    reason?: string;
     skill?: {
         name: string;
         path: string;

package/dist/lib/daemon/auth-sync-service.js

@@ -23,7 +23,7 @@ export class AuthSyncService extends BasePeriodicService {
     }
     async onTick(ctx) {
         const { publishReservedAuthVerdict, syncReservedAuthBundle } = await import('../secrets/reserved-sync.js');
-        const published = publishReservedAuthVerdict();
+        const published = await publishReservedAuthVerdict();
         if (published.error)
             ctx.log('WARN', `auth-sync: verdict: ${published.error}`);
         const { syncFleetSharedStateRepo } = await import('../fleet-shared-repo-sync.js');

package/dist/lib/daemon/browser-task-reap-service.js

@@ -15,7 +15,7 @@ export class BrowserTaskReapService extends BasePeriodicService {
     async onStart(_ctx) { }
     async onStop() { }
     async onTick(ctx) {
-        const result = await this.browserService.reapAbandoned({ idleMs: resolveBrowserTaskIdleMs() });
+        const result = await this.browserService.reapAbandoned({ idleMs: await resolveBrowserTaskIdleMs() });
         if (result.closed.length > 0) {
             ctx.log('INFO', `Browser-task reaper: closed ${result.closed.length} task(s)`);
             for (const closed of result.closed) {

package/dist/lib/daemon/daemon.js

@@ -40,6 +40,7 @@ import { BrowserIPCService } from './browser-ipc-service.js';
 import { WatchdogService } from './watchdog-service.js';
 import { DeviceProbeService } from './device-probe-service.js';
 import { SelfHealService } from './self-heal-service.js';
+import { SelfUpdateService } from './self-update-service.js';
 import { KeychainReapService } from './keychain-reap-service.js';
 import { AuthSyncService } from './auth-sync-service.js';
 import { UsageSyncService } from './usage-sync-service.js';
@@ -49,7 +50,7 @@ import { WebhookReceiverService } from './webhook-receiver-service.js';
 import { HeartbeatService } from './heartbeat-service.js';
 import { TmuxReapService } from './tmux-reap-service.js';
 import { BrowserTaskReapService } from './browser-task-reap-service.js';
-import { emit, emitRoutineEnd } from '../feed/events.js';
+import { emit, emitAsync, emitRoutineEnd } from '../feed/events.js';
 import { readDaemonServicesConfig, drainDaemonServiceRestartQueue } from '../daemon-services.js';
 import { sleepSync } from '../fs-atomic.js';
 /**
@@ -749,11 +750,16 @@ export function log(level, message) {
             : lvl === 'START' || /starting|started/i.test(message) ? 'daemon.start'
                 : lvl === 'STOP' || /stopping|stopped|shutting down/i.test(message) ? 'daemon.stop'
                     : 'daemon.info';
-        emit(event, {
+        // Fire-and-forget the event mirror: `log()` is a synchronous primitive on
+        // every daemon tick's `ctx.log`, and the mirror's event-log lock would
+        // otherwise block the shared event loop for up to 30s under contention
+        // (PHNX-3695). The daemon-log append above is the primary, synchronous sink;
+        // the mirror is best-effort, so a fire-and-forget async write is correct.
+        void emitAsync(event, {
             module: 'daemon',
             detail: redactSecrets(message).slice(0, 500),
             status: lvl,
-        });
+        }).catch(() => { });
     }
     catch { /* never crash the daemon on event-log failure */ }
 }
@@ -1073,6 +1079,10 @@ export async function runDaemon() {
         supervisor.register(new SelfHealService());
     else
         log('INFO', 'Self-heal service disabled');
+    if (isEnabled('self-update'))
+        supervisor.register(new SelfUpdateService());
+    else
+        log('INFO', 'Self-update service disabled');
     if (isEnabled('keychain-reap'))
         supervisor.register(new KeychainReapService());
     else

package/dist/lib/daemon/heartbeat-service.js

@@ -1,5 +1,5 @@
 /** Daemon heartbeat and routine-process reconciliation under supervision. */
-import { monitorRunningJobs } from './runner.js';
+import { reapExitedRunningJobs } from './runner.js';
 import { reapTerminalRoutineProcesses } from '../routine-process-cleanup.js';
 import { BasePeriodicService } from './service.js';
 const HEARTBEAT_TICK_MS = 60_000;
@@ -17,8 +17,8 @@ export class HeartbeatService extends BasePeriodicService {
     async onStop() { }
     async onTick(ctx) {
         this.publishHeartbeat();
-        monitorRunningJobs();
-        const reaped = reapTerminalRoutineProcesses();
+        await reapExitedRunningJobs();
+        const reaped = await reapTerminalRoutineProcesses();
         if (reaped.length > 0) {
             ctx.log('WARN', `Reaped ${reaped.length} terminal routine process group(s): ${reaped.join(', ')}`);
         }

package/dist/lib/daemon/keychain-reap-service.js

@@ -22,7 +22,7 @@ export class KeychainReapService extends BasePeriodicService {
     }
     async onTick(ctx) {
         const { reapOrphanedKeychainProcesses } = await import('../secrets/reaper.js');
-        const result = reapOrphanedKeychainProcesses();
+        const result = await reapOrphanedKeychainProcesses();
         if (result.reaped > 0) {
             ctx.log('WARN', `Reaped ${result.reaped} keychain orphan/stuck process(es)`);
             for (const d of result.details)

package/dist/lib/daemon/runner.d.ts

@@ -251,6 +251,23 @@ export declare function listLiveRoutineChildren(): number[];
  *   remote `.exit` is reconciled (`finalizeHostRun`).
  */
 export declare function isRunGenuinelyInFlight(meta: RunMeta): boolean;
-/** Scan all runs marked "running" and finalize any whose process has exited. */
+/**
+ * Scan all runs marked "running" and finalize any whose process has exited.
+ *
+ * SYNCHRONOUS — for OFF-loop callers only (the `agents routines list/status`
+ * builders and CLI best-effort orphan reaps), which run in short-lived CLI
+ * processes where a bounded synchronous `ps`/scan cannot starve a served event
+ * loop. The daemon's own heartbeat tick MUST use {@link reapExitedRunningJobs}
+ * instead — a sync scan there would freeze the shared event loop (PHNX-3695).
+ */
 export declare function monitorRunningJobs(): void;
+/**
+ * Async, non-blocking twin of {@link monitorRunningJobs} for the daemon's
+ * heartbeat tick (PHNX-3695). Identical reconciliation via
+ * {@link reconcileRunningRecord}, but the directory walk uses `fs/promises` and
+ * the pid-identity probe uses the deadline-bounded {@link isPidOursAsync}, so
+ * the every-tick scan never freezes the shared event loop — the freeze that
+ * left the browser IPC `version` probe unanswered.
+ */
+export declare function reapExitedRunningJobs(): Promise<void>;
 export {};