@phnx-labs/agents-cli 1.22.57 → 1.22.59

package/dist/lib/secrets/drivers/rush.js

@@ -26,6 +26,11 @@ function readRushToken() {
     if (!token) {
         throw new Error('No session token in ~/.rush/user.yaml. Run `rush login` first.');
     }
+    const expiresAt = data.session?.expires_at;
+    if (typeof expiresAt === 'number' && expiresAt <= Date.now() / 1000) {
+        const expiredAt = new Date(expiresAt * 1000).toISOString();
+        throw new Error(`Rush session expired at ${expiredAt}. Run \`rush login\` to refresh.`);
+    }
     return token;
 }
 async function api(method, endpoint, body) {

package/dist/lib/secrets/reaper.d.ts

@@ -1,20 +1,14 @@
 /**
  * Reaper for orphaned / wedged keychain-helper processes.
  *
- * macOS keychain-helper calls are synchronous spawnSync invocations. When
- * coreauthd / LocalAuthentication hangs, the helper process (and sometimes its
- * parent `agents` process) can pile up forever. This module detects two classes
- * of stale process and kills them.
- *
- * The design splits cleanly into:
- *   - a pure planner ({@link planKeychainReap}) that is unit-testable without a
- *     real `ps` shell, and
- *   - an impure driver ({@link reapOrphanedKeychainProcesses}) that shells `ps`
- *     once per tick and executes kills through {@link killTree}.
+ * coreauthd / LocalAuthentication hangs can leave helper (and parent `agents`)
+ * processes pile up. The pure planner ({@link planKeychainReap}) is unit-testable
+ * without a real `ps`; the driver ({@link reapOrphanedKeychainProcesses}) shells
+ * `ps` once per tick and kills through {@link killTree}.
  */
-/** Elapsed grace before a helper whose parent exited is considered an orphan. */
+/** Grace before a helper whose parent exited is considered an orphan. */
 export declare const ORPHAN_GRACE_SEC = 30;
-/** Elapsed grace before a helper with a live parent is considered stuck. */
+/** Grace before a helper with a live parent is considered stuck. */
 export declare const STUCK_GRACE_SEC = 90;
 /** Snapshot of one process row from `ps`, fed into the pure planner. */
 export interface KeychainProcessSnapshot {
@@ -22,32 +16,19 @@ export interface KeychainProcessSnapshot {
     ppid: number;
     /** Elapsed seconds since the process started. */
     elapsedSec: number;
-    /**
-     * Stable start-time fingerprint from {@link captureProcessStartTime}.
-     * `null` means "could not capture" — the planner must fail closed.
-     */
+    /** Stable start-time fingerprint from {@link captureProcessStartTime}; null fails closed. */
     startTime: string | null;
-    /**
-     * True when this process is a REAP-ELIGIBLE helper invocation — the installed
-     * helper binary running a short-lived keychain verb. False for a non-helper
-     * process AND for the long-lived `watch-lock` watcher (see
-     * {@link isReapableHelperCommand}).
-     */
+    /** True for a reap-eligible helper invocation (short-lived keychain verb). */
     isHelper: boolean;
     /**
-     * True when this process is the deliberately long-lived `watch-lock` watcher
-     * (auto-lock-on-sleep). Mutually exclusive with {@link isHelper}:
-     * {@link isReapableHelperCommand} keeps live-parent watch-locks out of the
-     * stuck-helper path, and a SEPARATE orphan path in {@link planKeychainReap}
-     * reaps them only once the owning daemon is provably dead (RUSH-2419).
+     * True for the deliberately long-lived `watch-lock` watcher
+     * (auto-lock-on-sleep). Mutually exclusive with {@link isHelper}; killing it
+     * silently disables auto-lock-on-sleep, so it is reaped only once the owning
+     * daemon is provably dead (RUSH-2419).
      */
     isWatchLock?: boolean;
 }
-/**
- * Tracked state for a stuck `agents` parent that has a live helper child.
- * Keyed by parent PID. The two-sweep debounce avoids acting on a racy `ps`
- * snapshot; the `stage` field drives child-first kill then parent escalation.
- */
+/** Tracked state for a stuck parent across two-sweep debounce. */
 export interface StuckParentCandidate {
     pid: number;
     startTime: string | null;
@@ -58,7 +39,7 @@ export interface StuckParentCandidate {
 }
 /** Result of one planning pass. */
 export interface ReapPlan {
-    /** PIDs that should be killed this tick. */
+    /** PIDs to kill this tick. */
     kill: number[];
     /** Candidates to carry forward to the next sweep. */
     nextCandidates: Map<number, StuckParentCandidate>;
@@ -66,51 +47,31 @@ export interface ReapPlan {
 /**
  * Pure predicate: decide which processes to kill given a `ps`-like snapshot.
  *
- * Mirrors the shape of {@link isExpiredPoolStray} in `lib/crabbox/lease.ts`:
- * a side-effect-free classifier that the impure driver shells `ps` for. Three
- * conservative reap classes:
+ * Three conservative classes:
+ *   1. Orphaned helper: PPID == 1, helper path, alive longer than grace.
+ *   2. Stuck `agents` parent: helper child alive longer than stuck grace,
+ *      recorded on first sight, child killed on second sweep, parent on third.
+ *   3. Orphaned `watch-lock`: long-lived watcher whose owning daemon is gone.
  *
- *   1. Orphaned helper: PPID == 1, path-matches the helper, alive longer than
- *      {@link ORPHAN_GRACE_SEC}.
- *   2. Stuck `agents` parent: helper child alive longer than
- *      {@link STUCK_GRACE_SEC}. Recorded on first sight, child killed on the
- *      second consecutive sweep with the same PID + startTime, parent killed on
- *      the third sweep if the helper child is still present.
- *   3. Orphaned `watch-lock` watcher (RUSH-2419): the long-lived auto-lock
- *      child whose owning daemon is provably dead. {@link isReapableHelperCommand}
- *      still excludes live-parent watch-locks from class 1/2; this path only
- *      reaps when the parent is gone from the snapshot (Unix reparents to init
- *      after daemon death) and the watcher itself has a start-time fingerprint.
- *
- * Never reaps a process whose start time could not be captured, whose path does
- * not match the helper, or (for stuck parents) whose parent is no longer in the
- * snapshot. A watch-lock whose parent IS still in the snapshot is never touched.
+ * Fails closed when start time can't be captured.
  */
 export declare function planKeychainReap(snapshots: KeychainProcessSnapshot[], now: number, prevCandidates: ReadonlyMap<number, StuckParentCandidate>): ReapPlan;
 /**
  * Parse macOS `ps -o etime=` elapsed time into whole seconds.
  *
- * BSD `etime` renders as `[[dd-]hh:]mm:ss` (e.g. `05:03`, `01:02:03`,
- * `14-04:10:52`). This is the portable keyword: `etimes` (raw seconds) is a
- * GNU/Linux procps extension that macOS `ps` rejects with a non-zero exit, so
- * the reaper — which only ever runs on darwin — must read `etime`.
- * Returns null for an unparseable value so the caller drops the row.
+ * BSD `etime` renders as `[[dd-]hh:]mm:ss`. `etimes` (raw seconds) is a GNU
+ * extension that macOS `ps` rejects, so darwin uses `etime`.
  */
 export declare function parseEtimeToSeconds(raw: string): number | null;
 /**
- * Whether a `ps` command line is a REAP-ELIGIBLE helper invocation: the installed
- * helper binary running a short-lived keychain verb (get/has/list/set/delete/
- * migrate-*) that a wedged `coreauthd` can hang. Returns false for a non-helper
- * command AND for the deliberately long-lived `watch-lock` watcher — matching by
- * the full argv (`ps … command=`), so a live-parent `watch-lock` child is never
- * mistaken for a stuck read and killed. Pure; unit-tested.
+ * Whether a `ps` command line is a reap-eligible helper invocation: the installed
+ * helper binary running a short-lived keychain verb. Returns false for the
+ * long-lived `watch-lock` watcher, which must never be mistaken for a stuck read.
  */
 export declare function isReapableHelperCommand(command: string, helperPath: string): boolean;
 /**
  * Whether a `ps` command line is the deliberately long-lived `watch-lock`
- * watcher (auto-lock-on-sleep). Inverse of {@link isReapableHelperCommand} for
- * the watch-lock verb only — used by the orphaned-watch-lock reaper path
- * (RUSH-2419). Pure; unit-tested.
+ * watcher. Inverse of {@link isReapableHelperCommand} for the watch-lock verb.
  */
 export declare function isWatchLockHelperCommand(command: string, helperPath: string): boolean;
 /** Test seam: reset the persisted candidate state. */
@@ -119,11 +80,8 @@ export declare function resetKeychainReaperCandidatesForTest(): void;
  * Impure driver: snapshot all processes once with `ps`, plan the reap, then
  * execute kills through {@link killTree}.
  *
- * Path-matching uses the full helper path (proc_pidpath-style), not just the
- * executable name, so an unrelated binary named "Agents CLI" is never targeted.
- *
- * Returns on non-darwin platforms without shelling anything — the helper only
- * exists on macOS.
+ * Path-matches the full helper path so an unrelated binary named "Agents CLI" is
+ * never targeted. Returns on non-darwin without shelling anything.
  */
 export declare function reapOrphanedKeychainProcesses(): {
     reaped: number;

package/dist/lib/secrets/reaper.js

@@ -1,46 +1,28 @@
 /**
  * Reaper for orphaned / wedged keychain-helper processes.
  *
- * macOS keychain-helper calls are synchronous spawnSync invocations. When
- * coreauthd / LocalAuthentication hangs, the helper process (and sometimes its
- * parent `agents` process) can pile up forever. This module detects two classes
- * of stale process and kills them.
- *
- * The design splits cleanly into:
- *   - a pure planner ({@link planKeychainReap}) that is unit-testable without a
- *     real `ps` shell, and
- *   - an impure driver ({@link reapOrphanedKeychainProcesses}) that shells `ps`
- *     once per tick and executes kills through {@link killTree}.
+ * coreauthd / LocalAuthentication hangs can leave helper (and parent `agents`)
+ * processes pile up. The pure planner ({@link planKeychainReap}) is unit-testable
+ * without a real `ps`; the driver ({@link reapOrphanedKeychainProcesses}) shells
+ * `ps` once per tick and kills through {@link killTree}.
  */
 import { execFileSync } from 'child_process';
 import { killTree, captureProcessStartTime } from '../platform/process.js';
 import { getKeychainHelperPath } from './install-helper.js';
-/** Elapsed grace before a helper whose parent exited is considered an orphan. */
+/** Grace before a helper whose parent exited is considered an orphan. */
 export const ORPHAN_GRACE_SEC = 30;
-/** Elapsed grace before a helper with a live parent is considered stuck. */
+/** Grace before a helper with a live parent is considered stuck. */
 export const STUCK_GRACE_SEC = 90;
 /**
  * Pure predicate: decide which processes to kill given a `ps`-like snapshot.
  *
- * Mirrors the shape of {@link isExpiredPoolStray} in `lib/crabbox/lease.ts`:
- * a side-effect-free classifier that the impure driver shells `ps` for. Three
- * conservative reap classes:
- *
- *   1. Orphaned helper: PPID == 1, path-matches the helper, alive longer than
- *      {@link ORPHAN_GRACE_SEC}.
- *   2. Stuck `agents` parent: helper child alive longer than
- *      {@link STUCK_GRACE_SEC}. Recorded on first sight, child killed on the
- *      second consecutive sweep with the same PID + startTime, parent killed on
- *      the third sweep if the helper child is still present.
- *   3. Orphaned `watch-lock` watcher (RUSH-2419): the long-lived auto-lock
- *      child whose owning daemon is provably dead. {@link isReapableHelperCommand}
- *      still excludes live-parent watch-locks from class 1/2; this path only
- *      reaps when the parent is gone from the snapshot (Unix reparents to init
- *      after daemon death) and the watcher itself has a start-time fingerprint.
+ * Three conservative classes:
+ *   1. Orphaned helper: PPID == 1, helper path, alive longer than grace.
+ *   2. Stuck `agents` parent: helper child alive longer than stuck grace,
+ *      recorded on first sight, child killed on second sweep, parent on third.
+ *   3. Orphaned `watch-lock`: long-lived watcher whose owning daemon is gone.
  *
- * Never reaps a process whose start time could not be captured, whose path does
- * not match the helper, or (for stuck parents) whose parent is no longer in the
- * snapshot. A watch-lock whose parent IS still in the snapshot is never touched.
+ * Fails closed when start time can't be captured.
  */
 export function planKeychainReap(snapshots, now, prevCandidates) {
     const pidMap = new Map(snapshots.map((s) => [s.pid, s]));
@@ -50,8 +32,7 @@ export function planKeychainReap(snapshots, now, prevCandidates) {
         if (!s.isHelper)
             continue;
         if (s.ppid === 1) {
-            // Orphaned helper: parent is init/launchd. Fail closed if we can't prove
-            // the process identity with a start-time fingerprint.
+            // Orphaned helper: fail closed without a start-time fingerprint.
             if (s.elapsedSec <= ORPHAN_GRACE_SEC)
                 continue;
             if (s.startTime == null)
@@ -59,8 +40,7 @@ export function planKeychainReap(snapshots, now, prevCandidates) {
             kill.push(s.pid);
             continue;
         }
-        // Stuck agents: a helper with a live parent that has been wedged for longer
-        // than the interactive timeout. The parent must still exist in the snapshot.
+        // Stuck agents: helper with a live parent wedged longer than the timeout.
         if (s.elapsedSec <= STUCK_GRACE_SEC)
             continue;
         const parent = pidMap.get(s.ppid);
@@ -74,13 +54,12 @@ export function planKeychainReap(snapshots, now, prevCandidates) {
             prev.helperStartTime === s.startTime &&
             prev.startTime === parent.startTime) {
             if (prev.stage === 'watch') {
-                // Second sweep: kill the child first so the parent's spawnSync returns.
-                // Keep the parent candidate at stage 'escalate' for the next sweep.
+                // Second sweep: kill the child first so spawnSync returns; escalate next.
                 kill.push(s.pid);
                 nextCandidates.set(parent.pid, { ...prev, stage: 'escalate' });
                 continue;
             }
-            // Third sweep: child did not free the parent, so the parent itself is wedged.
+            // Third sweep: child did not free the parent, so the parent is wedged.
             kill.push(parent.pid);
             continue;
         }
@@ -94,32 +73,21 @@ export function planKeychainReap(snapshots, now, prevCandidates) {
             stage: 'watch',
         });
     }
-    // Separate path for orphaned watch-lock watchers (RUSH-2419). Does NOT
-    // weaken {@link isReapableHelperCommand}: a watch-lock with a live parent
-    // stays isHelper=false and is skipped above. Here we only kill when the
-    // owning daemon is provably absent from the process table.
+    // Separate path for orphaned watch-lock watchers: only reap when the owning
+    // daemon is provably absent from the process table.
     for (const s of snapshots) {
         if (!s.isWatchLock)
             continue;
-        // Fail closed: no start-time fingerprint → refuse to kill (pid-reuse guard
-        // for the process we are about to target, same as orphan helpers).
         if (s.startTime == null)
             continue;
         if (s.elapsedSec <= ORPHAN_GRACE_SEC)
             continue;
-        // Live parent in this snapshot → owning daemon is still up. Leave it alone
-        // (this is the property isReapableHelperCommand protects for stuck-helper
-        // reaping; re-assert it here so a mis-tagged row cannot be killed either).
         if (s.ppid !== 1) {
             const parent = pidMap.get(s.ppid);
             if (parent)
                 continue;
-            // Parent pid not listed: the process occupying that slot is gone. On Unix
-            // a dead parent reparents the child to init; a missing parent with a
-            // non-1 ppid is the race window before reparenting. Either way the owner
-            // is dead — safe to reap after grace + fingerprint.
+            // Parent missing means the owner is dead (or reparenting race); safe to reap.
         }
-        // ppid===1 (reparented to init/launchd) or parent missing → orphaned.
         kill.push(s.pid);
     }
     return { kill, nextCandidates };
@@ -127,11 +95,8 @@ export function planKeychainReap(snapshots, now, prevCandidates) {
 /**
  * Parse macOS `ps -o etime=` elapsed time into whole seconds.
  *
- * BSD `etime` renders as `[[dd-]hh:]mm:ss` (e.g. `05:03`, `01:02:03`,
- * `14-04:10:52`). This is the portable keyword: `etimes` (raw seconds) is a
- * GNU/Linux procps extension that macOS `ps` rejects with a non-zero exit, so
- * the reaper — which only ever runs on darwin — must read `etime`.
- * Returns null for an unparseable value so the caller drops the row.
+ * BSD `etime` renders as `[[dd-]hh:]mm:ss`. `etimes` (raw seconds) is a GNU
+ * extension that macOS `ps` rejects, so darwin uses `etime`.
  */
 export function parseEtimeToSeconds(raw) {
     const m = raw.match(/^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/);
@@ -150,8 +115,6 @@ export function parseEtimeToSeconds(raw) {
  *
  * Expected format from `ps -ax -o pid=,ppid=,etime=,command=`:
  *   "<pid> <ppid> <etime> <command...>"
- * where `<etime>` is BSD elapsed time (`[[dd-]hh:]mm:ss`). The command field is
- * the remainder of the line and may contain spaces.
  */
 function parsePsLine(line) {
     const trimmed = line.trim();
@@ -168,22 +131,12 @@ function parsePsLine(line) {
         return null;
     return { pid, ppid, elapsedSec, command };
 }
-/**
- * The one helper verb that is DELIBERATELY long-lived: the broker's auto-lock
- * sleep/lock watcher (`spawn(getKeychainHelperPath(), ['watch-lock'], …)` in
- * `agent.ts`). It lives for the broker's whole hold — potentially days — as a
- * healthy child of the live broker/daemon, emitting LOCK/SLEEP lines that wipe
- * the in-memory secret store on sleep. It is NOT a stuck keychain read, so the
- * reaper must never target it: killing it silently disables auto-lock-on-sleep.
- */
+/** The one helper verb that is deliberately long-lived: the auto-lock watcher. */
 const HELPER_WATCH_LOCK_VERB = 'watch-lock';
 /**
- * Whether a `ps` command line is a REAP-ELIGIBLE helper invocation: the installed
- * helper binary running a short-lived keychain verb (get/has/list/set/delete/
- * migrate-*) that a wedged `coreauthd` can hang. Returns false for a non-helper
- * command AND for the deliberately long-lived `watch-lock` watcher — matching by
- * the full argv (`ps … command=`), so a live-parent `watch-lock` child is never
- * mistaken for a stuck read and killed. Pure; unit-tested.
+ * Whether a `ps` command line is a reap-eligible helper invocation: the installed
+ * helper binary running a short-lived keychain verb. Returns false for the
+ * long-lived `watch-lock` watcher, which must never be mistaken for a stuck read.
  */
 export function isReapableHelperCommand(command, helperPath) {
     if (command === helperPath)
@@ -195,9 +148,7 @@ export function isReapableHelperCommand(command, helperPath) {
 }
 /**
  * Whether a `ps` command line is the deliberately long-lived `watch-lock`
- * watcher (auto-lock-on-sleep). Inverse of {@link isReapableHelperCommand} for
- * the watch-lock verb only — used by the orphaned-watch-lock reaper path
- * (RUSH-2419). Pure; unit-tested.
+ * watcher. Inverse of {@link isReapableHelperCommand} for the watch-lock verb.
  */
 export function isWatchLockHelperCommand(command, helperPath) {
     if (!command.startsWith(`${helperPath} `))
@@ -215,11 +166,8 @@ export function resetKeychainReaperCandidatesForTest() {
  * Impure driver: snapshot all processes once with `ps`, plan the reap, then
  * execute kills through {@link killTree}.
  *
- * Path-matching uses the full helper path (proc_pidpath-style), not just the
- * executable name, so an unrelated binary named "Agents CLI" is never targeted.
- *
- * Returns on non-darwin platforms without shelling anything — the helper only
- * exists on macOS.
+ * Path-matches the full helper path so an unrelated binary named "Agents CLI" is
+ * never targeted. Returns on non-darwin without shelling anything.
  */
 export function reapOrphanedKeychainProcesses() {
     const details = [];
@@ -249,11 +197,8 @@ export function reapOrphanedKeychainProcesses() {
         if (!parsed)
             continue;
         const { pid, ppid, elapsedSec, command } = parsed;
-        // Reap-eligible = the helper binary running a short-lived keychain verb. The
-        // full-argv match excludes the deliberately long-lived `watch-lock` watcher,
-        // whose live-parent child would otherwise be killed as if it were stuck
-        // (RUSH-2232 — that silently disabled auto-lock-on-sleep). Orphaned
-        // watch-locks are tracked separately via isWatchLock (RUSH-2419).
+        // Match the full argv so the long-lived `watch-lock` watcher is never
+        // mistaken for a stuck read. Orphaned watch-locks are tracked separately.
         const isHelper = isReapableHelperCommand(command, helperPath);
         const isWatchLock = isWatchLockHelperCommand(command, helperPath);
         rows.push({ pid, ppid, elapsedSec, isHelper, isWatchLock, startTime: null });