@phnx-labs/agents-cli 1.22.113 → 1.22.115

package/dist/cli/command-registry.js

@@ -26,78 +26,74 @@ export { KNOWN_TOP_LEVEL_COMMANDS, RETIRED_TOP_LEVEL_COMMANDS } from '../lib/sta
 // One loader per command module. Each dynamically imports the module and hands
 // back its register function. Kept as named consts so src/index.ts can compose
 // them into the exact main-branch registration order for the slow path.
-export const loadView = async () => (await import('../commands/view.js')).registerViewCommand;
-export const loadInspect = async () => (await import('../commands/inspect.js')).registerInspectCommand;
-export const loadFeedback = async () => (await import('../commands/feedback.js')).registerFeedbackCommand;
-export const loadCommands = async () => (await import('../commands/commands.js')).registerCommandsCommands;
-export const loadHooks = async () => (await import('../commands/hooks.js')).registerHooksCommands;
-export const loadSkills = async () => (await import('../commands/skills.js')).registerSkillsCommands;
-export const loadRules = async () => (await import('../commands/rules.js')).registerRulesCommands;
-export const loadMemory = async () => (await import('../commands/memory.js')).registerMemoryCommands;
-export const loadPermissions = async () => (await import('../commands/permissions.js')).registerPermissionsCommands;
-export const loadMcp = async () => (await import('../commands/mcp.js')).registerMcpCommands;
-export const loadCli = async () => (await import('../commands/cli.js')).registerCliCommands;
-export const loadSubagents = async () => (await import('../commands/subagents.js')).registerSubagentsCommands;
-export const loadPlugins = async () => (await import('../commands/plugins.js')).registerPluginsCommands;
-export const loadWorkflows = async () => (await import('../commands/workflows.js')).registerWorkflowsCommands;
+const loadView = async () => (await import('../commands/view.js')).registerViewCommand;
+const loadInspect = async () => (await import('../commands/inspect.js')).registerInspectCommand;
+const loadFeedback = async () => (await import('../commands/feedback.js')).registerFeedbackCommand;
+const loadCommands = async () => (await import('../commands/commands.js')).registerCommandsCommands;
+const loadHooks = async () => (await import('../commands/hooks.js')).registerHooksCommands;
+const loadSkills = async () => (await import('../commands/skills.js')).registerSkillsCommands;
+const loadRules = async () => (await import('../commands/rules.js')).registerRulesCommands;
+const loadMemory = async () => (await import('../commands/memory.js')).registerMemoryCommands;
+const loadPermissions = async () => (await import('../commands/permissions.js')).registerPermissionsCommands;
+const loadMcp = async () => (await import('../commands/mcp.js')).registerMcpCommands;
+const loadCli = async () => (await import('../commands/cli.js')).registerCliCommands;
+const loadSubagents = async () => (await import('../commands/subagents.js')).registerSubagentsCommands;
+const loadPlugins = async () => (await import('../commands/plugins.js')).registerPluginsCommands;
+const loadWorkflows = async () => (await import('../commands/workflows.js')).registerWorkflowsCommands;
 export const loadVersions = async () => (await import('../commands/versions.js')).registerVersionsCommands;
 export const loadUpdate = async () => (await import('../commands/update.js')).registerUpdateCommand;
-export const loadImport = async () => (await import('../commands/import.js')).registerImportCommand;
-export const loadPackages = async () => (await import('../commands/packages.js')).registerPackagesCommands;
-export const loadRoutines = async () => (await import('../commands/routines.js')).registerRoutinesCommands;
-export const loadMonitors = async () => (await import('../commands/monitors.js')).registerMonitorsCommands;
-export const loadProjects = async () => (await import('../commands/projects.js')).registerProjectsCommands;
+const loadImport = async () => (await import('../commands/import.js')).registerImportCommand;
+const loadPackages = async () => (await import('../commands/packages.js')).registerPackagesCommands;
+const loadRoutines = async () => (await import('../commands/routines.js')).registerRoutinesCommands;
+const loadMonitors = async () => (await import('../commands/monitors.js')).registerMonitorsCommands;
+const loadProjects = async () => (await import('../commands/projects.js')).registerProjectsCommands;
 export const loadRun = async () => (await import('../commands/exec.js')).registerRunCommand;
-export const loadOpen = async () => (await import('../commands/open.js')).registerOpenCommand;
-export const loadReconnect = async () => (await import('../commands/reconnect.js')).registerReconnectCommand;
-export const loadFork = async () => (await import('../commands/fork.js')).registerForkCommand;
-export const loadConfig = async () => (await import('../commands/config.js')).registerConfigCommand;
-export const loadModels = async () => (await import('../commands/models.js')).registerModelsCommand;
-export const loadModes = async () => (await import('../commands/modes.js')).registerModesCommand;
+const loadOpen = async () => (await import('../commands/open.js')).registerOpenCommand;
+const loadFork = async () => (await import('../commands/fork.js')).registerForkCommand;
+const loadConfig = async () => (await import('../commands/config.js')).registerConfigCommand;
+const loadModels = async () => (await import('../commands/models.js')).registerModelsCommand;
+const loadModes = async () => (await import('../commands/modes.js')).registerModesCommand;
 export const loadPrune = async () => (await import('../commands/prune.js')).registerPruneCommand;
-export const loadTrash = async () => (await import('../commands/trash.js')).registerTrashCommands;
-export const loadRestore = async () => (await import('../commands/trash.js')).registerRestoreCommand;
+const loadTrash = async () => (await import('../commands/trash.js')).registerTrashCommands;
+const loadRestore = async () => (await import('../commands/trash.js')).registerRestoreCommand;
 export const loadDoctor = async () => (await import('../commands/doctor.js')).registerDoctorCommand;
-export const loadRoute = async () => (await import('../commands/route.js')).registerRouteCommands;
-export const loadHarness = async () => (await import('../commands/harness.js')).registerHarnessCommands;
+const loadRoute = async () => (await import('../commands/route.js')).registerRouteCommands;
+const loadHarness = async () => (await import('../commands/harness.js')).registerHarnessCommands;
 // PHNX-3989: `agents secrets` is a thin passthrough to the standalone
 // `secrets` CLI (secrets-passthrough.ts). The legacy in-repo engine and its
 // own command registrar are gone (Track D, tasks.md item 7) — the standalone
 // `@phnx-labs/secrets-cli` package is the only implementation.
-export const loadSecrets = async () => (await import('../commands/secrets-passthrough.js')).registerSecretsCommands;
-export const loadMenubar = async () => (await import('../commands/menubar.js')).registerMenubarCommands;
-export const loadSync = async () => (await import('../commands/sync.js')).registerSyncCommand;
-export const loadRefreshRules = async () => (await import('../commands/refresh-rules.js')).registerRefreshRulesCommand;
-export const loadFactory = async () => (await import('../commands/factory.js')).registerFactoryCommands;
-export const loadInsights = async () => (await import('../commands/insights.js')).registerInsightsCommand;
-export const loadTrace = async () => (await import('../commands/sessions-trace.js')).registerTraceCommand;
-export const loadPty = async () => (await import('../commands/pty.js')).registerPtyCommands;
-export const loadTmux = async () => (await import('../commands/tmux.js')).registerTmuxCommands;
-export const loadWatchdog = async () => (await import('../commands/watchdog.js')).registerWatchdogCommand;
-export const loadBrowser = async () => (await import('../commands/browser.js')).registerBrowserCommand;
-export const loadComputer = async () => (await import('../commands/computer.js')).registerComputerCommand;
-export const loadLogs = async () => (await import('../commands/logs.js')).registerLogsCommand;
-export const loadEvents = async () => (await import('../commands/events.js')).registerEventsCommand;
-export const loadSsh = async () => (await import('../commands/ssh.js')).registerSshCommands;
-export const loadRepo = async () => (await import('../commands/repo.js')).registerRepoCommands;
-export const loadSetup = async () => (await import('../commands/setup.js')).registerSetupCommand;
-export const loadUninstall = async () => (await import('../commands/uninstall.js')).registerUninstallCommands;
-export const loadUpgrade = async () => (await import('../commands/upgrade.js')).registerUpgradeCommand;
+const loadSecrets = async () => (await import('../commands/secrets-passthrough.js')).registerSecretsCommands;
+const loadMenubar = async () => (await import('../commands/menubar.js')).registerMenubarCommands;
+const loadSync = async () => (await import('../commands/sync.js')).registerSyncCommand;
+const loadRefreshRules = async () => (await import('../commands/refresh-rules.js')).registerRefreshRulesCommand;
+const loadFactory = async () => (await import('../commands/factory.js')).registerFactoryCommands;
+const loadInsights = async () => (await import('../commands/insights.js')).registerInsightsCommand;
+const loadTrace = async () => (await import('../commands/sessions-trace.js')).registerTraceCommand;
+const loadTmux = async () => (await import('../commands/tmux.js')).registerTmuxCommands;
+const loadWatchdog = async () => (await import('../commands/watchdog.js')).registerWatchdogCommand;
+const loadBrowser = async () => (await import('../commands/browser.js')).registerBrowserCommand;
+const loadComputer = async () => (await import('../commands/computer.js')).registerComputerCommand;
+const loadLogs = async () => (await import('../commands/logs.js')).registerLogsCommand;
+const loadEvents = async () => (await import('../commands/events.js')).registerEventsCommand;
+const loadSsh = async () => (await import('../commands/ssh.js')).registerSshCommands;
+const loadRepo = async () => (await import('../commands/repo.js')).registerRepoCommands;
+const loadSetup = async () => (await import('../commands/setup.js')).registerSetupCommand;
+const loadUninstall = async () => (await import('../commands/uninstall.js')).registerUninstallCommands;
+const loadUpgrade = async () => (await import('../commands/upgrade.js')).registerUpgradeCommand;
 export const loadSessions = async () => (await import('../commands/sessions.js')).registerSessionsCommands;
 export const loadTeams = async () => (await import('../commands/teams.js')).registerTeamsCommands;
-export const loadCloud = async () => (await import('../commands/cloud.js')).registerCloudCommands;
-export const loadMessage = async () => (await import('../commands/message.js')).registerMessageCommand;
-export const loadSend = async () => (await import('../commands/send.js')).registerSendCommand;
-export const loadFeed = async () => (await import('../commands/feed.js')).registerFeedCommand;
-export const loadMailboxes = async () => (await import('../commands/mailboxes.js')).registerMailboxesCommand;
-// Registers the `artifacts` group (`share` + `setup` + nested `unshare`).
-export const loadArtifacts = async () => (await import('../commands/artifacts.js')).registerArtifactsCommands;
-export const loadWebhooks = async () => (await import('../commands/webhook.js')).registerWebhooksCommand;
-export const loadHumans = async () => (await import('../commands/humans.js')).registerHumansCommands;
-export const loadAccounts = async () => (await import('../commands/accounts.js')).registerAccountsCommand;
-export const loadDaemon = async () => (await import('../commands/daemon.js')).registerDaemonCommand;
-export const loadAuth = async () => (await import('../commands/auth.js')).registerAuthCommand;
-export const loadTraces = async () => (await import('../commands/traces.js')).registerTracesCommands;
+const loadCloud = async () => (await import('../commands/cloud.js')).registerCloudCommands;
+const loadMessage = async () => (await import('../commands/message.js')).registerMessageCommand;
+const loadSend = async () => (await import('../commands/send.js')).registerSendCommand;
+const loadFeed = async () => (await import('../commands/feed.js')).registerFeedCommand;
+const loadMailboxes = async () => (await import('../commands/mailboxes.js')).registerMailboxesCommand;
+const loadWebhooks = async () => (await import('../commands/webhook.js')).registerWebhooksCommand;
+const loadHumans = async () => (await import('../commands/humans.js')).registerHumansCommands;
+const loadAccounts = async () => (await import('../commands/accounts.js')).registerAccountsCommand;
+const loadDaemon = async () => (await import('../commands/daemon.js')).registerDaemonCommand;
+const loadAuth = async () => (await import('../commands/auth.js')).registerAuthCommand;
+const loadTraces = async () => (await import('../commands/traces.js')).registerTracesCommands;
 export const loadReminders = async () => (await import('../commands/reminders.js')).registerRemindersCommand;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
@@ -109,7 +105,6 @@ export const loadReminders = async () => (await import('../commands/reminders.js
 // `roster` was a sessions --active alias — removed; use sessions --active.
 export const LAZY_COMMAND_NAMES = new Set([
     'sessions',
-    'reconnect',
     'teams',
     'cloud',
     'message',
@@ -166,7 +161,6 @@ export const COMMAND_LOADERS = {
     // tokens must lazy-load the same module so either resolves. See commands/open.ts.
     _callback: [loadOpen],
     open: [loadOpen],
-    reconnect: [loadReconnect],
     fork: [loadFork],
     config: [loadConfig],
     models: [loadModels],
@@ -187,7 +181,6 @@ export const COMMAND_LOADERS = {
     // `agents trace` is a top-level alias of `agents sessions trace` (precedent:
     // `agents insights` aliases `agents sessions insights`). One implementation.
     trace: [loadTrace],
-    pty: [loadPty],
     tmux: [loadTmux],
     watchdog: [loadWatchdog],
     browser: [loadBrowser],
@@ -212,11 +205,9 @@ export const COMMAND_LOADERS = {
     cloud: [loadCloud],
     message: [loadMessage],
     send: [loadSend],
-    notify: [loadSend],
     feed: [loadFeed],
     mailboxes: [loadMailboxes],
     mailbox: [loadMailboxes],
-    artifacts: [loadArtifacts],
     webhooks: [loadWebhooks],
     humans: [loadHumans],
     daemon: [loadDaemon],

package/dist/commands/accounts.d.ts

@@ -1,45 +1,7 @@
 import type { Command } from 'commander';
 import type { AgentId } from '../lib/types.js';
-import { collectRunCandidates, type RotateCandidate } from '../lib/accounting/rotate.js';
-import { type Profile } from '../lib/profiles.js';
 import { type NativeAccountCatalogRow, type ProviderAccountCatalogRow } from '../lib/account-catalog.js';
 import { type UnifiedAccount } from '../lib/account-registry.js';
-export declare function nativeIdentityFromSource(raw: string): Promise<{
-    agent: AgentId;
-    version: string;
-    identityKey: string;
-    identityLabel?: string;
-    scope: 'version' | 'device';
-}>;
-type AttachTarget = {
-    kind: 'installation';
-    agent: AgentId;
-    version: string;
-} | {
-    kind: 'device-agent';
-    agent: AgentId;
-} | {
-    kind: 'profile';
-    profile: Profile;
-};
-/**
- * Classify + validate an attach target, rejecting a typo BEFORE any binding is
- * written: it must be an existing custom-harness profile, an installed
- * `agent@version`, or a known harness id.
- */
-export declare function classifyAttachTarget(target: string): AttachTarget;
-/**
- * Persist the attached setup-token to a per-version `.oauth_token` file so an
- * INTERACTIVE Claude launch on a keychain-less Linux worker can authenticate from it.
- * Headless runs inject the token via `buildExecEnv`. Since PHNX-3502 an interactive
- * launch on a worker-role device ALSO injects it through `claudeAdapter.applyExecConfigEnv`
- * (only a headed `personal`/`desktop` device defers to its per-version native login), and
- * the shim's Linux fallback (`claudeAdapter.shimConfigEnvBash`) reads exactly this file —
- * so writing it is what makes a freshly-attached setup-token visible to that shim fallback
- * on a worker. macOS keeps the credential in the keychain, so `resolveClaudeSetupToken`
- * returns null there and this is a no-op off Linux.
- */
-export declare function writeClaudeInteractiveOauthToken(target: AttachTarget, targetAgent: AgentId, email?: string): void;
 export declare function parseBundleKey(raw: string): {
     bundle: string;
     key: string;
@@ -49,52 +11,17 @@ export declare function renderAccountList(native: NativeAccountCatalogRow[], pro
     harness?: AgentId;
     localDevice?: string;
 }): string;
-/** One labelable signed-in identity, folded across every version it is signed into. */
-export interface LabelIdentity {
-    identityKey: string;
-    email: string | null;
-    versions: string[];
-    isDefault: boolean;
-}
-/**
- * Fold signed-in run candidates into distinct identities — the unit a label
- * binds to. The same account signed into several versions is ONE row, so a
- * multi-version single-account harness never demands a selector. Candidates
- * with no stable identity (no accountKey, no email) are dropped: there is
- * nothing durable for a label to bind to. Default-version identity first.
- */
-export declare function groupLabelIdentities(candidates: Pick<RotateCandidate, 'version' | 'email' | 'accountKey'>[], defaultVersion: string | null): LabelIdentity[];
-export type LabelSelection = {
-    kind: 'selected';
-    identity: LabelIdentity;
-} | {
-    kind: 'ambiguous';
-    identities: LabelIdentity[];
-};
-/**
- * Resolve which signed-in login a bare-harness `accounts label` call means.
- * `collect` is injectable (the `resolveRunVersion` pattern) so tests drive the
- * real selection path against fixture candidates.
- */
-export declare function resolveLabelIdentity(agent: AgentId, accountSelector: string | undefined, collect?: typeof collectRunCandidates): Promise<LabelSelection>;
-/**
- * Body of `accounts label`, exported with the injectable candidate collector
- * so tests exercise everything but the TTY prompt itself.
- */
-export declare function runAccountsLabel(source: string, label: string | undefined, opts: {
-    account?: string;
-}, collect?: typeof collectRunCandidates): Promise<void>;
-/** Named accounts that `set-default` / `switch` can pin for this harness. */
+/** Named accounts that `accounts default` can pin for this harness. */
 export declare function listSwitchableAccounts(agent: AgentId): Promise<UnifiedAccount[]>;
 /**
- * Pin the per-harness default. Shared by `accounts set-default` and `accounts switch`.
+ * Pin the per-harness default — the `accounts default` write path.
  * Provider accounts must authenticate the harness; native accounts must belong to it.
  */
 export declare function setDefaultAccount(agentRaw: string, name: string): {
     agent: AgentId;
     account: UnifiedAccount;
 };
-export declare function runAccountsSwitch(harness: string, accountName: string | undefined, opts: {
+export declare function runAccountsDefault(harness: string, accountName: string | undefined, opts: {
     json: boolean;
 }): Promise<void>;
 /**
@@ -118,4 +45,3 @@ export declare function resolveLogoutTarget(target: string): Promise<{
     version: string;
 }>;
 export declare function registerAccountsCommand(program: Command): void;
-export {};