@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/lib/fleet/remote-login.js

@@ -17,8 +17,9 @@
  * Layering — pure vs I/O, so the valuable logic is unit-testable without SSH:
  *  - `scrapeLogin` / `classifyLoginFlow` / `selectLoginTargets` /
  *    `buildRemoteLoginSshCommand` / `buildDashboardHtml` are PURE.
- *  - `driveRemoteLogin` drives a PTY through an injectable {@link PtyDriver}
- *    (fake in tests; real over the pty sidecar in prod).
+ *  - `driveRemoteLogin` drives a terminal through an injectable {@link TermDriver}
+ *    (fake in tests; real over the standalone `term` CLI in prod — see
+ *    `../term-client.js`).
  *  - `detectPending` / `runFleetLogin` do the real fleet I/O.
  *
  * The device codes have a ~15 min TTL, so the default (bulk) mode requests every
@@ -32,7 +33,7 @@ import { deviceIdentityArgs, fleetDialTarget } from '../devices/connect.js';
 import { planFleetTargets } from '../devices/fleet.js';
 import { assertValidSshTarget, shellQuote, sshExecAsync } from '../ssh-exec.js';
 import { machineId } from '../session/sync/config.js';
-import { ptyRequest } from '../pty-client.js';
+import { termStart, termExec, termWrite, termScreen, termStop } from '../term-client.js';
 import { showUrl } from '../open-url.js';
 import { readAuthHealthCache, } from '../auth-health.js';
 import { FLEET_LOGIN_FLOWS, KEYCHAIN_BOUND_ON_MAC, } from './auth-sync.js';
@@ -144,7 +145,7 @@ export function selectLoginTargets(devices, agents, cache, opts = {}) {
 }
 /**
  * Build the `ssh -tt <target> <loginCommand>` command string driven through the
- * PTY sidecar. `-tt` forces a tty so the remote CLI enters its interactive
+ * `term` CLI. `-tt` forces a tty so the remote CLI enters its interactive
  * device-code flow; `accept-new` learns a first-seen host key without a prompt.
  * Both the target and the login command are shell-quoted. Pure/testable.
  *
@@ -331,42 +332,42 @@ export function buildDashboardHtml(pending, mode) {
 </body>
 </html>`;
 }
-/** Real driver over the pty sidecar (`ptyRequest`). */
-export function defaultPtyDriver() {
+/** Real driver over the standalone `term` CLI (`../term-client.js`). */
+export function defaultTermDriver() {
     const expectOk = (res, what) => {
         if (!res.ok)
-            throw new Error(`pty ${what} failed: ${res.error ?? 'unknown'}`);
+            throw new Error(`term ${what} failed: ${res.error ?? 'unknown'}`);
     };
     return {
         async start(opts) {
-            const res = await ptyRequest('start', undefined, { rows: opts?.rows ?? 40, cols: opts?.cols ?? 120 });
+            const res = await termStart({ rows: opts?.rows ?? 40, cols: opts?.cols ?? 120 });
             expectOk(res, 'start');
             return res.id;
         },
         async exec(id, command) {
-            expectOk(await ptyRequest('exec', id, { command }), 'exec');
+            expectOk(await termExec(id, command), 'exec');
         },
         async write(id, input) {
-            expectOk(await ptyRequest('write', id, { input }), 'write');
+            expectOk(await termWrite(id, input), 'write');
         },
         async screen(id) {
-            const res = await ptyRequest('screen', id);
+            const res = await termScreen(id);
             expectOk(res, 'screen');
             return { screen: res.screen ?? '', exited: Boolean(res.exited) };
         },
         async stop(id) {
-            await ptyRequest('stop', id).catch(() => undefined);
+            await termStop(id).catch(() => undefined);
         },
     };
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 /**
  * Drive one remote device-code login: launch `ssh -tt <target> <loginCommand>`
- * in a PTY, send the flow's `deviceCodeSelect` keystrokes (if any) to reach the
+ * in a `term` session, send the flow's `deviceCodeSelect` keystrokes (if any) to reach the
  * device-code path, then poll the screen until {@link scrapeLogin} yields both a
  * URL and a code (or the deadline / session-exit). The human completes the code
  * in the browser; the caller polls the credential file for completion. Testable
- * against a fake {@link PtyDriver}.
+ * against a fake {@link TermDriver}.
  */
 export async function driveRemoteLogin(target, flow, driver, opts = {}, extraSshArgs = []) {
     const initialDelayMs = opts.initialDelayMs ?? 4000;
@@ -374,8 +375,8 @@ export async function driveRemoteLogin(target, flow, driver, opts = {}, extraSsh
     const timeoutMs = opts.timeoutMs ?? 90000;
     const id = await driver.start();
     // Everything past start() must tear the session down on a mid-flight throw —
-    // otherwise the caller never receives a sessionId and the PTY (and the
-    // `ssh -tt` process it drives) leaks until the sidecar's idle reaper. On the
+    // otherwise the caller never receives a sessionId and the term session (and
+    // the `ssh -tt` process it drives) leaks until term's own idle reaper. On the
     // normal return paths the caller owns stop() via the returned sessionId.
     try {
         await driver.exec(id, buildRemoteLoginSshCommand(target, flow, extraSshArgs));
@@ -412,7 +413,7 @@ export async function driveRemoteLogin(target, flow, driver, opts = {}, extraSsh
  * over the pure {@link selectLoginTargets}. Devices/agents can be narrowed by the
  * caller's flags; the default agent set is every agent with a defined flow.
  */
-export async function detectPending(opts = {}) {
+async function detectPending(opts = {}) {
     const reg = await loadDevices();
     const self = machineId();
     const online = planFleetTargets(reg)
@@ -432,7 +433,7 @@ export async function detectPending(opts = {}) {
  * bumping after the human completes the browser step. POSIX `stat` only (the
  * device-code agents are all POSIX-fleet).
  */
-export async function remoteFileMtime(target, homeRel, extraSshArgs = []) {
+async function remoteFileMtime(target, homeRel, extraSshArgs = []) {
     const cmd = `stat -c %Y "$HOME/${homeRel}" 2>/dev/null || stat -f %m "$HOME/${homeRel}" 2>/dev/null || echo 0`;
     const res = await sshExecAsync(target, cmd, { timeoutMs: 15000, multiplex: true, extraSshArgs }).catch(() => null);
     if (!res || res.code !== 0)
@@ -507,7 +508,7 @@ export async function runFleetLogin(opts = {}) {
             console.error(`  ${dashUrl}`);
         }
     }
-    const driver = opts.driver ?? defaultPtyDriver();
+    const driver = opts.driver ?? defaultTermDriver();
     const remotable = pending.filter((p) => p.remotable);
     const driveOne = async (p) => {
         const k = key(p.device, p.agent);

package/dist/lib/fleet/types.d.ts

@@ -204,14 +204,6 @@ export interface AuthFilePayload {
     /** POSIX mode to restore (e.g. 0o600 for credentials). */
     mode: number;
 }
-/** The plaintext we encrypt before shipping auth over the wire. */
-export interface AuthBundle {
-    /** Schema version for forward-compat. */
-    v: 1;
-    /** Source machine name the snapshot was taken on. */
-    source: string;
-    files: AuthFilePayload[];
-}
 /** Result of classifying one source agent's auth for propagation. */
 export interface AuthSnapshotResult {
     files: AuthFilePayload[];

package/dist/lib/fleet-cache.d.ts

@@ -1,18 +1,3 @@
-/**
- * One synchronous, disk-only read facade over the fleet/usage caches.
- *
- * These readers NEVER touch the network and NEVER SSH — they read the caches
- * the daemon keeps warm (usage snapshot, projected headroom, fleet status) and
- * return instantly. That is the whole point: the routing hot path
- * (`agents run` → rotate.ts), device affinity (smart-launch.ts), and Factory can
- * consult live-ish fleet state without paying a provider fetch or an ssh probe
- * on a latency-sensitive path.
- *
- * Writers live elsewhere (the daemon's `runUsageRefresh` for usage/headroom,
- * `runFleetStatusPublish` for the fleet-status mirror); this module is the read
- * side only.
- */
-import { type UsageSnapshot } from './accounting/usage.js';
 import { type FleetStatusRow } from './fleet-status.js';
 /**
  * The fleet-status union the daemon publishes (own row) and the fleet-status
@@ -21,10 +6,8 @@ import { type FleetStatusRow } from './fleet-status.js';
  */
 export declare function readFleetStatus(): Record<string, FleetStatusRow>;
 export type { FleetStatusRow };
-/** The last cached usage snapshot for an account, or null. Cache-only. */
-export declare function readAccountUsage(usageKey: string): UsageSnapshot | null;
 /** An account's projected headroom, as published by the daemon refresher. */
-export interface AccountHeadroom {
+interface AccountHeadroom {
     status: 'available' | 'rate_limited' | null;
     /** Projected minutes until the session window caps; null = unknown/idle. */
     minutesToLimit: number | null;

package/dist/lib/fleet-cache.js

@@ -12,7 +12,6 @@
  * `runFleetStatusPublish` for the fleet-status mirror); this module is the read
  * side only.
  */
-import { readClaudeUsageCache } from './accounting/usage.js';
 import { readHeadroomEntry } from './usage-refresh.js';
 import { readFleetStatus as readFleetStatusMirror } from './fleet-status.js';
 /**
@@ -23,10 +22,6 @@ import { readFleetStatus as readFleetStatusMirror } from './fleet-status.js';
 export function readFleetStatus() {
     return readFleetStatusMirror();
 }
-/** The last cached usage snapshot for an account, or null. Cache-only. */
-export function readAccountUsage(usageKey) {
-    return readClaudeUsageCache(usageKey);
-}
 /**
  * The daemon-computed headroom for an account, or null when nothing has been
  * published yet. Cache-only — a cold cache simply yields null, and callers

package/dist/lib/fleet-shared-repo-sync.d.ts

@@ -1,5 +1,4 @@
 export declare const FLEET_SHARED_REPO_SYNC_DEADLINE_MS = 45000;
-export declare const FLEET_SHARED_REPO_KILL_GRACE_MS = 250;
 export declare const FLEET_SHARED_REPO_OUTPUT_MAX_BYTES: number;
 /**
  * When the shared-state exchange last completed successfully, in epoch ms, or
@@ -7,13 +6,13 @@ export declare const FLEET_SHARED_REPO_OUTPUT_MAX_BYTES: number;
  * Reads the default daemon-dir marker the periodic exchange writes.
  */
 export declare function readLastSuccessfulExchangeMs(): number | null;
-export interface BoundedProcessResult {
+interface BoundedProcessResult {
     code: number | null;
     stdout: string;
     stderr: string;
     timedOut: boolean;
 }
-export interface FleetSharedRepoSyncOptions {
+interface FleetSharedRepoSyncOptions {
     userAgentsDir?: string;
     device?: string;
     timeoutMs?: number;
@@ -53,3 +52,4 @@ export declare function runBoundedProcess(command: string, args: string[], optio
  * this resolves successfully.
  */
 export declare function syncFleetSharedStateRepo(options?: FleetSharedRepoSyncOptions): Promise<FleetSharedRepoSyncResult>;
+export {};

package/dist/lib/fleet-shared-repo-sync.js

@@ -18,7 +18,7 @@ import { logAndContinueOnLockCompromised } from './lock-compromise.js';
 import { machineId } from './session/sync/config.js';
 import { getDaemonDir, getUserAgentsDir } from './state.js';
 export const FLEET_SHARED_REPO_SYNC_DEADLINE_MS = 45_000;
-export const FLEET_SHARED_REPO_KILL_GRACE_MS = 250;
+const FLEET_SHARED_REPO_KILL_GRACE_MS = 250;
 export const FLEET_SHARED_REPO_OUTPUT_MAX_BYTES = 1024 * 1024;
 const FLEET_SHARED_REPO_PUSH_ATTEMPTS = 3;
 const FLEET_SHARED_REPO_REBASE_CLEANUP_RESERVE_MS = 5_000;

package/dist/lib/fleet-shared-state.d.ts

@@ -57,12 +57,12 @@ export interface FleetSharedDeviceState {
         rows: SessionMirrorRow[];
     };
 }
-export interface FleetSharedStatePatch {
+interface FleetSharedStatePatch {
     usage?: FleetSharedDeviceState['usage'];
     auth?: FleetSharedDeviceState['auth'];
     sessions?: FleetSharedDeviceState['sessions'];
 }
-export interface FleetSharedStateReadResult {
+interface FleetSharedStateReadResult {
     states: FleetSharedDeviceState[];
     errors: Array<{
         device: string;
@@ -89,3 +89,4 @@ export declare function updateFleetSharedDeviceStateAsync(device: string, patch:
 }>;
 /** Read every valid peer-owned state file; malformed peers fail separately. */
 export declare function readFleetSharedDeviceStates(userAgentsDir?: string): FleetSharedStateReadResult;
+export {};

package/dist/lib/format.d.ts

@@ -1,5 +1,5 @@
 /** Options for {@link die} — opt into machine-readable failure output. */
-export interface DieOptions {
+interface DieOptions {
     /**
      * Emit a machine-readable `{"error", "hint"?}` object to **stdout** instead of
      * red text on stderr. Pass `isJsonMode(options)` from a `--json` command so an
@@ -61,7 +61,7 @@ export declare function relTime(iso: string): string;
 export declare function humanDuration(ms: number): string;
 /**
  * Human-readable byte size. Previously copy-pasted into five files
- * (`commands/prune.ts`, `commands/share.ts`, `commands/inspect.ts`,
+ * (`commands/prune.ts`, `commands/inspect.ts`,
  * `commands/sessions.ts`, `lib/browser/sessions-list.ts`) — this is the
  * canonical home.
  */
@@ -98,3 +98,4 @@ export declare function readStdinSync(): string;
  * stdout is a TTY; otherwise return `text` unchanged.
  */
 export declare function termLink(text: string, filePath: string): string;
+export {};

package/dist/lib/format.js

@@ -115,7 +115,7 @@ export function humanDuration(ms) {
 }
 /**
  * Human-readable byte size. Previously copy-pasted into five files
- * (`commands/prune.ts`, `commands/share.ts`, `commands/inspect.ts`,
+ * (`commands/prune.ts`, `commands/inspect.ts`,
  * `commands/sessions.ts`, `lib/browser/sessions-list.ts`) — this is the
  * canonical home.
  */

package/dist/lib/friction-heuristics.d.ts

@@ -7,7 +7,7 @@
  * an agent stuck retrying the SAME denied action instead of adapting.
  */
 import type { EventRecord } from './feed/events.js';
-export interface RepeatedGuardBlockFinding {
+interface RepeatedGuardBlockFinding {
     /** Session id the repeated blocks happened in, or 'unknown' when the
      *  friction event carried no session (e.g. a guard fired outside any
      *  tracked agent session). */
@@ -30,3 +30,4 @@ export interface RepeatedGuardBlockFinding {
 export declare function detectRepeatedGuardBlocks(events: EventRecord[], opts?: {
     minRepeats?: number;
 }): RepeatedGuardBlockFinding[];
+export {};

package/dist/lib/fs-walk.d.ts

@@ -1,5 +1,5 @@
 /** A file surfaced by the walk, carrying the mtime+size from the walk's own stat. */
-export interface WalkedFile {
+interface WalkedFile {
     path: string;
     mtimeMs: number;
     size: number;
@@ -19,3 +19,4 @@ export declare function walkForFiles(dir: string, ext: string, limit: number): s
  * Hot-path helper for the `agents run` account-recency probe.
  */
 export declare function latestFileMtimeMs(dir: string, ext: string): number | null;
+export {};

package/dist/lib/fuzzy.d.ts

@@ -11,7 +11,7 @@ export declare function levenshtein(a: string, b: string): number;
  * "one misspelling."
  */
 export declare function damerauLevenshtein(a: string, b: string): number;
-export interface FuzzyOptions {
+interface FuzzyOptions {
     /** Absolute max edit distance allowed. */
     maxDistance?: number;
     /** Max ratio of distance to input length. If set, effective threshold = min(maxDistance, floor(len * maxRatio)). */
@@ -61,3 +61,4 @@ export declare const FUZZY_PRESETS: {
         readonly maxRatio: 0.3;
     };
 };
+export {};

package/dist/lib/gemini-settings.d.ts

@@ -1,3 +1,2 @@
 export declare function readGeminiSettings(settingsPath: string): Record<string, unknown>;
-export declare function writeGeminiSettings(settingsPath: string, settings: Record<string, unknown>): void;
 export declare function updateGeminiSettings(settingsPath: string, mutate: (settings: Record<string, unknown>) => void): Record<string, unknown>;

package/dist/lib/gemini-settings.js

@@ -26,7 +26,7 @@ export function readGeminiSettings(settingsPath) {
     }
     return parsed;
 }
-export function writeGeminiSettings(settingsPath, settings) {
+function writeGeminiSettings(settingsPath, settings) {
     fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
 }

package/dist/lib/git.d.ts

@@ -48,7 +48,7 @@ export declare function assertValidBranchName(branch: string): void;
  */
 export declare function pushOrigin(git: SimpleGit, branch: string, targetBranch?: string): Promise<void>;
 /** Parsed representation of a git source string (GitHub, generic URL, or local path). */
-export interface GitSource {
+interface GitSource {
     type: 'github' | 'url' | 'local';
     url: string;
     ref?: string;
@@ -71,30 +71,19 @@ export interface GitSource {
  *   ./relative/path                  -> local path
  */
 export declare function parseSource(source: string): GitSource;
-/** Clone a remote repo or pull updates if it already exists locally. */
-export declare function cloneOrPull(source: GitSource, targetDir: string): Promise<{
-    isNew: boolean;
-    commit: string;
-}>;
 /** Clone a repository from a source string, returning the local path and commit hash. */
 export declare function cloneRepo(source: string): Promise<{
     localPath: string;
     commit: string;
     isNew: boolean;
 }>;
-/** Clone a package from a source string into the packages directory. */
-export declare function clonePackage(source: string): Promise<{
-    localPath: string;
-    commit: string;
-    isNew: boolean;
-}>;
 /** Get the short commit hash (8 chars) of the latest commit in a repo. */
 export declare function getRepoCommit(repoPath: string): Promise<string>;
 /** Compact, self-contained state of a git repo — branch, short HEAD, and a
  *  dirty flag — for cross-device comparison (RUSH-2027). Synchronous and
  *  best-effort: a non-repo or unreadable path yields `null` fields, never a
  *  throw, so a device's `doctor --json` payload always serializes. */
-export interface RepoStateSnapshot {
+interface RepoStateSnapshot {
     branch: string | null;
     head: string | null;
     dirty: boolean;
@@ -117,33 +106,10 @@ export declare function readRepoState(repoPath: string): RepoStateSnapshot | nul
 export declare function resolveSnapshotSha(repoRoot: string): string | undefined;
 /** Test seam: clear the memoized snapshot-sha cache between test cases. */
 export declare function _resetSnapshotShaCacheForTest(): void;
-/**
- * Get the current GitHub username using gh CLI.
- * Returns null if gh is not installed or user is not authenticated.
- */
-export declare function getGitHubUsername(): Promise<string | null>;
-/**
- * Resolve the GitHub username synchronously for `agents artifacts share`. Order:
- *   1. `AGENTS_SHARE_GITHUB_USER` env override
- *   2. `git config --global github.user`
- * Falls back to null so callers can decide whether to require auth or proceed
- * without a namespace.
- */
-export declare function resolveGitHubUsernameSync(): string | null;
-/**
- * Resolve the GitHub username asynchronously. Order:
- *   1. `AGENTS_SHARE_GITHUB_USER` env override
- *   2. `gh api user --jq ".login"`
- *   3. `git config --global github.user`
- * Returns null if none succeed.
- */
-export declare function resolveGitHubUsername(): Promise<string | null>;
 /**
  * Get the remote URL for origin in a git repo.
  */
 export declare function getRemoteUrl(repoPath: string): Promise<string | null>;
-/** The repo's checked-out branch, or 'main' on a detached HEAD / read failure. */
-export declare function getCurrentBranch(repoPath: string): Promise<string>;
 /**
  * Canonical `host/owner/repo` form of a git remote, transport-agnostic, so the
  * same repo cloned over SSH vs HTTPS compares equal. Strips protocol, any
@@ -178,16 +144,8 @@ export declare function isSystemRepoRemote(remote: string | null | undefined): b
 export declare function isExpectedSystemRepoRemote(remote: string | null | undefined): boolean;
 /** True when two git remote URLs point at the same repo across transport forms. */
 export declare function sameGitRemote(a: string | null | undefined, b: string | null | undefined): boolean;
-/**
- * Set the remote URL for origin in a git repo.
- */
-export declare function setRemoteUrl(repoPath: string, url: string): Promise<void>;
-/**
- * Check if a GitHub repo exists.
- */
-export declare function checkGitHubRepoExists(owner: string, repo: string): Promise<boolean>;
 /** Result of {@link commitAndPush}. */
-export type CommitAndPushResult = {
+type CommitAndPushResult = {
     success: boolean;
     error?: string;
     /** Human detail for success: "already up to date", "pushed abc..def", "committed and pushed …". */
@@ -318,7 +276,7 @@ export declare function resolveUserRepoRemoteUrl(dir: string): string | null;
  * real local edit and left alone — it surfaces as a modified path instead.
  */
 export declare function isStaleAgentsYamlStub(local: string, committed: string): boolean;
-export interface AdoptInPlaceResult {
+interface AdoptInPlaceResult {
     success: boolean;
     commit: string;
     /** Tracked files that were absent locally and materialized from origin/main. */
@@ -384,10 +342,6 @@ export declare function adoptUserRepoIfNeeded(dir: string, opts?: {
  * {@link isSystemRepoRemote}.
  */
 export declare function isSystemRepoOrigin(dir: string): Promise<boolean>;
-/**
- * Check if repo has uncommitted changes (including untracked files).
- */
-export declare function hasLocalChanges(dir: string): Promise<boolean>;
 /**
  * Render an absolute path in ~-relative form with forward slashes, matching the
  * way the rest of the CLI prints home-anchored paths (e.g. `~/.agents/.system`).
@@ -468,7 +422,7 @@ export declare function syncRepoGit(dir: string, opts: {
  * Get git status for sync display.
  * Returns files categorized by their status relative to HEAD.
  */
-export interface GitSyncStatus {
+interface GitSyncStatus {
     /** Tracked and unchanged files. */
     synced: string[];
     /** Modified but not staged files. */
@@ -486,38 +440,9 @@ export declare function getGitSyncStatus(dir: string, subdir?: string): Promise<
  * Get list of files tracked by git in a directory.
  */
 export declare function getTrackedFiles(dir: string, subdir?: string): Promise<string[]>;
-/**
- * Check if upstream remote is configured.
- */
-export declare function hasUpstreamRemote(dir: string): Promise<boolean>;
-/**
- * Get the upstream remote fetch URL, or null if none configured.
- */
-export declare function getUpstreamUrl(dir: string): Promise<string | null>;
-/**
- * Add or update the upstream remote.
- */
-export declare function setUpstreamRemote(dir: string, url: string): Promise<void>;
-/**
- * Pull from upstream remote (merge updates from system repo).
- */
-export declare function pullFromUpstream(dir: string): Promise<{
-    success: boolean;
-    commit: string;
-    error?: string;
-}>;
-/**
- * Try to auto-pull a git repo if it's clean and has a remote.
- * Uses --ff-only for safety (fails if diverged instead of creating merge commits).
- * Returns silently on success, returns error message on failure.
- */
-export declare function tryAutoPull(dir: string): Promise<{
-    pulled: boolean;
-    error?: string;
-}>;
 /** Result of {@link tryAutoPullSystemRepo}. `refused` is set only when the pull
  *  was blocked because origin is not the expected system remote. */
-export interface SystemRepoPullResult {
+interface SystemRepoPullResult {
     pulled: boolean;
     error?: string;
     /** True when origin is present but is NOT the expected system remote; no
@@ -552,3 +477,4 @@ export declare function commitsBehindUpstream(dir: string): {
     behind: number;
     branch: string;
 } | null;
+export {};