@phnx-labs/agents-cli 1.22.114 → 1.22.116

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.
-    `,
-    });
-}

package/dist/commands/share.d.ts

@@ -1,293 +0,0 @@
-import { type Command } from 'commander';
-import { type ShareConfig } from '../lib/share/config.js';
-import { type CloudflareRequester } from '../lib/share/provision.js';
-import { type PublishResult, type ShareVisibility } from '../lib/share/publish.js';
-import { deleteShare, type DeleteShareResult } from '../lib/share/delete.js';
-import type { PhoenixSession } from '../lib/identity/client.js';
-export declare function formatSharePublishResult(result: PublishResult, json?: boolean): string;
-/** Compare the configured endpoint's last-deployed template hash against the
- * hash of the CURRENT `worker-template.ts` render. A config with no recorded
- * hash (every endpoint provisioned before this field existed) is "unknown" —
- * never "current" or "outdated", since there is nothing to compare against. */
-export declare function shareTemplateStatus(cfg: ShareConfig): 'current' | 'outdated' | 'unknown';
-/** One published object as reported by the Worker's `?format=json` listing route. */
-interface ShareListItem {
-    slug: string;
-    url: string;
-    /** Object size in bytes. */
-    size: number;
-    /** Stored content type, or null if the Worker had none recorded. */
-    contentType: string | null;
-    /** ISO timestamp the object was last written (R2 `uploaded`). */
-    publishedAt: string;
-    /** ISO auto-expire timestamp, or null for a permanent share. */
-    expiresAt: string | null;
-    /** Human display title (explicit `--label` or auto-derived), or null for a
-     * share published before this field existed. */
-    label: string | null;
-    /** Harness/agent name that published this (`AGENTS_AGENT_NAME`), or null. */
-    agent: string | null;
-    /** Session id that published this, or null. */
-    session: string | null;
-    /** Hostname the publish ran from, or null. */
-    host: string | null;
-    /** git repo name at publish time, or null (published outside a git repo, or
-     * before this field existed). */
-    repo: string | null;
-    /** Count of retained prior versions under this slug (see `share revisions`). */
-    revisionCount: number;
-    /** The visibility stamped at publish time: public | unlisted | me | org.
-     * Missing on Workers that predate this field → treated as public. */
-    visibility: ShareVisibility;
-    /** Arbitrary `--meta key=value` entries attached at publish time (RUSH-2683)
-     * — everything that isn't a reserved provenance/label key. `{}` when none
-     * were set, or when the deployed Worker predates this field. */
-    meta: Record<string, string>;
-}
-interface ShareListResult {
-    /** The namespace listed. */
-    user: string;
-    count: number;
-    objects: ShareListItem[];
-}
-/** DI seam for tests — override the real HTTP GET of the JSON listing route.
- * The optional `headers` carry the owner bearer for hidden-visibility listings. */
-type ListingFetchFn = (url: string, headers?: Record<string, string>) => Promise<{
-    status: number;
-    contentType: string;
-    body: string;
-}>;
-interface ShareEditResult {
-    ok: true;
-    url: string;
-    label: string | null;
-    meta: Record<string, string>;
-    /** The visibility the page now carries (present on Workers that support the
-     * visibility edit; absent from an older deployed template). */
-    visibility?: ShareVisibility;
-    /** The visibility the page had before this edit, when the Worker reports it. */
-    previousVisibility?: ShareVisibility;
-}
-export declare function runShareEdit(target: string, opts: {
-    githubUser?: string;
-    config?: ShareConfig;
-    writeToken?: string;
-    byo?: boolean;
-    session?: PhoenixSession | null;
-    label?: string | null;
-    meta?: Record<string, string>;
-    metaMode?: 'merge' | 'replace';
-    removeMeta?: string[];
-    /** Change the page's visibility in place (public | unlisted | me | org).
-     * A metadata-only rewrite like label/meta — the body is untouched, so no
-     * revision is created. me/org require a Phoenix session. `private` is
-     * rejected here — token-gating needs a fresh viewer key only the publish
-     * path mints (PHNX-3654). */
-    visibility?: ShareVisibility;
-    force?: boolean;
-    fetchEdit?: typeof fetch;
-}): Promise<ShareEditResult>;
-/** Parse the Worker's listing JSON into a validated result, failing loud (with the
- * outdated-template hint) on any body that isn't the expected shape — an old Worker
- * serves the HTML gallery for a non-empty namespace, which must not be silently
- * accepted as "you have published nothing". */
-export declare function parseShareListing(user: string, body: string): ShareListResult;
-/** Fetch and parse the machine-readable listing of the caller's namespace from the
- * Worker's `?format=json` route. Fails loud when share was never configured, when
- * the deployed template is known-outdated (RUSH-2449 templateHash), or when the
- * live response proves the route is absent (404 or a non-JSON 200 = the old HTML
- * gallery) — never a silent empty/wrong result. Signed-in users hit the managed
- * endpoint; BYO still uses `readShareConfig()`. */
-export declare function runShareList(opts?: {
-    githubUser?: string;
-    config?: ShareConfig;
-    writeToken?: string;
-    byo?: boolean;
-    /** DI seam — override `readSession()`. Named `phoenixSession` because
-     * `session` is already the listing filter (session id). */
-    phoenixSession?: PhoenixSession | null;
-    fetchListing?: ListingFetchFn;
-    /** Only shares published by this agent/harness (case-insensitive, exact). */
-    agent?: string;
-    /** Only shares published from this session id (exact). */
-    session?: string;
-    /** Only shares whose label contains this text (case-insensitive substring). */
-    label?: string;
-    /** Only shares matching every provided `--meta key=value` entry. */
-    meta?: Record<string, string>;
-    /** Visibility filter. `public` (default) lists only public gallery pages;
-     * `unlisted`/`me`/`org` include that owner's hidden pages; `all` includes
-     * every active page. Hidden scopes send the owner's bearer and `scope=mine`. */
-    scope?: 'public' | 'unlisted' | 'private' | 'me' | 'org' | 'all';
-}): Promise<ShareListResult>;
-/** Client-side filtering over an already-fetched listing (RUSH-2683) — the
- * Worker has no query surface for this, so it narrows the fetched set instead
- * of a second round trip. `count` reflects the FILTERED set, matching what the
- * caller actually sees. */
-export declare function applyShareListFilters(result: ShareListResult, filters: {
-    agent?: string;
-    session?: string;
-    label?: string;
-    meta?: Record<string, string>;
-    scope?: 'public' | 'unlisted' | 'private' | 'me' | 'org' | 'all';
-}): ShareListResult;
-export declare function formatShareList(result: ShareListResult, json?: boolean): string;
-/** One retained prior version of a slug, as reported by the Worker's
- * `?revisions=json` route. */
-interface ShareRevisionItem {
-    /** R2 object key, `<user>/<slug>/rev-<ts>-<rand>`. */
-    key: string;
-    url: string;
-    size: number;
-    contentType: string | null;
-    /** ISO timestamp this version was replaced (when the copy was made). */
-    uploadedAt: string;
-    expiresAt: string | null;
-    label: string | null;
-    agent: string | null;
-    session: string | null;
-    host: string | null;
-    repo: string | null;
-    /** Arbitrary `--meta key=value` entries attached at publish time (RUSH-2683)
-     * — everything that isn't a reserved provenance/label key. `{}` when none
-     * were set, or when the deployed Worker predates this field. */
-    meta: Record<string, string>;
-}
-interface ShareRevisionsResult {
-    /** The canonical `<user>/<slug>` key these are revisions of. */
-    key: string;
-    count: number;
-    revisions: ShareRevisionItem[];
-}
-/** Parse the Worker's `?revisions=json` payload, failing loud (with the same
- * outdated-template hint as {@link parseShareListing}) on an unexpected shape. */
-export declare function parseShareRevisions(key: string, body: string): ShareRevisionsResult;
-/** Fetch and parse the retained prior versions of one published slug. `target`
- * accepts the same three forms as `agents artifacts unshare` (a full URL, `<user>/<slug>`,
- * or a bare slug resolved against the caller's own namespace) — reuses
- * {@link resolveDeleteTarget} rather than re-deriving the key. */
-export declare function runShareRevisions(target: string, opts?: {
-    githubUser?: string;
-    config?: ShareConfig;
-    writeToken?: string;
-    byo?: boolean;
-    session?: PhoenixSession | null;
-    fetchListing?: ListingFetchFn;
-}): Promise<ShareRevisionsResult>;
-/** The resolved page URL plus a signed-in-owner URL that carries a one-time
- * login ticket, so opening it activates the shared page's inline visibility
- * control (PHNX-3370). */
-interface ShareOpenResult {
-    /** `<user>/<slug>` key of the target page. */
-    key: string;
-    /** The plain page URL (no ticket). */
-    url: string;
-    /** The page URL with `?phoenix_ticket=<t>` — open THIS to be the owner. */
-    ownerUrl: string;
-}
-/** Mint a one-time login ticket for the signed-in owner and build the URL that
- * opens their own published page **as the owner**, so the inline visibility
- * control is live in the browser. Managed backend only — the control is gated on
- * the Phoenix identity, and BYO (WRITE_TOKEN) endpoints have no per-viewer login.
- * `target` accepts the same three forms as `visibility`/`unshare` (a full URL,
- * `<user>/<slug>`, or a bare slug in the caller's namespace). */
-export declare function runShareOpen(target: string, opts?: {
-    githubUser?: string;
-    config?: ShareConfig;
-    session?: PhoenixSession | null;
-    /** DI seam — override the ticket-mint POST. */
-    fetchTicket?: (url: string, bearer: string) => Promise<{
-        status: number;
-        body: string;
-    }>;
-}): Promise<ShareOpenResult>;
-export declare function formatShareRevisions(result: ShareRevisionsResult, json?: boolean): string;
-export declare function formatShareDeleteResult(result: DeleteShareResult, json?: boolean): string;
-interface ShareDeleteCliOpts {
-    keepCover?: boolean;
-    keepRevisions?: boolean;
-    ifExists?: boolean;
-    forUser?: string;
-    deleteJson?: boolean;
-}
-/** Shared handler for `agents artifacts share delete <targets...>` and the
- * nested `agents artifacts unshare <targets...>` alias. Deletes each target independently and
- * continues past a failed one (rm-style), reporting all results and exiting
- * non-zero if any target failed to verify as gone.
- *
- * `deleteFn` is a DI seam for tests (defaults to the real `deleteShare`) — it is
- * never exposed as a CLI flag, only used to inject a fake config/checker/deleter
- * without touching the keychain or a live endpoint. */
-export declare function runShareDelete(targets: string[], opts: ShareDeleteCliOpts, deleteFn?: typeof deleteShare): Promise<void>;
-/**
- * Register the `share` subtree under its parent group — `agents artifacts share`
- * (see commands/artifacts.ts). `agents artifacts unshare` is the nested alias
- * registered via {@link registerUnshareCommand} on the artifacts group.
- * registration on the ROOT program, so it is {@link registerUnshareCommand}, not
- * part of this subtree.
- */
-export declare function registerShareCommands(artifactsCmd: Command): void;
-/**
- * Register `agents artifacts unshare <targets...>` as the nested alias of
- * `agents artifacts share delete`. Top-level `agents unshare` is retired.
- */
-export declare function registerUnshareCommand(artifactsCmd: Command): void;
-/** Provision a fresh R2 bucket + Worker on the user's Cloudflare and persist the
- * endpoint config + write token. Shared by both modes of `agents artifacts setup`
- * (the flag-driven provision and the interactive wizard). */
-export declare function runShareProvision(opts: {
-    bundle: string;
-    worker: string;
-    bucket: string;
-    account?: string;
-    token?: string;
-    domain?: string;
-    analyticsToken?: string;
-    request?: CloudflareRequester;
-    /** Bind PHOENIX_ID_BASE even when the mapped hostname is not the managed domain. */
-    managed?: boolean;
-}): Promise<void>;
-interface ShareUpdateResult {
-    updated: boolean;
-    templateHash: string;
-    baseUrl: string;
-    workerName: string;
-    /** True when this was a `--check` run: nothing was deployed, the fields below
-     * just report whether a deploy WOULD be needed. Used by the release train to
-     * decide during preflight — before it verifies deploy creds — whether this
-     * release even changes the Worker. */
-    checked?: boolean;
-    /** Whether the current `worker-template.ts` render differs from what the
-     * endpoint last deployed (or `--force`/an endpoint with no recorded hash). */
-    deployNeeded?: boolean;
-    /** The template hash the endpoint last deployed, per local config. Undefined
-     * on an endpoint provisioned before the hash field existed. */
-    deployedHash?: string;
-}
-/** Re-deploy the Worker script on an ALREADY-provisioned endpoint to match the
- * current `worker-template.ts`. Reuses the existing account/worker/bucket and
- * write token from `readShareConfig()`/the `share` bundle — never creates a
- * bucket, touches routes/domains, or regenerates the token (see
- * `updateWorker` in `lib/share/provision.ts` for how the token — and, on a
- * managed endpoint, `PHOENIX_ID_BASE` — survives the re-upload). Idempotent:
- * no-ops the script upload when the deployed hash already matches unless
- * `force`; a managed endpoint still re-applies `PHOENIX_ID_BASE`. */
-export declare function runShareUpdate(opts?: {
-    bundle?: string;
-    account?: string;
-    token?: string;
-    force?: boolean;
-    /** Report whether a deploy is needed and return without deploying. Needs no
-     * Cloudflare credentials — change detection is a pure local render+hash. */
-    check?: boolean;
-    request?: CloudflareRequester;
-    /** Bind PHOENIX_ID_BASE even when the configured hostname is not the managed domain. */
-    managed?: boolean;
-}): Promise<ShareUpdateResult>;
-/** Join an existing share endpoint (no provisioning): prompt for the endpoint
- * details + write token and persist them. Shared by `agents artifacts share join`
- * and the `agents artifacts setup` wizard. */
-export declare function runShareJoin(baseUrl?: string, opts?: {
-    token?: string;
-}): Promise<void>;
-export {};