@phnx-labs/agents-cli 1.22.38 → 1.22.40

package/dist/commands/daemon.js

@@ -19,15 +19,17 @@ import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { setHelpSections } from '../lib/help.js';
-import { getDaemonStatus, isDaemonRunning, isDaemonWedged, readDaemonLog, startDaemon, stopDaemon, signalDaemonReload, findSurvivingStateDirDaemons, getDaemonLogPath, isDaemonAutostartCircuitOpen, } from '../lib/daemon.js';
+import { getDaemonStatus, isDaemonRunning, isDaemonWedged, readDaemonLog, startDaemon, stopDaemon, signalDaemonReload, findSurvivingStateDirDaemons, getDaemonLogPath, isDaemonAutostartCircuitOpen, } from '../lib/daemon/daemon.js';
 import { getConfigValue, setConfigValue, isDaemonEnabled } from '../lib/device-config.js';
 import { readSubsystemHealth, SUBSYSTEM_SECRETS_BROKER, SUBSYSTEM_BROWSER_IPC, SUBSYSTEM_DAEMON_START, } from '../lib/daemon-health.js';
 import { DAEMON_SERVICE_IDS, listDaemonServiceStates, setDaemonServiceEnabled, getDaemonServicesConfigPath, } from '../lib/daemon-services.js';
-import { listJobs, getLatestRun } from '../lib/routines.js';
+import { listJobs, getLatestRun } from '../lib/scheduling/routines.js';
 import { JobScheduler } from '../lib/scheduler.js';
 import { followFile } from '../lib/log-follow.js';
 import { parseDuration } from '../lib/hooks/cache.js';
 import { registerFunnelCommand } from './funnel.js';
+import { DEFAULT_WEBHOOK_PORT, DEFAULT_WEBHOOK_RATE_LIMIT, addHostedReceiver, getDaemonWebhooksConfigPath, hostedReceiverPort, readDaemonWebhooksConfig, removeHostedReceiver, } from '../lib/daemon-webhooks.js';
+import { parseFunnelPort } from '../lib/funnel.js';
 /**
  * Provably absent, or null when unknowable.
  *
@@ -96,7 +98,7 @@ function entryIsGone(p) {
  *
  * That split is not academic. The incident this feature exists to catch was
  * neither the tracked pid nor in the registry: it ran under an ephemeral `/tmp`
- * cwd from a deleted worktree, and `lib/daemon.ts` documents that such a process
+ * cwd from a deleted worktree, and `lib/daemon/daemon.ts` documents that such a process
  * "registers under its own state dir and is invisible here" BY DESIGN. Gating
  * the display on the registry too would have made this command silent on the
  * exact 4h14m ghost that motivated it.
@@ -624,6 +626,146 @@ async function runDoctor(opts) {
         console.log(`  ${chalk.red('✗')} ${p}`);
     process.exitCode = 1;
 }
+// ─── Hosted webhook receivers ────────────────────────────────────────────
+/** Parse a positive-integer option, failing loud rather than silently defaulting. */
+function requirePositiveInt(raw, label) {
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        console.error(chalk.red(`${label} must be a positive integer (got '${raw}').`));
+        process.exit(1);
+    }
+    return parsed;
+}
+/**
+ * `agents daemon webhooks` — which signed receivers THIS box hosts (RUSH-2548).
+ *
+ * The entries land in `daemon/webhooks.yaml`, which the daemon's
+ * `webhook-receiver` service reads at start; nothing binds until the daemon
+ * picks the change up, so every mutation says how to apply it.
+ */
+function registerWebhooksSubcommand(parent) {
+    const webhooks = parent
+        .command('webhooks')
+        .description('Signed webhook receivers this box hosts as a supervised daemon service.')
+        .option('--json', 'Emit as JSON')
+        .action((opts, command) => {
+        runWebhooksList(command.optsWithGlobals().json === true);
+    });
+    setHelpSections(webhooks, {
+        examples: `
+      # What this box hosts today
+      agents daemon webhooks list
+
+      # Host a receiver on the default port, signing secrets from a bundle
+      agents daemon webhooks add --secrets-bundle linear-webhook
+
+      # A second receiver on its own port, publicly exposed via Tailscale Funnel
+      agents daemon webhooks add --secrets-bundle gh-webhook --port 8788 --funnel-port 443
+
+      # Apply the change (the running daemon rebinds on restart)
+      agents daemon restart
+
+      # Stop hosting the receiver bound to a port
+      agents daemon webhooks remove 8788
+    `,
+        notes: `
+      The bundle must hold GITHUB_WEBHOOK_SECRET and/or LINEAR_WEBHOOK_SECRET
+      ('agents secrets add <bundle> LINEAR_WEBHOOK_SECRET'). The daemon reads it
+      through the secrets broker, so a hosted receiver needs no
+      AGENTS_SECRETS_PASSPHRASE and no nohup. A LOCKED bundle fails that receiver
+      loud in 'agents daemon logs' rather than binding unverified ingress.
+
+      Port is the identity: a second 'add' on the same port edits that receiver.
+      Funnel ports are limited by Tailscale to 443, 8443, and 10000.
+    `,
+    });
+    webhooks
+        .command('list')
+        .description('List the receivers declared for this box.')
+        .option('--json', 'Emit as JSON')
+        .action((opts, command) => {
+        runWebhooksList(command.optsWithGlobals().json === true || opts.json === true);
+    });
+    webhooks
+        .command('add')
+        .description('Declare a receiver on this box. Replaces any receiver already on the same port.')
+        .requiredOption('--secrets-bundle <name>', 'agents secrets bundle holding GITHUB_WEBHOOK_SECRET and/or LINEAR_WEBHOOK_SECRET')
+        .option('-p, --port <n>', `Local bind port (default ${DEFAULT_WEBHOOK_PORT})`)
+        .option('--rate-limit <n>', `Accepted deliveries per source per minute (default ${DEFAULT_WEBHOOK_RATE_LIMIT})`)
+        .option('--funnel-port <n>', 'Expose publicly on this Tailscale Funnel port (443 | 8443 | 10000)')
+        .action((opts) => {
+        const receiver = { bundle: opts.secretsBundle };
+        if (opts.port !== undefined)
+            receiver.port = requirePositiveInt(opts.port, '--port');
+        if (opts.rateLimit !== undefined)
+            receiver.rateLimit = requirePositiveInt(opts.rateLimit, '--rate-limit');
+        if (opts.funnelPort !== undefined) {
+            try {
+                receiver.funnel = { publicPort: parseFunnelPort(opts.funnelPort) };
+            }
+            catch (err) {
+                console.error(chalk.red(err.message));
+                process.exit(1);
+            }
+        }
+        addHostedReceiver(receiver);
+        const port = hostedReceiverPort(receiver);
+        console.log(chalk.green(`Hosting a webhook receiver on 127.0.0.1:${port}`) + chalk.gray(` (bundle ${receiver.bundle})`));
+        if (receiver.funnel)
+            console.log(chalk.gray(`  public: Tailscale Funnel :${receiver.funnel.publicPort} → localhost:${port}`));
+        console.log(chalk.gray(`  config: ${getDaemonWebhooksConfigPath()}`));
+        console.log(chalk.gray(isDaemonRunning()
+            ? '  run `agents daemon restart` to bind it'
+            : '  run `agents daemon start` to bind it'));
+    });
+    webhooks
+        .command('remove <port>')
+        .description('Stop hosting the receiver bound to this port.')
+        .action((portArg) => {
+        const port = requirePositiveInt(portArg, 'port');
+        const removed = removeHostedReceiver(port);
+        if (!removed) {
+            console.error(chalk.red(`No receiver declared on port ${port}. Run 'agents daemon webhooks list'.`));
+            process.exit(1);
+        }
+        console.log(chalk.green(`Removed the webhook receiver on port ${port}.`));
+        if (removed.funnel) {
+            // Leaving the Funnel up would keep a public HTTPS route pointed at a port
+            // nothing serves, so say what to run — this box may not be the tailnet
+            // node, and `funnel down` names the host explicitly.
+            console.log(chalk.yellow(`  public ingress is still up on :${removed.funnel.publicPort} — take it down:`));
+            console.log(chalk.gray(`    agents daemon funnel down <host> --port ${removed.funnel.publicPort}`));
+        }
+        if (isDaemonRunning())
+            console.log(chalk.gray('  run `agents daemon restart` to release the port'));
+    });
+}
+function runWebhooksList(json) {
+    const { receivers } = readDaemonWebhooksConfig();
+    if (json) {
+        console.log(JSON.stringify(receivers.map((r) => ({
+            bundle: r.bundle,
+            port: hostedReceiverPort(r),
+            rateLimit: r.rateLimit ?? DEFAULT_WEBHOOK_RATE_LIMIT,
+            funnelPort: r.funnel?.publicPort ?? null,
+        })), null, 2));
+        return;
+    }
+    if (receivers.length === 0) {
+        console.log(chalk.gray('No webhook receivers declared on this box — the daemon binds nothing.'));
+        console.log(chalk.gray('Add one: agents daemon webhooks add --secrets-bundle <name>'));
+        return;
+    }
+    console.log(chalk.bold('Hosted webhook receivers'));
+    for (const r of receivers) {
+        const port = hostedReceiverPort(r);
+        const funnel = r.funnel ? chalk.cyan(` public :${r.funnel.publicPort}`) : chalk.gray(' localhost only');
+        console.log(`  127.0.0.1:${String(port).padEnd(6)} ${chalk.gray(`bundle ${r.bundle}`)}${funnel}`);
+        console.log(chalk.gray(`    endpoints: /hooks/github, /hooks/linear · ${r.rateLimit ?? DEFAULT_WEBHOOK_RATE_LIMIT}/min per source`));
+    }
+    console.log(chalk.gray(`\nConfig: ${getDaemonWebhooksConfigPath()}`));
+    console.log(chalk.gray('Changes take effect on the next daemon restart.'));
+}
 // ─── Command registration ────────────────────────────────────────────────
 export function registerDaemonCommand(program) {
     const cmd = program
@@ -653,9 +795,13 @@ export function registerDaemonCommand(program) {
       # Reload config (SIGHUP) without restarting — picks up routine/scheduler-gate changes
       agents daemon reload
 
-      # Just the two hosted services (secrets broker, browser IPC)
+      # Every hosted service (secrets broker, browser IPC, webhook receiver, ...)
       agents daemon services
 
+      # Host a signed webhook receiver here, supervised and restarted on crash
+      agents daemon webhooks add --secrets-bundle linear-webhook
+      agents daemon webhooks list
+
       # Manage public ingress for daemon-world webhook receivers
       agents daemon funnel status yosemite-s0
       agents daemon funnel up yosemite-s0 --local-port 8787 --port 443
@@ -829,6 +975,7 @@ export function registerDaemonCommand(program) {
             console.log(chalk.gray('Run `agents daemon reload` (or restart) to apply.'));
         }
     });
+    registerWebhooksSubcommand(cmd);
     registerFunnelCommand(cmd);
     cmd.command('logs')
         .description('Read the daemon\'s own log (lifecycle + subsystem errors — not routine run output).')

package/dist/commands/detach.js

@@ -17,7 +17,7 @@ import chalk from 'chalk';
 import { gatherLiveTargets } from './go.js';
 import { killSession } from '../lib/tmux/index.js';
 import { getDefaultSocketPath } from '../lib/tmux/paths.js';
-import { getAgentsInvocation } from '../lib/daemon.js';
+import { getAgentsInvocation } from '../lib/daemon/daemon.js';
 import { captureProcessStartTime } from '../lib/pty-server.js';
 import { writeDetachRecord } from '../lib/session/detached.js';
 import { getLogsDir } from '../lib/state.js';

package/dist/commands/doctor.js

@@ -15,16 +15,16 @@ import { sshExecAsync } from '../lib/ssh-exec.js';
 import { hostIdentityArgs, sshTargetFor } from '../lib/hosts/types.js';
 import { deviceIdentityArgs } from '../lib/devices/connect.js';
 import { machineId, normalizeHost } from '../lib/session/sync/config.js';
-import { findAmbiguousDevicePins } from '../lib/routines.js';
+import { findAmbiguousDevicePins } from '../lib/scheduling/routines.js';
 import chalk from 'chalk';
 import { checkAllClis, collectTeamsDoctorData } from '../lib/teams/agents.js';
 import { AGENTS, ALL_AGENT_IDS, resolveAgentName, formatAgentError, getAccountInfo } from '../lib/agents.js';
-import { getVersionHomePath, listInstalledVersions, } from '../lib/versions.js';
+import { getVersionHomePath, listInstalledVersions, } from '../lib/installations/versions.js';
 import { resolveAgentTargets, AgentSpecError } from '../lib/agent-spec/index.js';
 import { loadManifest, isStale } from '../lib/staleness/index.js';
 import { diffVersionResources, DOCTOR_ALL_KINDS, } from '../lib/doctor-diff.js';
 import { checkVersionHookWiring, inspectDuplicateVersionHooks, registerHooksToSettings, repairManagedHookRuntimeArtifacts } from '../lib/hooks.js';
-import { isVersionIsolated } from '../lib/versions.js';
+import { isVersionIsolated } from '../lib/installations/versions.js';
 import { computeDrift, checkSyncStatus, countOrphans, computeSourceBehind } from '../lib/drift.js';
 import { readAuthHealthCache, summarizeHostAuth } from '../lib/auth-health.js';
 import { readMeta } from '../lib/state.js';
@@ -156,9 +156,9 @@ export function asRemoteSecretFindings(raw, device) {
     return out;
 }
 async function resolveFleetTargets(opts) {
-    const singleName = opts.host || opts.device;
+    const singleName = opts.device;
     if (singleName) {
-        // --device / --host as a single-device filter: resolve through the device
+        // --device as a single-device filter: resolve through the device
         // registry first, then the general host registry, then ad-hoc user@host.
         const registry = await loadDevices();
         const deviceProfile = registry[singleName];
@@ -358,7 +358,7 @@ export function asFleetInventory(value) {
     return v;
 }
 async function runDevicesDoctor(opts) {
-    const singleName = opts.host || opts.device;
+    const singleName = opts.device;
     const targets = await resolveFleetTargets(opts);
     const localName = machineId();
     const results = [];
@@ -1189,7 +1189,7 @@ function purgeStaleAgentsCliCopies(_opts) {
     });
 }
 function renderStaleInstallPurgeText(purge) {
-    if (purge.removed.length === 0 && purge.failed.length === 0)
+    if (purge.removed.length === 0 && purge.failed.length === 0 && purge.unresolved.length === 0)
         return;
     console.log(chalk.bold('\nStale agents-cli installs'));
     for (const r of purge.removed) {
@@ -1199,6 +1199,15 @@ function renderStaleInstallPurgeText(purge) {
     for (const f of purge.failed) {
         console.log(`  ${chalk.red('hold  ')} ${chalk.gray(`${f.packageRoot}  ${f.version}  — ${f.error}`)}`);
     }
+    // RUSH-2705/2713: a duplicate --fix cannot auto-purge — either a healthy
+    // >=1.22.30 peer, OR a pre-1.22.30 copy left alone only because no fixed peer
+    // exists to fall back to (that one is NOT healthy). Either way, hand back the
+    // command that removes it instead of ending on a bare "everything in sync".
+    // Don't call it "healthy" — that would understate a genuinely vulnerable copy.
+    for (const u of purge.unresolved) {
+        console.log(`  ${chalk.yellow('manual')} ${chalk.gray(`${u.packageRoot}  ${u.version}  — --fix will not delete this copy; remove it with:`)}`);
+        console.log(`         ${chalk.bold(u.manualRemoveCommand)}`);
+    }
 }
 async function runFix(parsed, opts) {
     // Heal targets the global install — project layer is irrelevant, so cwd is
@@ -1437,8 +1446,7 @@ export function registerDoctorCommand(program) {
         .option('--cwd <path>', 'Resolution cwd for project layer detection (default: process.cwd())')
         .option('--adopt <agent>', "Take over the agent's native launcher that shadows the shim (symlink it to the version-managed shim; reversible with --release)")
         .option('--release <agent>', 'Undo --adopt: restore the native launcher agents-cli previously adopted')
-        .option('--devices', 'Check agent readiness AND cross-device harness divergence (missing resources/versions, repo drift) on every registered device (alias --hosts)')
-        .option('--hosts', 'Alias of --devices')
+        .option('--devices', 'Check agent readiness AND cross-device harness divergence (missing resources/versions, repo drift) on every registered device')
         .option('--check', 'CI drift gate: exit non-zero when any installed version is out of sync (stale or never-synced), zero when clean. Combine with --devices to gate the whole fleet.')
         .option('--refresh', 'Bypass the cached overview snapshot: recompute the bare `doctor --json` overview live and refresh the shared cache that the menu-bar and other pollers read')
         .option('-q, --quiet', 'With --check, suppress per-version lines; print only the one-line verdict');
@@ -1492,7 +1500,7 @@ export function registerDoctorCommand(program) {
                 console.error(chalk.red('Cannot combine --check with a target argument.'));
                 process.exit(1);
             }
-            if (opts.devices || opts.hosts) {
+            if (opts.devices) {
                 await runDevicesCheck(opts, cwd);
             }
             else {
@@ -1500,7 +1508,7 @@ export function registerDoctorCommand(program) {
             }
             return;
         }
-        if (opts.devices || opts.hosts) {
+        if (opts.devices) {
             if (target) {
                 console.error(chalk.red('Cannot combine --devices with a target argument.'));
                 process.exit(1);

package/dist/commands/events.js

@@ -14,7 +14,7 @@
  */
 import chalk from 'chalk';
 import * as fs from 'fs';
-import { getLogsPath, stats, rotate } from '../lib/events.js';
+import { getLogsPath, stats, rotate } from '../lib/feed/events.js';
 import { readUnifiedEvents } from '../lib/event-stream.js';
 import { parseFamilyList, EVENT_FAMILIES } from '../lib/event-families.js';
 import { ingestBatch } from '../lib/events-ingest.js';

package/dist/commands/exec.d.ts

@@ -8,7 +8,6 @@
 import { type Command } from 'commander';
 import type { ExecEffort } from '../lib/exec.js';
 import { RUN_AUTO_KEYWORD } from '../lib/types.js';
-import { type SshGResult } from '../lib/hosts/ssh-config.js';
 export interface RunAccountPickerRequest {
     requested: boolean;
     normalizedAgentSpec: string;
@@ -18,8 +17,8 @@ export interface RunAccountPickerRequest {
 export declare function parseRunAccountPickerRequest(agentSpec: string): RunAccountPickerRequest;
 /** Return every option whose routing semantics conflict with a local account choice. */
 /**
- * The `--host` alias family — the flags that mean "dispatch this run to another
- * machine over SSH". `--host` is canonical; `--device`/`--on`/`--computer` are
+ * The `--device` alias family — the flags that mean "dispatch this run to another
+ * machine over SSH". `--device` is canonical; `--on`/`--computer` are hidden
  * aliases. Returns the values actually given (so callers can both test presence
  * and read the target). Kept in ONE place because a guard that listed only a
  * subset silently let `--terminal --device` open a local tab and drop the remote
@@ -68,14 +67,6 @@ export declare function runAutoDefaultsToAffinity(options: {
  * decision matrix is unit-testable.
  */
 export declare function hostInteractiveNeedsCorrelationId(runAgent: string, hostSessionId: string | undefined, resumeId: string | undefined): boolean;
-/** The host descriptor fields the `--copy-creds` security gate reads. */
-export interface CopyCredsGateHost {
-    name: string;
-    /** Concrete SSH target for inline/provider hosts; unset for ssh-config aliases. */
-    address?: string;
-    /** `devices` = registered Tailscale fleet host; `local` = ssh-config/inline. */
-    provider?: string;
-}
 /**
  * Whether `cwd` is inside a git work tree.
  *
@@ -109,45 +100,6 @@ export declare function leaseFreshReposPath(): string;
 export declare function readAlwaysFreshRepos(): string[];
 /** Persist the always-fresh repo roots. Best-effort — never throws. */
 export declare function writeAlwaysFreshRepos(repos: string[]): void;
-/** Outcome of the `--copy-creds` security gate (RUSH-1767). */
-export interface CopyCredsGateDecision {
-    /** Ship credentials? True only when the host key is pinned in the managed store. */
-    allowed: boolean;
-    /** The address whose key is checked/pinned — an ssh-config alias resolved to its real HostName. */
-    pinTarget: string;
-    /** True when the non-device self-pin path pinned the target during this call. */
-    selfPinned: boolean;
-}
-/** Injectable network seams so the gate decision is testable without ssh/keyscan. */
-export interface CopyCredsGateDeps {
-    /** Managed known_hosts store file (defaults to the real cache path). */
-    file?: string;
-    /** Resolve an ssh-config alias to its effective HostName/Port (defaults to real `ssh -G`). */
-    resolve?: (name: string) => SshGResult | undefined;
-    /** Self-pin `target` via ssh-keyscan; returns whether it's pinned afterward (defaults to real `pinHostKey`). */
-    selfPin?: (target: string, port: number | undefined, file: string) => boolean;
-}
-/**
- * Decide whether `--copy-creds` may ship credentials (and the Claude OAuth
- * token) to `host` (RUSH-1767). Credentials ship only to a host whose SSH host
- * key is pinned in the managed known_hosts store, so the offload never rides an
- * accept-new (TOFU) connection a machine-in-the-middle could intercept.
- *
- * Resolution:
- *  - The checked target is the host's concrete `address`, else its ssh-config
- *    HostName (`ssh -G`), else its name — so an alias is pinned/verified against
- *    the SAME real host the strict dispatch later connects to.
- *  - An unpinned NON-device (a bare `~/.ssh/config` `Host` alias or literal,
- *    which `agents ssh <name>` can't reach — "Unknown device") is self-pinned in
- *    place via ssh-keyscan. A registered device is left unpinned here — it earns
- *    its pin through the normal `agents ssh <name>` accept-new connect, so the
- *    caller steers there instead.
- *
- * The network seams (`resolve`, `selfPin`) default to the real ssh -G /
- * ssh-keyscan implementations and are injectable so the ship/refuse decision is
- * unit-testable against real known_hosts fixtures with no network.
- */
-export declare function decideCopyCredsGate(host: CopyCredsGateHost, deps?: CopyCredsGateDeps): CopyCredsGateDecision;
 /**
  * Build the LoopConfig the driver consumes from CLI flags and/or a workflow's
  * `loop:` frontmatter block (issue #332). Returns undefined when neither source