@phnx-labs/agents-cli 1.22.42 → 1.22.44

package/dist/lib/session/relative-time.js

@@ -1,120 +1,4 @@
-/**
- * Human-readable "time since" formatting for session timestamps. Lives here (not
- * inline in `sessions.ts`) so both the session list renderer and the remote
- * offline-cache banner (`remote.ts`) share one formatter — `sessions.ts` imports
- * `remote.ts`, so a back-import would cycle.
- */
-const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-/**
- * Calendar label for a timestamp older than the relative window. A 2-digit year
- * is appended outside the current year so "Jun 28" is never ambiguous across
- * years (e.g. "Jun 28 '25").
- */
-function calendarLabel(thenMs, nowMs) {
-    const d = new Date(thenMs);
-    const label = `${MONTHS[d.getMonth()]} ${d.getDate()}`;
-    return d.getFullYear() === new Date(nowMs).getFullYear()
-        ? label
-        : `${label} '${String(d.getFullYear()).slice(-2)}`;
-}
-export function formatRelativeTime(isoTimestamp) {
-    const now = Date.now();
-    const then = new Date(isoTimestamp).getTime();
-    if (isNaN(then))
-        return isoTimestamp;
-    const diffMs = now - then;
-    const diffMin = Math.floor(diffMs / 60_000);
-    const diffHrs = Math.floor(diffMs / 3_600_000);
-    const diffDays = Math.floor(diffMs / 86_400_000);
-    if (diffMin < 1)
-        return 'just now';
-    if (diffMin < 60)
-        return `${diffMin} min ago`;
-    if (diffHrs < 24)
-        return `${diffHrs} hour${diffHrs === 1 ? '' : 's'} ago`;
-    if (diffDays < 7)
-        return `${diffDays} day${diffDays === 1 ? '' : 's'} ago`;
-    // Older: show the date.
-    return calendarLabel(then, now);
-}
-/**
- * Compact age — `now`, `45m`, `3h`, `2d`, then the calendar date. This is the
- * *creation* half of a session's time cell: it renders right next to the long
- * last-activity label, and one row can afford one long form, not two.
- */
-export function formatCompactAge(isoTimestamp) {
-    const now = Date.now();
-    const then = new Date(isoTimestamp).getTime();
-    if (isNaN(then))
-        return isoTimestamp;
-    const diffMs = now - then;
-    const diffMin = Math.floor(diffMs / 60_000);
-    const diffHrs = Math.floor(diffMs / 3_600_000);
-    const diffDays = Math.floor(diffMs / 86_400_000);
-    if (diffMin < 1)
-        return 'now';
-    if (diffMin < 60)
-        return `${diffMin}m`;
-    if (diffHrs < 24)
-        return `${diffHrs}h`;
-    if (diffDays < 7)
-        return `${diffDays}d`;
-    return calendarLabel(then, now);
-}
-/**
- * Shortest creation→last-activity gap worth rendering as two fields. Below it
- * both halves name the same minute, so the row would carry a duplicate instead
- * of information.
- */
-const SPAN_MIN_MS = 60_000;
-/**
- * Split a session's timestamps into the two fields a listing renders: when it
- * was created and when it was last active. One last-activity label answers
- * neither "is this the old session I'm looking for" nor "how long did it run" —
- * a session touched an hour ago may have started last week.
- */
-export function sessionAgeParts(createdIso, lastActivityIso) {
-    const lastIso = lastActivityIso ?? createdIso;
-    const last = formatRelativeTime(lastIso);
-    const createdMs = new Date(createdIso).getTime();
-    const lastMs = new Date(lastIso).getTime();
-    if (isNaN(createdMs) || isNaN(lastMs) || lastMs - createdMs < SPAN_MIN_MS)
-        return { last };
-    return { created: formatCompactAge(createdIso), last };
-}
-/**
- * Parse a time filter string (relative like '7d' or an ISO timestamp) into epoch
- * milliseconds. Backs `--since` on `sessions`, `cost`, `teams`, and `output`, and
- * `--unused` on `secrets list`.
- *
- * It lives here, in a module with no imports, rather than in `discover.ts` where
- * it started: `discover.ts` loads `../sqlite.js`, so importing this one function
- * from there pulls `node:sqlite` into the caller's module graph and Node prints
- * `ExperimentalWarning: SQLite …` on stderr. That is invisible in a command that
- * already touches the session DB, and a broken contract in one that doesn't —
- * `monitors --json` asserts a clean stderr. `discover.ts` re-exports it, so
- * existing importers are unaffected.
- */
-export function parseTimeFilter(input) {
-    // Units: m=minute, h=hour, d=day, w=week, mo=month(30d), y=year(365d). `mo`
-    // must precede the single-letter alternatives so "1mo" isn't read as "1m"+"o".
-    const relativeMatch = input.match(/^(\d+)(mo|[mhdwy])$/i);
-    if (relativeMatch) {
-        const value = parseInt(relativeMatch[1], 10);
-        const unit = relativeMatch[2].toLowerCase();
-        if (unit === 'm')
-            return Date.now() - value * 60_000;
-        if (unit === 'h')
-            return Date.now() - value * 3_600_000;
-        if (unit === 'd')
-            return Date.now() - value * 86_400_000;
-        if (unit === 'w')
-            return Date.now() - value * 7 * 86_400_000;
-        if (unit === 'mo')
-            return Date.now() - value * 30 * 86_400_000;
-        if (unit === 'y')
-            return Date.now() - value * 365 * 86_400_000;
-    }
-    const ts = new Date(input).getTime();
-    return Number.isNaN(ts) ? 0 : ts;
-}
+// Moved to ../text/relative-time.ts (move 1 of the core-module refactor — see
+// .agents/artifacts/2026-08-20/plan-*.md). Kept as a re-export shim so
+// existing importers don't break.
+export * from '../text/relative-time.js';

package/dist/lib/session/remote/remote-bundle.d.ts

@@ -0,0 +1,12 @@
+import { type ParsedBundle } from '../bundle.js';
+export interface RemotePullResult {
+    bundles: ParsedBundle[];
+    errors: string[];
+}
+/**
+ * Run `agents sessions export …exportArgs --stdout` on each host and parse the
+ * streamed bundle. A host that fails (unreachable, remote error, bad output) is
+ * collected in `errors` and skipped — one asleep peer never aborts the pull.
+ * `exportArgs` must NOT contain --device (the remote export runs for itself only).
+ */
+export declare function pullBundlesFromHosts(hosts: string[], exportArgs: string[]): Promise<RemotePullResult>;

package/dist/lib/session/remote/remote-bundle.js

@@ -0,0 +1,61 @@
+/**
+ * Multi-device session transfer over the EXISTING SSH fleet transport
+ * (RUSH-1712) — no R2, no daemon. `agents sessions export --device <h>` and
+ * `agents sessions import --from-host <h>` both run `agents sessions export
+ * … --stdout` ON the peer and stream the bundle back over the same SSH path the
+ * cross-machine listing already uses (resolveExplicitTargets + ssh-exec), then
+ * either write it (export) or import it (import) locally.
+ *
+ * This deliberately reuses ssh-exec / resolve-target rather than adding a second
+ * transport: the raw form `agents ssh boxA 'agents sessions export --stdout' |
+ * agents sessions import -` works with plain export/import; this module is just
+ * the one-shot wrapper around it.
+ */
+import chalk from 'chalk';
+import { sshExec } from '../../ssh-exec.js';
+import { shellQuote } from '../../ssh-exec.js';
+import { resolveExplicitTargets } from '../../devices/resolve-target.js';
+import { remoteShellFor, buildWindowsAgentsCommand } from '../../hosts/remote-cmd.js';
+import { parseBundle } from '../bundle.js';
+/** Remote export can traverse many sessions; give it a generous ceiling. */
+const REMOTE_EXPORT_TIMEOUT_MS = 300_000;
+/** Build `agents <args>` for the peer's login shell (bash or PowerShell). */
+function remoteAgentsCommand(args, os) {
+    if (remoteShellFor(os) === 'powershell') {
+        return buildWindowsAgentsCommand({ args });
+    }
+    const inner = ['agents', ...args].map((t, i) => (i === 0 ? t : shellQuote(t))).join(' ');
+    return `bash -lc ${shellQuote(inner)}`;
+}
+/**
+ * Run `agents sessions export …exportArgs --stdout` on each host and parse the
+ * streamed bundle. A host that fails (unreachable, remote error, bad output) is
+ * collected in `errors` and skipped — one asleep peer never aborts the pull.
+ * `exportArgs` must NOT contain --device (the remote export runs for itself only).
+ */
+export async function pullBundlesFromHosts(hosts, exportArgs) {
+    const targets = await resolveExplicitTargets(hosts);
+    const bundles = [];
+    const errors = [];
+    for (const t of targets) {
+        const cmd = remoteAgentsCommand(['sessions', 'export', ...exportArgs, '--stdout'], t.os);
+        process.stderr.write(chalk.dim(`Pulling sessions from ${t.name}…\n`));
+        const res = sshExec(t.target, cmd, { timeoutMs: REMOTE_EXPORT_TIMEOUT_MS, extraSshArgs: t.extraSshArgs });
+        if (res.timedOut) {
+            errors.push(`${t.name}: timed out after ${Math.round(REMOTE_EXPORT_TIMEOUT_MS / 1000)}s`);
+            continue;
+        }
+        if (res.code !== 0) {
+            const tail = res.stderr.trim().split('\n').filter(Boolean).pop();
+            errors.push(`${t.name}: remote export failed (${res.code ?? 'ssh error'})${tail ? ': ' + tail : ''}`);
+            continue;
+        }
+        try {
+            bundles.push(parseBundle(res.stdout));
+        }
+        catch (err) {
+            errors.push(`${t.name}: ${err.message}`);
+        }
+    }
+    return { bundles, errors };
+}

package/dist/lib/session/remote/remote-list.d.ts

@@ -0,0 +1,148 @@
+import { type DeviceProfile } from '../../devices/registry.js';
+import { type RemoteAgentsJsonParseResult } from '../../remote-agents-json.js';
+import type { SessionMeta } from '../types.js';
+import { type ToolProgramCountEnvelope, type ToolSearchEnvelope } from '../tool-index.js';
+export { REMOTE_STDOUT_MAX_BYTES, RemoteUtf8Accumulator } from '../../ssh-exec.js';
+export declare const REMOTE_TOOL_AGGREGATE_MAX_BYTES: number;
+export interface RemoteToolByteBudget {
+    remainingBytes: number;
+    exhausted: boolean;
+}
+/** Claim received bytes against one fleet-query budget before retaining them. */
+export declare function consumeRemoteToolByteBudget(budget: RemoteToolByteBudget, bytes: number): boolean;
+/** Charge sanitized, machine-stamped evidence because redaction may expand it. */
+export declare function consumeParsedRemoteToolSearchBudget(budget: RemoteToolByteBudget, envelope: ToolSearchEnvelope): boolean;
+/**
+ * The command run on each peer: answer for itself, as JSON, without recursing.
+ * `forwardedArgs` carry the caller's own query/filters (already including the
+ * leading `sessions` and a `--json`) so each peer returns a comparable slice.
+ * A Windows peer gets a PowerShell invocation (ssh lands in cmd.exe/PowerShell
+ * there, where `bash -lc` is not a command); every other OS keeps `bash -lc`.
+ */
+export declare function remoteListCommand(forwardedArgs: string[], os?: string): string;
+/**
+ * Parse a peer's `sessions --json` stdout into `SessionMeta[]`, tagging each
+ * with `machine`. Defensive against version skew / partial output: non-JSON or
+ * a non-array yields `[]`, and non-object entries are dropped rather than
+ * throwing. The `machine` we dialed always wins over any value the peer set on
+ * its own rows, so grouping keys off the computer we asked. Exported for unit
+ * testing without a live tailnet.
+ */
+export declare function parseRemoteList(stdout: string, machine: string): SessionMeta[];
+export declare function parseRemoteListPayload(stdout: string, machine: string, safeResolver?: boolean): {
+    items: SessionMeta[];
+    valid: boolean;
+};
+/** Run one remote `agents sessions … --json` and capture stdout. Resolves
+ * `{ code: null }` on spawn error or timeout (host treated as dead). */
+export declare function sshCapture(target: string, remoteCmd: string, timeoutMs: number, aggregateBudget?: RemoteToolByteBudget, options?: {
+    multiplex?: boolean;
+    port?: number;
+    hostKeyOpts?: string[];
+}): Promise<{
+    code: number | null;
+    stdout: string;
+    aggregateBudgetExceeded?: boolean;
+}>;
+export interface RemoteListResult {
+    sessions: SessionMeta[];
+    /** How many peer machines we attempted to reach (drives the empty-fleet tip). */
+    deviceCount: number;
+    /**
+     * Peers that failed to answer, by display name. The stderr note above is
+     * enough for a printed listing, but the interactive browser repaints over it —
+     * so callers rendering a full-screen UI need the outcome as data to tell
+     * "that box is asleep" apart from "that box has no matching sessions".
+     */
+    unreachable: string[];
+}
+/** Keep browse and tool-search fan-out on the same automatic peer set. */
+export declare function isAutomaticSessionPeer(d: DeviceProfile, self: string): boolean;
+/**
+ * Gather listing sessions from other machines. With an explicit `hosts` list
+ * (from `--device`), fan out to exactly those. Otherwise sweep the registered,
+ * online devices from `ag devices`, excluding this machine and any without an
+ * address. `forwardedArgs` are the caller's own sessions args (query + filters,
+ * already `--json`) so every peer returns the same slice this machine asked for.
+ */
+export interface GatherRemoteListOptions {
+    /**
+     * Opt-in early-exit for a globally-unique id lookup (a full UUID): the first
+     * peer to return the matching row resolves the fan-out and cancels the rest.
+     * Omitted for browse/label/prefix sweeps, which must wait for every peer to
+     * know whether the match is unique or conflicting.
+     */
+    isDefinitive?: (session: SessionMeta, machine: string) => boolean;
+    /** Per-peer deadline for slower indexed browse queries. */
+    timeoutMs?: number;
+}
+export declare function gatherRemoteList(forwardedArgs: string[], hosts?: string[], opts?: GatherRemoteListOptions): Promise<RemoteListResult>;
+export interface RemoteToolSearchResult {
+    envelopes: Array<{
+        machine: string;
+        envelope: ToolSearchEnvelope;
+    }>;
+    deviceCount: number;
+    unreachable: string[];
+    truncated: string[];
+}
+export interface RemoteToolProgramCountResult {
+    envelopes: Array<{
+        machine: string;
+        envelope: ToolProgramCountEnvelope;
+    }>;
+    deviceCount: number;
+    unreachable: string[];
+}
+export declare function parseRemoteToolProgramCount(stdout: string, machine: string, expectedProgram: string): RemoteAgentsJsonParseResult<{
+    machine: string;
+    envelope: ToolProgramCountEnvelope;
+}>;
+export declare function gatherRemoteToolProgramCounts(forwardedArgs: string[], hosts: string[] | undefined, expectedProgram: string): Promise<RemoteToolProgramCountResult>;
+export declare function parseRemoteToolSearch(stdout: string, machine: string, expectedClauses?: string[]): ToolSearchEnvelope | undefined;
+/**
+ * Fleet sibling of {@link gatherRemoteList} for the versioned tool-search
+ * envelope. Each peer executes the same local-only query against its own
+ * SQLite index; only compact matches cross SSH.
+ */
+export declare function gatherRemoteToolSearch(forwardedArgs: string[], hosts?: string[], maxAggregateBytes?: number, expectedClauses?: string[]): Promise<RemoteToolSearchResult>;
+/** Resolve a peer's SSH target (and OS) from the device registry by its
+ * normalized machine id — the same id the fan-out tags rows with. Returns
+ * undefined when no registered device with an address matches. */
+export declare function resolvePeerTarget(machine: string): Promise<{
+    target: string;
+    os?: string;
+} | undefined>;
+/**
+ * Fetch one remote session's preview digest from its owning peer — the data
+ * behind the picker pane for a `_remote` row, whose transcript file this
+ * machine cannot parse. Runs the peer's own `agents sessions preview <id>
+ * --local --json` (the same envelope `agents sessions preview` already
+ * delegates to for a remote id) and returns its `preview` object, verbatim and
+ * UNSANITIZED — the caller owns scrubbing peer-supplied strings before any of
+ * them reach a TTY. Undefined on every failure: unregistered machine, SSH
+ * error, timeout, version-skewed peer with no `--json` preview envelope.
+ */
+export declare function fetchPeerPreviewDigest(sessionId: string, machine: string, timeoutMs?: number): Promise<unknown | undefined>;
+/**
+ * Run `agents <args>` ON a peer over SSH, attached to this terminal (inherited
+ * stdio). `args` is the full arg vector after the binary — callers pass e.g.
+ * `['sessions', id, '--markdown']` or `['sessions', 'resume', id]`. Used when a
+ * picked session lives on another machine: its transcript and agent binary are
+ * there, so both reading (no TTY) and resuming (TTY) must execute on the peer —
+ * not via a local `--device` hop, which would discover locally and dead-end for a
+ * session that exists only on the peer. Resolves 'no-target' when the machine
+ * isn't a dialable registered device; the caller surfaces a clear message.
+ *
+ * `opts.env` adds variables to the remote command. It deliberately does NOT
+ * carry `AGENTS_FLEET_REMOTE` the way the `--device` passthrough does: that marker
+ * gates consent-sensitive actions on the far side
+ * (lib/browser/remote-control.ts), and a resumed agent is a long-lived session
+ * that would inherit it for its whole life — `agents browser start` inside it
+ * would then be refused as a cross-machine drive. A one-shot `--device` command
+ * can carry the marker; a session cannot.
+ */
+export declare function runOnPeer(args: string[], machine: string, opts?: {
+    tty?: boolean;
+    env?: Record<string, string>;
+}): Promise<'ok' | 'no-target'>;