@phnx-labs/agents-cli 1.20.78 → 1.20.83

package/dist/commands/repo.js

@@ -36,11 +36,13 @@ import { refresh } from '../lib/refresh.js';
 import { capableAgents } from '../lib/capabilities.js';
 import { getGlobalDefault, getVersionHomePath, listInstalledVersions } from '../lib/versions.js';
 import { syncAllMarketplaces } from '../lib/plugin-marketplace.js';
+import { gatherRemoteAgentsJson } from '../lib/remote-agents-json.js';
+import { machineId, normalizeHost } from '../lib/machine-id.js';
 /**
  * After a repo add/remove/enable/disable, reconcile each plugins-capable
  * agent's default version against the new marketplace set. Re-synthesizes
  * catalogs and known_marketplaces.json entries. Source-copy of plugins is
- * out of scope here — full sync still goes through `agents repo refresh`.
+ * out of scope here — full sync still goes through `agents sync`.
  */
 function syncMarketplacesForDefaults() {
     for (const agent of capableAgents('plugins')) {
@@ -432,13 +434,161 @@ function renderCards(rows, cols) {
         }
     }
 }
+/**
+ * Recursion guard for the fleet fan-out, passed as an env var (not a CLI flag)
+ * so an OLDER remote `agents` that predates this feature ignores it harmlessly
+ * instead of erroring on an unknown option. A peer new enough to fan out reads
+ * it and answers only for itself. Mirrors `NO_FANOUT_ENV` in remote-active.ts.
+ */
+export const NO_REPO_FANOUT_ENV = 'AGENTS_REPO_LOCAL';
+/**
+ * Parse one peer's `repo status --json` stdout (a RepoRow[]) into a single
+ * device entry tagged with `machine`. Defensive against version skew: non-JSON
+ * or a non-array yields no entry, and non-object rows are dropped rather than
+ * throwing. Exported for unit testing without a live tailnet.
+ */
+export function parseRemoteRepoRows(stdout, machine) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const rows = parsed.filter((x) => !!x && typeof x === 'object' && !Array.isArray(x));
+    return [{ device: machine, reachable: true, rows }];
+}
+/**
+ * Query repo status on the fleet. With an explicit `hosts` list, fan out to
+ * exactly those; otherwise sweep every registered, online peer (excluding this
+ * machine). Each peer runs `repo status [alias] --json` locally — never its own
+ * fan-out — and unreachable peers are skipped with a gray note, never fatal.
+ */
+async function gatherRemoteRepoStatus(alias, hosts) {
+    const args = ['repo', 'status', ...(alias ? [alias] : []), '--json'];
+    const { items } = await gatherRemoteAgentsJson({
+        args,
+        noFanoutEnv: NO_REPO_FANOUT_ENV,
+        hosts,
+        parse: parseRemoteRepoRows,
+    });
+    return items;
+}
+/**
+ * Render the fleet repo-status table: one row per (device, repo), with the
+ * device name shown once per group. SYNC and CHANGES reuse the same compact
+ * cells as the local wide table (`↓N (…)  ↑N` / `clean` / `~N edits`), and an
+ * unreachable device collapses to a single `unreachable` marker row. Pure — no
+ * I/O — so the aggregation/formatting is unit-testable without live devices.
+ */
+export function renderDeviceStatusRows(results) {
+    const cells = [];
+    for (const r of results) {
+        if (!r.reachable || !r.rows) {
+            cells.push({ device: r.device, repo: chalk.gray('unreachable'), sync: '', changes: '' });
+            continue;
+        }
+        if (r.rows.length === 0) {
+            cells.push({ device: r.device, repo: chalk.gray('no repos'), sync: '', changes: '' });
+            continue;
+        }
+        let firstOfDevice = true;
+        for (const row of r.rows) {
+            const device = firstOfDevice ? r.device : '';
+            firstOfDevice = false;
+            if (row.raw) {
+                // missing / no-git-remote / error — the free-form trailer says it all.
+                cells.push({ device, repo: row.alias, sync: row.raw, changes: '' });
+            }
+            else {
+                cells.push({ device, repo: row.alias, sync: syncCompact(row), changes: changesCompact(row) });
+            }
+        }
+    }
+    if (cells.length === 0)
+        return [];
+    const headers = ['DEVICE', 'REPO', 'SYNC', 'CHANGES'];
+    const devW = Math.max(headers[0].length, ...cells.map((c) => visibleWidth(c.device)));
+    const repoW = Math.max(headers[1].length, ...cells.map((c) => visibleWidth(c.repo)));
+    const syncW = Math.max(headers[2].length, ...cells.map((c) => visibleWidth(c.sync)));
+    const lines = [];
+    lines.push(`  ${chalk.gray(headers[0].padEnd(devW))}  ${chalk.gray(headers[1].padEnd(repoW))}  ${chalk.gray(headers[2].padEnd(syncW))}  ${chalk.gray(headers[3])}`);
+    for (const c of cells) {
+        lines.push(`  ${chalk.cyan(padVisible(c.device, devW))}  ${padVisible(c.repo, repoW)}  ${padVisible(c.sync, syncW)}  ${c.changes}`);
+    }
+    return lines;
+}
+/**
+ * Read the device-scope flags into an intent, or null for the default local-only
+ * run. `--devices-all`/`--hosts-all` (and `--devices all`/`--hosts all`) sweep
+ * every reachable peer; `--devices box1,box2` targets an explicit list. A peer
+ * carrying {@link NO_REPO_FANOUT_ENV} never fans out again (recursion guard).
+ */
+export function resolveDeviceIntent(opts) {
+    if (process.env[NO_REPO_FANOUT_ENV] === '1')
+        return null;
+    if (opts.devicesAll || opts.hostsAll)
+        return { all: true };
+    const val = opts.devices ?? opts.hosts;
+    if (val === undefined)
+        return null;
+    const v = val.trim();
+    if (v === '' || v.toLowerCase() === 'all')
+        return { all: true };
+    const hosts = v.split(',').map((s) => s.trim()).filter(Boolean);
+    return hosts.length ? { hosts } : { all: true };
+}
+/**
+ * `repo status`/`list` across the fleet: read THIS machine's rows locally, fan
+ * out to peers, and render one aggregated table (device · repo · sync · changes).
+ * The local box is always shown first; unreachable peers were already noted by
+ * the fan-out and are simply absent from the table.
+ */
+async function listReposAcrossDevices(alias, opts, intent) {
+    const localTargets = collectRepoTargets(alias);
+    if (!localTargets) {
+        process.exitCode = 1;
+        return;
+    }
+    const localRows = await Promise.all(localTargets.map(renderRepoRow));
+    const self = machineId();
+    const hosts = 'hosts' in intent ? intent.hosts : undefined;
+    const remote = (await gatherRemoteRepoStatus(alias, hosts))
+        // An explicit host list may name this box; the local rows already cover it.
+        .filter((r) => normalizeHost(r.device) !== self);
+    const combined = [
+        { device: self, reachable: true, rows: localRows },
+        ...remote,
+    ];
+    if (opts.json) {
+        const clean = combined.map((r) => ({
+            device: r.device,
+            reachable: r.reachable,
+            rows: (r.rows ?? []).map((row) => row.raw !== undefined ? { ...row, raw: stripAnsi(row.raw) } : row),
+        }));
+        console.log(JSON.stringify(clean, null, 2));
+        return;
+    }
+    console.log('');
+    for (const line of renderDeviceStatusRows(combined))
+        console.log(line);
+    console.log('');
+}
 /**
  * Shared action body for `agents repo list` and the hidden `agents repo status`
  * alias. Responsive: a wide terminal gets an aligned table with compact SYNC /
  * CHANGES cells; a narrow one gets one card per repo with wrapping detail;
- * `--verbose` forces the full-detail table at any width.
+ * `--verbose` forces the full-detail table at any width. A device-scope flag
+ * (`--devices-all` / `--devices <list>`) instead fans out across the fleet.
  */
 async function listRepos(alias, opts = {}) {
+    const intent = resolveDeviceIntent(opts);
+    if (intent) {
+        await listReposAcrossDevices(alias, opts, intent);
+        return;
+    }
     const targets = collectRepoTargets(alias);
     if (!targets) {
         process.exitCode = 1;
@@ -487,6 +637,20 @@ function formatRepoTarget(alias, dir, branch) {
     const ref = branch ? `origin/${branch}` : 'origin';
     return `${alias} (${displayHomePath(dir)} → ${ref})`;
 }
+/**
+ * Register the fleet device-scope flags shared by `repo list` / `repo status`.
+ * `--devices-all` (alias `--hosts-all`) sweeps every reachable device;
+ * `--devices <who>` (alias `--hosts`) takes `all` or a comma-separated list.
+ * A single `--host`/`--device` is handled upstream by maybeRunOnHost, which
+ * streams that one box's `agents repo status` — these are the aggregating forms.
+ */
+function addDeviceStatusOptions(cmd) {
+    return cmd
+        .option('--devices-all', 'Report repo sync state across ALL reachable fleet devices (alias: --hosts-all).')
+        .option('--hosts-all', 'Alias of --devices-all.')
+        .option('--devices <who>', 'Fleet devices to report on: "all", or a comma-separated device list (alias: --hosts).')
+        .option('--hosts <who>', 'Alias of --devices.');
+}
 /** Register the `agents repos` command tree (`repo` is a convenience alias). */
 export function registerRepoCommands(program) {
     // addHostOption on the group so --help documents --host/--device; remote
@@ -512,6 +676,9 @@ export function registerRepoCommands(program) {
       # See what's registered
       agents repos list
 
+      # Report repo sync state across the whole fleet (one box: --device <name>)
+      agents repos status --devices-all
+
       # View one repo's contents (git state + resource counts); omit the name for a picker
       agents repos view system
 
@@ -714,13 +881,13 @@ export function registerRepoCommands(program) {
         console.log(chalk.gray(`\nRegistered as "${alias}". Skills and commands from this repo will be`));
         console.log(chalk.gray(`picked up automatically the next time you launch any agent.`));
     });
-    repoCmd
+    const listCmd = repoCmd
         .command('list [alias]')
         .alias('ls')
         .description('Show all repos with resource-level sync (skills/commands/plugins to pull or push) and local changes.')
         .option('-v, --verbose', 'Full per-resource detail in a table, regardless of terminal width')
-        .option('--json', 'machine-readable JSON output')
-        .action(async (alias, options) => {
+        .option('--json', 'machine-readable JSON output');
+    addDeviceStatusOptions(listCmd).action(async (alias, options) => {
         await listRepos(alias, options);
     });
     repoCmd
@@ -922,12 +1089,21 @@ export function registerRepoCommands(program) {
             }
         }
     });
+    // Deprecated: superseded by `agents sync`. `agents sync --local` runs the same
+    // reconcile stage (sync-umbrella.ts calls this exact `refresh()`), and `agents
+    // sync <agent>` targets one agent — with the added reach `refresh` lacks
+    // (all installed versions, no silent skip when there is no global default).
+    // Hidden from help; kept as a warned, functional alias so old muscle-memory and
+    // scripts don't break. Migrate callers to `agents sync`.
     repoCmd
-        .command('refresh [agent]')
-        .description('Re-materialize resources into installed agent version homes. No git, no network.')
+        .command('refresh [agent]', { hidden: true })
+        .description('Deprecated — use `agents sync` instead.')
         .option('-y, --yes', 'Auto-sync everything without prompting')
         .option('--skip-clis', 'Skip CLI version install/upgrade from agents.yaml')
         .action(async (arg, options) => {
+        console.warn(chalk.yellow('`agents repo refresh` is deprecated — use `agents sync` instead:'));
+        console.warn(chalk.gray('  all agents:  agents sync --local'));
+        console.warn(chalk.gray('  one agent:   agents sync <agent>'));
         let agentFilter;
         if (arg) {
             if (!isAgentName(arg)) {
@@ -955,12 +1131,12 @@ export function registerRepoCommands(program) {
             process.exit(1);
         }
     });
-    repoCmd
+    const statusCmd = repoCmd
         .command('status [alias]', { hidden: true })
-        .description('Alias of `list` (kept for muscle memory).')
+        .description('Alias of `list` (kept for muscle memory). Add --devices-all to report across the fleet.')
         .option('-v, --verbose', 'Full per-resource detail in a table, regardless of terminal width')
-        .option('--json', 'machine-readable JSON output')
-        .action(async (alias, options) => {
+        .option('--json', 'machine-readable JSON output');
+    addDeviceStatusOptions(statusCmd).action(async (alias, options) => {
         await listRepos(alias, options);
     });
 }

package/dist/commands/routines.d.ts

@@ -6,13 +6,20 @@
  * Also exposes scheduler lifecycle controls (start/stop/status/logs).
  */
 import type { Command } from 'commander';
-import type { RunMeta } from '../lib/routines.js';
+import type { JobConfig, RunMeta } from '../lib/routines.js';
+import type { DeviceRegistry } from '../lib/devices/registry.js';
 /**
  * Human-friendly wall-clock a run took (e.g. "  · 3 min", "  · 45 sec"), or ""
  * when it hasn't completed or timestamps are unparseable. Leading separator lets
  * callers drop it straight into a status line.
  */
 export declare function formatRunDuration(startedAt: string, completedAt: string | null): string;
+export interface RoutineListGroup {
+    key: string;
+    title: string;
+    jobs: JobConfig[];
+}
+export declare function groupRoutineJobsByDevice(jobs: JobConfig[], registry: DeviceRegistry, self?: string): RoutineListGroup[];
 export declare function buildRunsJson(runs: RunMeta[]): Record<string, unknown>[];
 /** Register the `agents routines` command tree. */
 export declare function registerRoutinesCommands(program: Command): void;