@phnx-labs/agents-cli 1.22.114 → 1.22.115

package/dist/commands/artifacts.js

@@ -1,58 +0,0 @@
-/**
- * `agents artifacts` — the group that owns everything an agent publishes for a
- * human to open: HTML plans, reports, rendered visuals, screenshots.
- *
- * RUSH-2580 nested the former top-level `agents share` here. `artifacts` is the
- * noun, `share` is the action on it, so the surface reads noun-then-action like
- * the rest of the CLI:
- *
- *   agents artifacts share <file>          publish
- *   agents artifacts share list|delete|analytics|join|status|update
- *   agents artifacts setup                 provision (or join) the endpoint
- *
- * The subtree itself lives in commands/share.ts (publish + its subcommands) and
- * commands/artifacts-setup.ts (the provisioning door); this module only assembles
- * the group, so there is one place that says what `agents artifacts` contains.
- */
-import { setHelpSections } from '../lib/help.js';
-import { registerShareCommands, registerUnshareCommand } from './share.js';
-import { registerArtifactsSetupCommand } from './artifacts-setup.js';
-export function registerArtifactsCommands(program) {
-    const artifactsCmd = program
-        .command('artifacts')
-        .description('Publish agent-made artifacts (plans, reports, visuals) to a shareable link — managed if signed in, otherwise your Cloudflare R2.');
-    registerArtifactsSetupCommand(artifactsCmd);
-    registerShareCommands(artifactsCmd);
-    setHelpSections(artifactsCmd, {
-        examples: `
-      # Signed in? Just publish — no Cloudflare setup
-      agents auth login
-      agents artifacts share ./out/plan.html
-
-      # Or provision your own Cloudflare endpoint (or join a teammate's)
-      agents artifacts setup
-      agents artifacts share join https://share.getrush.ai
-
-      # What's live in your namespace, and taking one down
-      agents artifacts share list
-      agents artifacts unshare my-plan-a1b2
-
-      # Endpoint health, and pushing a new Worker template to it
-      agents artifacts share status
-      agents artifacts share update
-    `,
-        notes: `
-  agents artifacts share is the publish action; agents artifacts setup is the
-  one-time endpoint provisioning. It runs the interactive wizard only when you
-  type NO endpoint flag on a TTY; type any of --bundle/--worker/--bucket/
-  --account/--token/--domain/--analytics-token, or run non-interactively, and it
-  provisions directly with what you named.
-
-  agents artifacts unshare <targets...> is the nested alias of
-  agents artifacts share delete. Top-level \`agents unshare\` is gone.
-
-  Architecture: cli/docs/observability.md.
-    `,
-    });
-    registerUnshareCommand(artifactsCmd);
-}

package/dist/commands/attach.d.ts

@@ -1,12 +0,0 @@
-/**
- * `agents sessions attach <id>` — bring a backgrounded (or parked) agent session
- * back to the foreground: stop its headless continuation, then resume it
- * interactively in this terminal. The resume is version-pinned native resume
- * (claude/codex) or a `/continue` replay (others) — the same session, full
- * history, the exact inverse of `agents sessions detach`.
- */
-import type { Command } from 'commander';
-import type { SessionMeta } from '../lib/session/types.js';
-export declare function registerAttachCommand(program: Command): void;
-export declare function attachAction(id: string): Promise<void>;
-export declare function attachRecoveryArgs(session: Pick<SessionMeta, 'id'>): string[];

package/dist/commands/attach.js

@@ -1,86 +0,0 @@
-import chalk from 'chalk';
-import { runOnPeer } from '../lib/session/remote-list.js';
-import { sessionRecoveryPeer } from '../lib/session/recovery.js';
-import { resolveSessionMetadataValue, resumeSessionInPlace } from './sessions.js';
-import { readDetachRecord, clearDetachRecord, isHeadlessAlive } from '../lib/session/detached.js';
-import { attachLocalLiveSelector } from '../lib/session/local-tmux-attach.js';
-export function registerAttachCommand(program) {
-    // Deprecated: superseded by `agents sessions resume`, which detects the state
-    // (live pane / headless / ended) instead of making the caller pick a verb.
-    // Hidden from help; kept as a warned, functional alias for one release so old
-    // muscle-memory and scripts don't break.
-    program
-        .command('attach', { hidden: true })
-        .argument('<id>', 'Short or full id of the backgrounded/parked session to resume interactively')
-        .description('Deprecated — use `agents sessions resume <id>` instead.')
-        .action(async (id) => {
-        console.warn(chalk.yellow('`agents sessions attach` is deprecated — use `agents sessions resume` instead:'));
-        console.warn(chalk.gray(`  agents sessions resume ${id}`));
-        await attachAction(id);
-    });
-}
-export async function attachAction(id) {
-    // PHNX-3292: this deprecated spelling still gets the local-pane fast path —
-    // a live tmux alias/short id on THIS box attaches with zero SSH, matching
-    // `sessions resume`. `attach` takes no `--device`, so hosts is always empty.
-    if (await attachLocalLiveSelector(id.trim(), [])) {
-        return;
-    }
-    const outcome = await resolveSessionMetadataValue(id);
-    if (outcome.kind === 'partial') {
-        // RUSH-2492: an unreachable peer is a warning, not a hard failure. The
-        // resolver already resolves an id found on the reachable fleet (SES-9a), so
-        // reaching here means the session was not found on any device we COULD reach
-        // — it may live on one of the unreachable peers, which we could not check.
-        const offline = outcome.failedPeers;
-        console.error(chalk.yellow(`Warning: ${offline.length} device(s) unreachable, not checked: ${offline.join(', ')}`));
-        console.error(chalk.red(`No session matching "${id}" on any reachable device (${offline.length} unreachable, not checked).`));
-        console.error(chalk.gray('  If it lives on an offline box, wake it (agents devices) or run there: agents ssh <device>'));
-        process.exitCode = 1;
-        return;
-    }
-    if (outcome.kind === 'not-found') {
-        console.error(chalk.red(`No session matching "${id}".`));
-        console.error(chalk.gray('  See your sessions: agents sessions'));
-        process.exitCode = 1;
-        return;
-    }
-    if (outcome.kind === 'ambiguous') {
-        console.error(chalk.red(`"${id}" matches ${outcome.candidates.length} sessions. Pass the full session id.`));
-        process.exitCode = 1;
-        return;
-    }
-    const meta = outcome.session;
-    // Route the WHOLE attach operation to the origin, not just its eventual
-    // resume. The detach record and headless PID are device-local; clearing them
-    // here would leave the real background continuation running beside a second
-    // process on the owning machine.
-    const peer = sessionRecoveryPeer(meta);
-    if (peer) {
-        const routed = await runOnPeer(attachRecoveryArgs(meta), peer, { tty: true, sessionId: meta.id });
-        if (routed === 'no-target') {
-            console.error(chalk.red(`Cannot attach ${meta.shortId}: origin device ${peer} is not a registered reachable peer.`));
-            process.exitCode = 1;
-        }
-        return;
-    }
-    // If it's backgrounded, stop the headless continuation first so two processes
-    // don't resume the same transcript at once.
-    const rec = readDetachRecord(meta.id);
-    if (rec) {
-        if (isHeadlessAlive(rec)) {
-            try {
-                process.kill(rec.headlessPid, 'SIGTERM');
-            }
-            catch {
-                /* already gone */
-            }
-        }
-        clearDetachRecord(meta.id);
-    }
-    console.log(chalk.gray(`Attaching ${meta.agent} ${meta.id.slice(0, 8)} — resuming interactively…`));
-    await resumeSessionInPlace(meta);
-}
-export function attachRecoveryArgs(session) {
-    return ['sessions', 'attach', session.id];
-}

package/dist/commands/auth-mint.d.ts

@@ -1,12 +0,0 @@
-/**
- * Shared `mint` subcommand registered on both `agents auth` (the ticket
- * surface) and `agents accounts` (the credential noun). Hidden on both:
- * `agents accounts add <harness> [name]` / `agents accounts login <harness>#<name>`
- * is the taught path. Implementation lives in lib/auth-mint.ts so neither
- * command file owns the seed path.
- */
-import type { Command } from 'commander';
-import { type MintDriveHooks } from '../lib/auth-mint.js';
-export declare function registerMintCommand(parent: Command, testHooks?: MintDriveHooks, opts?: {
-    hidden?: boolean;
-}): Command;

package/dist/commands/auth-mint.js

@@ -1,108 +0,0 @@
-/**
- * Shared `mint` subcommand registered on both `agents auth` (the ticket
- * surface) and `agents accounts` (the credential noun). Hidden on both:
- * `agents accounts add <harness> [name]` / `agents accounts login <harness>#<name>`
- * is the taught path. Implementation lives in lib/auth-mint.ts so neither
- * command file owns the seed path.
- */
-import chalk from 'chalk';
-import { setHelpSections } from '../lib/help.js';
-import { readStdinSync, runOrDie } from '../lib/format.js';
-import { isInteractiveTerminal } from './utils.js';
-import { getMintFlow, listMintableHarnesses, mintAndSeed, } from '../lib/auth-mint.js';
-const MINT_POINTER = 'agents accounts add <harness> [name] / agents accounts login <harness>#<name>';
-function collect(value, previous) {
-    return [...previous, value];
-}
-function printResult(result, json) {
-    if (json) {
-        console.log(JSON.stringify({
-            harness: result.harness,
-            account: result.account,
-            email: result.email,
-            authBundleKey: result.authBundleKey,
-            rotated: result.rotated,
-            fleet: result.fleet,
-        }, null, 2));
-        return;
-    }
-    const verb = result.rotated ? 'Rotated' : 'Minted';
-    console.log(chalk.green(`${verb} ${result.harness} setup-token for ${result.email} into account '${result.account}' and reserved auth bundle key ${result.authBundleKey}.`));
-    console.log(chalk.gray('The token is never printed. Native OAuth was not copied.'));
-    console.log(chalk.gray(`Run: agents run ${result.harness} --account ${result.account}`));
-    if (result.fleet.length) {
-        for (const row of result.fleet) {
-            console.log(chalk.green(`  synced ${row.device} (${row.message})`));
-        }
-    }
-}
-export function registerMintCommand(parent, testHooks, opts) {
-    const hidden = opts?.hidden ?? true;
-    const mint = parent
-        .command('mint <harness>', { hidden })
-        .description('Mint a long-lived setup-token and seed it as a named account')
-        .option('--account <name-or-email>', 'Named account to create/rotate, or the account email')
-        .option('--email <email>', 'Email that keys the reserved auth bundle when --account is a name')
-        .option('--token-stdin', 'Seed an already-minted token from stdin (skip the PTY drive)')
-        .option('--code <code>', 'Authorization code to paste into the setup-token prompt')
-        .option('--no-open', 'Print the authorize URL instead of opening a browser')
-        .option('--fleet', 'Sync the minted account and reserved auth bundle to every other registered device')
-        .option('--device <name>', 'Sync to this device (repeatable)', collect, [])
-        .option('--json', 'Machine-readable result (never includes the token)')
-        .action((harness, o, command) => {
-        const json = !!o.json || !!command.optsWithGlobals().json;
-        return runOrDie(async () => {
-            getMintFlow(harness);
-            let token;
-            if (o.tokenStdin) {
-                token = readStdinSync();
-                if (!token)
-                    throw new Error('No value received on stdin. Pass the setup-token on stdin with --token-stdin.');
-            }
-            else if (!isInteractiveTerminal() && !o.code) {
-                throw new Error(`Minting ${harness} interactively needs a TTY (or --token-stdin / --code). Supported harnesses: ${listMintableHarnesses().join(', ')}.`);
-            }
-            const result = await mintAndSeed({
-                harness,
-                account: o.account,
-                email: o.email,
-                token,
-                code: o.code,
-                open: o.open,
-                fleet: o.fleet,
-                devices: o.device,
-                json,
-                hooks: {
-                    ...testHooks,
-                    ...(o.tokenStdin || o.code || !isInteractiveTerminal()
-                        ? {}
-                        : {
-                            readCode: async () => {
-                                const { input } = await import('@inquirer/prompts');
-                                return input({ message: 'Paste the authorization code from the browser' });
-                            },
-                        }),
-                },
-            });
-            printResult(result, json);
-        }, { json });
-    });
-    if (hidden) {
-        mint.hook('preAction', () => {
-            console.error(chalk.gray(`'agents ${parent.name()} mint' is a hidden alias; use \`${MINT_POINTER}\` — still works this release.`));
-        });
-    }
-    setHelpSections(mint, {
-        examples: `agents accounts add claude work
-agents accounts login claude#work
-agents accounts mint claude --token-stdin < token.txt
-agents accounts mint claude --code AUTHCODE --json
-agents accounts mint claude --fleet`,
-        notes: `Hidden alias of the worker-credential step that \`agents accounts add <harness> [name]\` (mint during add) and \`agents accounts login <harness>#<name>\` (re-mint) now own. Claude is the only harness with an interactive long-lived setup-token (\`claude setup-token\`, ~1 year, shareable across machines). The command drives that flow in a PTY, opens the authorize URL, captures a well-formed sk-ant-oat01- token (refusing the #1767 TTY-banner capture), and seeds:
-  1. a named provider account (policy never) for \`agents run --account\` / \`agents accounts sync\`
-  2. the reserved FILE-BASED auth bundle keyed per email, which usage/probe reads
-Native rotating OAuth is never copied. Other harnesses fail loud: device-code login is \`agents fleet login\`; API keys are \`agents accounts add\`.
-Already have a token? \`--token-stdin\` skips the browser dance. \`agents auth mint\` and \`agents accounts mint\` are the same hidden command.`,
-    });
-    return mint;
-}

package/dist/commands/reconnect.d.ts

@@ -1,46 +0,0 @@
-/**
- * `agents reconnect [session-id]` — get me back into an agent terminal whose ssh
- * link dropped.
- *
- * The auto-reconnect in lib/hosts/reconnect.ts already re-attaches a live remote
- * pane over its own bounded backoff on a transient blink. This is the MANUAL
- * recovery for after it gave up — a sustained outage, or a VS Code terminal tab
- * that closed with the dead ssh client. One verb that always tries hardest to put
- * you back into that agent: attach the live pane if it still exists, else resume
- * the session; live pane > resumed copy > a clear message about what was lost.
- *
- * It delegates to `focus`, which already does exactly attach-else-resume for a
- * resolved id ({@link focusAction} → `focusResolvedSession`), so there is no second
- * recovery path to keep in sync. What `reconnect` adds is the recovery framing and,
- * with no id, targeting the MOST RECENT session in this shell's directory — the one
- * that most likely just dropped — instead of opening the full fleet picker.
- */
-import type { Command } from 'commander';
-import type { SessionMeta } from '../lib/session/types.js';
-/**
- * The recency signal a no-id reconnect targets: last activity if the scan
- * computed one, else the creation time. A row with neither parseable sorts last.
- * Pure so target selection is unit-tested without the scanner.
- */
-export declare function sessionRecency(s: Pick<SessionMeta, 'lastActivity' | 'timestamp'>): number;
-/**
- * Pick the session to reconnect when the user gave no id: the most recently
- * active one in scope — the terminal that most likely just dropped. Pure; returns
- * undefined for an empty scope so the caller can print guidance.
- */
-export declare function pickMostRecentSession(sessions: SessionMeta[]): SessionMeta | undefined;
-/**
- * Resolve the no-id target: prefer the most recent session started from THIS
- * directory (the shell the user is reconnecting from), falling back to the most
- * recent session anywhere when the current directory has none. Best-effort — a
- * discovery failure yields undefined, never throws. Injectable `discover` keeps
- * the two-step scope preference testable without touching the real scanner.
- */
-export declare function resolveRecentTarget(cwd: string, discover?: (opts: {
-    cwd?: string;
-    all?: boolean;
-    since?: string;
-    limit?: number;
-}) => Promise<SessionMeta[]>): Promise<SessionMeta | undefined>;
-export declare function reconnectAction(id: string | undefined): Promise<void>;
-export declare function registerReconnectCommand(program: Command): void;

package/dist/commands/reconnect.js

@@ -1,115 +0,0 @@
-/**
- * `agents reconnect [session-id]` — get me back into an agent terminal whose ssh
- * link dropped.
- *
- * The auto-reconnect in lib/hosts/reconnect.ts already re-attaches a live remote
- * pane over its own bounded backoff on a transient blink. This is the MANUAL
- * recovery for after it gave up — a sustained outage, or a VS Code terminal tab
- * that closed with the dead ssh client. One verb that always tries hardest to put
- * you back into that agent: attach the live pane if it still exists, else resume
- * the session; live pane > resumed copy > a clear message about what was lost.
- *
- * It delegates to `focus`, which already does exactly attach-else-resume for a
- * resolved id ({@link focusAction} → `focusResolvedSession`), so there is no second
- * recovery path to keep in sync. What `reconnect` adds is the recovery framing and,
- * with no id, targeting the MOST RECENT session in this shell's directory — the one
- * that most likely just dropped — instead of opening the full fleet picker.
- */
-import chalk from 'chalk';
-import { focusAction } from './focus.js';
-import { discoverSessions } from '../lib/session/discover.js';
-import { setHelpSections } from '../lib/help.js';
-/**
- * The recency signal a no-id reconnect targets: last activity if the scan
- * computed one, else the creation time. A row with neither parseable sorts last.
- * Pure so target selection is unit-tested without the scanner.
- */
-export function sessionRecency(s) {
-    const t = Date.parse(s.lastActivity ?? s.timestamp ?? '');
-    return Number.isFinite(t) ? t : Number.NEGATIVE_INFINITY;
-}
-/**
- * Pick the session to reconnect when the user gave no id: the most recently
- * active one in scope — the terminal that most likely just dropped. Pure; returns
- * undefined for an empty scope so the caller can print guidance.
- */
-export function pickMostRecentSession(sessions) {
-    let best;
-    for (const s of sessions) {
-        if (!best || sessionRecency(s) > sessionRecency(best))
-            best = s;
-    }
-    return best;
-}
-/**
- * Resolve the no-id target: prefer the most recent session started from THIS
- * directory (the shell the user is reconnecting from), falling back to the most
- * recent session anywhere when the current directory has none. Best-effort — a
- * discovery failure yields undefined, never throws. Injectable `discover` keeps
- * the two-step scope preference testable without touching the real scanner.
- */
-export async function resolveRecentTarget(cwd, discover = discoverSessions) {
-    try {
-        const here = await discover({ cwd, since: '7d', limit: 200 });
-        const local = pickMostRecentSession(here);
-        if (local)
-            return local;
-        const any = await discover({ all: true, since: '7d', limit: 200 });
-        return pickMostRecentSession(any);
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function reconnectAction(id) {
-    if (id) {
-        // focus already attaches a live pane or recovers a dropped one for a resolved
-        // id — on the origin device for a remote session. Reconnect is that path with
-        // a recovery-first name; no reason to duplicate the resolution/attach logic.
-        await focusAction(id, {});
-        return;
-    }
-    const recent = await resolveRecentTarget(process.cwd());
-    if (!recent) {
-        console.log(chalk.gray('No recent session to reconnect from here.'));
-        console.log(chalk.gray('  reconnect a specific one:  agents reconnect <session-id>'));
-        console.log(chalk.gray('  or pick from the fleet:    agents sessions'));
-        return;
-    }
-    const where = recent.machine ? ` on ${recent.machine}` : '';
-    console.log(chalk.gray(`Reconnecting ${recent.shortId}${where} (most recent here)…`));
-    await focusAction(recent.id, {});
-}
-export function registerReconnectCommand(program) {
-    // Deprecated: superseded by `agents sessions resume`, which does the same
-    // attach-else-recover and additionally takes a tmux alias. Hidden + warned +
-    // functional for one release. Bare `reconnect` targeted the most recent
-    // session in this directory; that default now lives on `resume`'s picker.
-    const cmd = program
-        .command('reconnect', { hidden: true })
-        .argument('[session-id]', 'Session id/prefix to reconnect (default: the most recent session started here)')
-        .description('Deprecated — use `agents sessions resume` instead.')
-        .action(async (id) => {
-        console.warn(chalk.yellow('`agents reconnect` is deprecated — use `agents sessions resume` instead:'));
-        console.warn(chalk.gray(`  agents sessions resume${id ? ` ${id}` : ''}`));
-        await reconnectAction(id);
-    });
-    setHelpSections(cmd, {
-        examples: `
-      # Reconnect the session that just dropped in this shell (most recent here)
-      agents reconnect
-
-      # Reconnect one specific agent terminal by id/prefix
-      agents reconnect 74b13b0b
-
-      # Same, spelled under the sessions group
-      agents sessions reconnect 74b13b0b
-    `,
-        notes: `
-      - Best-effort recovery: a living remote tmux pane is JOINED (a second client, no fork); a dropped one is RESUMED on its origin device (a copy if it was mid-run, a /continue if idle).
-      - With no id, targets the most recent session started from this directory (the terminal that most likely just dropped), not the full fleet picker. Falls back to the most recent session anywhere when this directory has none.
-      - This is the manual companion to the automatic reconnect that runs during a live 'agents run --device <box>' when the network blinks; use it after that gave up or the terminal tab closed.
-      - Deprecated: use 'agents sessions resume' — it attaches a live pane, foregrounds a headless session, or recovers an ended one.
-    `,
-    });
-}