@phnx-labs/agents-cli 1.20.72 → 1.20.74

package/dist/lib/staleness/writers/sources.js

@@ -35,6 +35,50 @@ function isLiveDir(p) {
         return false;
     }
 }
+function readPluginManifest(pluginRoot) {
+    const manifestPath = path.join(pluginRoot, '.claude-plugin', 'plugin.json');
+    if (!isLiveFile(manifestPath))
+        return null;
+    try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        if (!manifest.name || !manifest.version)
+            return null;
+        return manifest;
+    }
+    catch {
+        return null;
+    }
+}
+function pluginSupportsAgent(manifest, agent) {
+    if (!agent)
+        return true;
+    return !manifest.agents || manifest.agents.length === 0 || manifest.agents.includes(agent);
+}
+function pluginSkillDirs(options = {}) {
+    const dirs = [];
+    for (const base of trustedSourceBases()) {
+        const pluginsDir = path.join(base.dir, 'plugins');
+        let entries;
+        try {
+            entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            if (options.plugins && !options.plugins.has(entry.name))
+                continue;
+            const pluginRoot = path.join(pluginsDir, entry.name);
+            const manifest = readPluginManifest(pluginRoot);
+            if (!manifest || !pluginSupportsAgent(manifest, options.agent))
+                continue;
+            dirs.push(path.join(pluginRoot, 'skills'));
+        }
+    }
+    return dirs;
+}
 /** Find the trusted source for a command markdown by name. */
 export function resolveCommandSource(name) {
     const candidates = [
@@ -45,14 +89,36 @@ export function resolveCommandSource(name) {
     return candidates.find(isLiveFile) ?? null;
 }
 /** Find the trusted source directory for a skill by name. */
-export function resolveSkillSource(name) {
+export function resolveSkillSource(name, options = {}) {
     const candidates = [
         safeJoin(path.join(getUserAgentsDir(), 'skills'), name),
         safeJoin(getSkillsDir(), name),
         ...getEnabledExtraRepos().map((e) => safeJoin(path.join(e.dir, 'skills'), name)),
+        ...pluginSkillDirs(options).map((skillsDir) => safeJoin(skillsDir, name)),
     ];
     return candidates.find(isLiveDir) ?? null;
 }
+/** List trusted plugin-bundled skill names, filtered to an optional plugin/agent scope. */
+export function listPluginSkillNames(options = {}) {
+    const names = new Set();
+    for (const skillsDir of pluginSkillDirs(options)) {
+        let entries;
+        try {
+            entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            if (isLiveFile(path.join(skillsDir, entry.name, 'SKILL.md'))) {
+                names.add(entry.name);
+            }
+        }
+    }
+    return Array.from(names);
+}
 /** Find the trusted source file for a hook by name. */
 export function resolveHookSource(name) {
     const candidates = [
@@ -68,5 +134,6 @@ export function trustedSkillRoots() {
         path.join(getUserAgentsDir(), 'skills'),
         getSkillsDir(),
         ...getEnabledExtraRepos().map((e) => path.join(e.dir, 'skills')),
+        ...pluginSkillDirs(),
     ];
 }

package/dist/lib/star-nudge.d.ts

@@ -0,0 +1,45 @@
+/**
+ * One-time "star us on GitHub" nudge.
+ *
+ * Printed a single time, ever, after a user's first *successful* headline run
+ * (`agents run` / `agents teams`). Modelled on the existing warn-once sentinel
+ * pattern (see maybeWarnMultiInstall in src/index.ts): a marker under the
+ * regenerable runtime-state dir records that the hint was shown so it never
+ * repeats. It is a plain inline line — not a toast, not a nag — and stays out
+ * of the way of non-interactive, CI, quiet, and JSON output.
+ */
+/** Canonical GitHub repo the nudge points at. */
+export declare const REPO_URL = "https://github.com/phnx-labs/agents-cli";
+/** Has the star nudge already been shown on this machine? */
+export declare function hasShownStarNudge(): boolean;
+/** Inputs to the pure show/skip decision (kept side-effect free for testing). */
+export interface StarNudgeContext {
+    /** Caller asked for quiet / JSON output. */
+    quiet?: boolean;
+    /** stdout is attached to an interactive terminal. */
+    isTTY: boolean;
+    /** CI is set in the environment. */
+    ci: boolean;
+    /** User opted out via AGENTS_NO_NUDGE=1. */
+    optedOut: boolean;
+    /** The one-time sentinel already exists. */
+    alreadyShown: boolean;
+}
+/**
+ * Pure decision: should the one-time star nudge be shown? Skipped for
+ * quiet/JSON output, non-interactive terminals (pipes, redirects), CI, an
+ * explicit opt-out, or once it has already been shown.
+ */
+export declare function shouldShowStarNudge(ctx: StarNudgeContext): boolean;
+/**
+ * Show the one-time star nudge if it hasn't been shown yet and the context is
+ * appropriate. Best-effort by contract: never throws, never blocks the run it
+ * follows.
+ *
+ * Skipped when: the caller asked for quiet/JSON output, stdout is not an
+ * interactive terminal (pipes, redirects), CI is set, or the user opted out
+ * with AGENTS_NO_NUDGE=1.
+ */
+export declare function maybeShowStarNudge(opts?: {
+    quiet?: boolean;
+}): void;

package/dist/lib/star-nudge.js

@@ -0,0 +1,91 @@
+/**
+ * One-time "star us on GitHub" nudge.
+ *
+ * Printed a single time, ever, after a user's first *successful* headline run
+ * (`agents run` / `agents teams`). Modelled on the existing warn-once sentinel
+ * pattern (see maybeWarnMultiInstall in src/index.ts): a marker under the
+ * regenerable runtime-state dir records that the hint was shown so it never
+ * repeats. It is a plain inline line — not a toast, not a nag — and stays out
+ * of the way of non-interactive, CI, quiet, and JSON output.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { getRuntimeStateDir } from './state.js';
+/** Canonical GitHub repo the nudge points at. */
+export const REPO_URL = 'https://github.com/phnx-labs/agents-cli';
+/** Sentinel written the first (and only) time the nudge is shown. */
+function nudgeSentinelPath() {
+    return path.join(getRuntimeStateDir(), 'star-nudge-shown');
+}
+/** Has the star nudge already been shown on this machine? */
+export function hasShownStarNudge() {
+    try {
+        return fs.existsSync(nudgeSentinelPath());
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Pure decision: should the one-time star nudge be shown? Skipped for
+ * quiet/JSON output, non-interactive terminals (pipes, redirects), CI, an
+ * explicit opt-out, or once it has already been shown.
+ */
+export function shouldShowStarNudge(ctx) {
+    if (ctx.quiet)
+        return false;
+    if (!ctx.isTTY)
+        return false;
+    if (ctx.ci)
+        return false;
+    if (ctx.optedOut)
+        return false;
+    if (ctx.alreadyShown)
+        return false;
+    return true;
+}
+/**
+ * Show the one-time star nudge if it hasn't been shown yet and the context is
+ * appropriate. Best-effort by contract: never throws, never blocks the run it
+ * follows.
+ *
+ * Skipped when: the caller asked for quiet/JSON output, stdout is not an
+ * interactive terminal (pipes, redirects), CI is set, or the user opted out
+ * with AGENTS_NO_NUDGE=1.
+ */
+export function maybeShowStarNudge(opts = {}) {
+    try {
+        const show = shouldShowStarNudge({
+            quiet: opts.quiet,
+            isTTY: Boolean(process.stdout.isTTY),
+            ci: Boolean(process.env.CI),
+            optedOut: process.env.AGENTS_NO_NUDGE === '1',
+            alreadyShown: hasShownStarNudge(),
+        });
+        if (!show)
+            return;
+        // Claim the one-time slot with an ATOMIC exclusive create (O_EXCL). The
+        // hasShownStarNudge() check above is only a cheap fast-path; the existsSync
+        // + write pair is a TOCTOU race across processes, and `agents teams` spawns
+        // many at once. The `wx` flag makes the create itself the arbiter: exactly
+        // one process succeeds, every other gets EEXIST and stays silent — so the
+        // hint prints at most once even under concurrent completions.
+        const sentinel = nudgeSentinelPath();
+        fs.mkdirSync(path.dirname(sentinel), { recursive: true });
+        try {
+            fs.writeFileSync(sentinel, new Date().toISOString(), { flag: 'wx' });
+        }
+        catch (e) {
+            if (e.code === 'EEXIST')
+                return; // another process won the race
+            throw e; // real write failure -> caught by the outer best-effort guard
+        }
+        console.log('\n' +
+            chalk.gray('Enjoying agents-cli? Give it a star to help others find it: ') +
+            chalk.cyan(REPO_URL));
+    }
+    catch {
+        /* best-effort: a nudge must never break a successful run */
+    }
+}

package/dist/lib/startup/command-registry.d.ts

@@ -25,6 +25,7 @@ export type Registrar = (program: Command) => void;
 export type ModuleLoader = () => Promise<Registrar>;
 export declare const loadView: ModuleLoader;
 export declare const loadInspect: ModuleLoader;
+export declare const loadResources: ModuleLoader;
 export declare const loadFeedback: ModuleLoader;
 export declare const loadCommands: ModuleLoader;
 export declare const loadHooks: ModuleLoader;
@@ -40,8 +41,8 @@ export declare const loadWorkflows: ModuleLoader;
 export declare const loadWorktree: ModuleLoader;
 export declare const loadVersions: ModuleLoader;
 export declare const loadImport: ModuleLoader;
+export declare const loadExport: ModuleLoader;
 export declare const loadPackages: ModuleLoader;
-export declare const loadDaemon: ModuleLoader;
 export declare const loadRoutines: ModuleLoader;
 export declare const loadMonitors: ModuleLoader;
 export declare const loadRun: ModuleLoader;
@@ -57,6 +58,7 @@ export declare const loadCheck: ModuleLoader;
 export declare const loadStatus: ModuleLoader;
 export declare const loadProfiles: ModuleLoader;
 export declare const loadSecrets: ModuleLoader;
+export declare const loadLogin: ModuleLoader;
 export declare const loadWallet: ModuleLoader;
 export declare const loadHelper: ModuleLoader;
 export declare const loadMenubar: ModuleLoader;
@@ -71,6 +73,7 @@ export declare const loadCost: ModuleLoader;
 export declare const loadOutput: ModuleLoader;
 export declare const loadBudget: ModuleLoader;
 export declare const loadAlias: ModuleLoader;
+export declare const loadMine: ModuleLoader;
 export declare const loadPty: ModuleLoader;
 export declare const loadTmux: ModuleLoader;
 export declare const loadWatchdog: ModuleLoader;
@@ -90,7 +93,10 @@ export declare const loadSessions: ModuleLoader;
 export declare const loadTeams: ModuleLoader;
 export declare const loadCloud: ModuleLoader;
 export declare const loadMessage: ModuleLoader;
+export declare const loadSend: ModuleLoader;
+export declare const loadHq: ModuleLoader;
 export declare const loadFeed: ModuleLoader;
+export declare const loadActivity: ModuleLoader;
 export declare const loadMailboxes: ModuleLoader;
 export declare const loadServe: ModuleLoader;
 export declare const loadShare: ModuleLoader;

package/dist/lib/startup/command-registry.js

@@ -3,6 +3,7 @@
 // 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 loadResources = async () => (await import('../../commands/resources.js')).registerResourcesCommand;
 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;
@@ -18,8 +19,8 @@ export const loadWorkflows = async () => (await import('../../commands/workflows
 export const loadWorktree = async () => (await import('../../commands/worktree.js')).registerWorktreeCommands;
 export const loadVersions = async () => (await import('../../commands/versions.js')).registerVersionsCommands;
 export const loadImport = async () => (await import('../../commands/import.js')).registerImportCommand;
+export const loadExport = async () => (await import('../../commands/export.js')).registerExportCommand;
 export const loadPackages = async () => (await import('../../commands/packages.js')).registerPackagesCommands;
-export const loadDaemon = async () => (await import('../../commands/daemon.js')).registerDaemonCommands;
 export const loadRoutines = async () => (await import('../../commands/routines.js')).registerRoutinesCommands;
 export const loadMonitors = async () => (await import('../../commands/monitors.js')).registerMonitorsCommands;
 export const loadRun = async () => (await import('../../commands/exec.js')).registerRunCommand;
@@ -35,6 +36,7 @@ export const loadCheck = async () => (await import('../../commands/check.js')).r
 export const loadStatus = async () => (await import('../../commands/status.js')).registerStatusCommand;
 export const loadProfiles = async () => (await import('../../commands/profiles.js')).registerProfilesCommands;
 export const loadSecrets = async () => (await import('../../commands/secrets.js')).registerSecretsCommands;
+export const loadLogin = async () => (await import('../../commands/login.js')).registerLoginCommands;
 export const loadWallet = async () => (await import('../../commands/wallet.js')).registerWalletCommands;
 export const loadHelper = async () => (await import('../../commands/helper.js')).registerHelperCommand;
 export const loadMenubar = async () => (await import('../../commands/menubar.js')).registerMenubarCommands;
@@ -49,6 +51,7 @@ export const loadCost = async () => (await import('../../commands/cost.js')).reg
 export const loadOutput = async () => (await import('../../commands/output.js')).registerOutputCommand;
 export const loadBudget = async () => (await import('../../commands/budget.js')).registerBudgetCommand;
 export const loadAlias = async () => (await import('../../commands/alias.js')).registerAliasCommand;
+export const loadMine = async () => (await import('../../commands/mine.js')).registerMineCommand;
 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;
@@ -68,7 +71,10 @@ export const loadSessions = async () => (await import('../../commands/sessions.j
 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 loadHq = async () => (await import('../../commands/hq.js')).registerHqCommand;
 export const loadFeed = async () => (await import('../../commands/feed.js')).registerFeedCommand;
+export const loadActivity = async () => (await import('../../commands/activity.js')).registerActivityCommand;
 export const loadMailboxes = async () => (await import('../../commands/mailboxes.js')).registerMailboxesCommand;
 export const loadServe = async () => (await import('../../commands/serve.js')).registerServeCommand;
 export const loadShare = async () => (await import('../../commands/share.js')).registerShareCommands;
@@ -82,7 +88,7 @@ export const loadFunnel = async () => (await import('../../commands/funnel.js'))
  * inherit the root's custom help formatter rather than getting the per-command
  * recursive pass. Keeping that ordering preserves their `--help` output exactly.
  */
-export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'message', 'serve']);
+export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'message', 'hq', 'serve']);
 /**
  * User-typed top-level command name -> ordered list of module loaders to run.
  *
@@ -100,6 +106,7 @@ export const LAZY_COMMAND_NAMES = new Set(['sessions', 'teams', 'cloud', 'messag
 export const COMMAND_LOADERS = {
     view: [loadView],
     inspect: [loadInspect],
+    resources: [loadResources],
     feedback: [loadFeedback],
     commands: [loadCommands],
     hooks: [loadHooks],
@@ -121,10 +128,10 @@ export const COMMAND_LOADERS = {
     purge: [loadVersions],
     prune: [loadVersions, loadPrune],
     import: [loadImport],
+    export: [loadExport],
     registry: [loadPackages],
     search: [loadPackages],
     install: [loadPackages],
-    daemon: [loadDaemon],
     routines: [loadRoutines],
     monitors: [loadMonitors],
     run: [loadRun],
@@ -137,8 +144,12 @@ export const COMMAND_LOADERS = {
     apply: [loadApply],
     check: [loadCheck],
     status: [loadStatus],
+    profile: [loadProfiles],
     profiles: [loadProfiles],
     secrets: [loadSecrets],
+    login: [loadLogin],
+    logout: [loadLogin],
+    whoami: [loadLogin],
     wallet: [loadWallet],
     helper: [loadHelper],
     menubar: [loadMenubar],
@@ -153,6 +164,7 @@ export const COMMAND_LOADERS = {
     output: [loadOutput],
     budget: [loadBudget],
     alias: [loadAlias],
+    mine: [loadMine],
     pty: [loadPty],
     tmux: [loadTmux],
     watchdog: [loadWatchdog],
@@ -180,7 +192,11 @@ export const COMMAND_LOADERS = {
     teams: [loadTeams],
     cloud: [loadCloud],
     message: [loadMessage],
+    send: [loadSend],
+    notify: [loadSend],
+    hq: [loadHq],
     feed: [loadFeed],
+    activity: [loadActivity],
     mailboxes: [loadMailboxes],
     mailbox: [loadMailboxes],
     serve: [loadServe],

package/dist/lib/state.d.ts

@@ -137,6 +137,8 @@ export declare function getMonitorsHistoryDir(): string;
 export declare function getMailboxRootDir(): string;
 /** Root for open-block feed records (~/.agents/.history/feed/). */
 export declare function getFeedDir(): string;
+/** Append-only per-session agent-activity event logs (~/.agents/.history/activity/). */
+export declare function getActivityDir(): string;
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
 export declare function getVersionsDir(): string;
 /** Path to version-switching shim scripts (~/.agents/.cache/shims/). */

package/dist/lib/state.js

@@ -101,6 +101,7 @@ const BACKUPS_DIR = path.join(HISTORY_DIR, 'backups');
 const TRASH_DIR = path.join(HISTORY_DIR, 'trash');
 const MAILBOX_DIR = path.join(HISTORY_DIR, 'mailbox');
 const FEED_DIR = path.join(HISTORY_DIR, 'feed');
+const ACTIVITY_DIR = path.join(HISTORY_DIR, 'activity');
 // Cache bucket (regenerable).
 const SHIMS_DIR = path.join(CACHE_DIR, 'shims');
 const HOOK_SHIMS_DIR = path.join(SHIMS_DIR, 'hooks');
@@ -340,6 +341,8 @@ export function getMonitorsHistoryDir() { return MONITORS_HISTORY_DIR; }
 export function getMailboxRootDir() { return MAILBOX_DIR; }
 /** Root for open-block feed records (~/.agents/.history/feed/). */
 export function getFeedDir() { return FEED_DIR; }
+/** Append-only per-session agent-activity event logs (~/.agents/.history/activity/). */
+export function getActivityDir() { return ACTIVITY_DIR; }
 /** Path to installed agent CLI binaries (~/.agents/.history/versions/). */
 export function getVersionsDir() { return VERSIONS_DIR; }
 /** Path to version-switching shim scripts (~/.agents/.cache/shims/). */
@@ -603,18 +606,25 @@ function writeIfChanged(filePath, content) {
  * `agents:` / `versions:` are not written (no empty committed files).
  */
 function writeMetaUnlocked(meta) {
-    const { agents, versions, defaultBrowserProfile, ...central } = meta;
+    const { agents, isolatedAgents, versions, defaultBrowserProfile, ...central } = meta;
     // Write the machine-local files FIRST, then strip central — so a crash mid-write
     // never removes pins/versions from central before they're persisted elsewhere.
     const devicePath = getDeviceMetaPath();
     const hasAgents = !!agents && Object.keys(agents).length > 0;
+    // The isolated pointer names a version installed on THIS machine, exactly like a
+    // global pin, so it belongs beside `agents:` in the device file rather than in the
+    // central doc that syncs — otherwise another machine inherits a pointer to a copy
+    // it does not have.
+    const hasIsolatedAgents = !!isolatedAgents && Object.keys(isolatedAgents).length > 0;
     const hasDefaultBrowser = !!defaultBrowserProfile;
-    if (hasAgents || hasDefaultBrowser) {
+    if (hasAgents || hasIsolatedAgents || hasDefaultBrowser) {
         // Device-local doc carries `agents:` pins and `defaultBrowserProfile:` — both
         // are per-machine and must never land in central agents.yaml (which syncs).
         const deviceDoc = {};
         if (hasAgents)
             deviceDoc.agents = agents;
+        if (hasIsolatedAgents)
+            deviceDoc.isolatedAgents = isolatedAgents;
         if (hasDefaultBrowser)
             deviceDoc.defaultBrowserProfile = defaultBrowserProfile;
         fs.mkdirSync(path.dirname(devicePath), { recursive: true });
@@ -637,8 +647,9 @@ function writeMetaUnlocked(meta) {
 }
 /**
  * Overlay this machine's local state onto a central-portable Meta:
- *   - `agents:` from the device file (device wins; the union both preserves the
- *     one-level merge and self-heals a pre-migration central that still has pins)
+ *   - `agents:` and `isolatedAgents:` from the device file (device wins; the union
+ *     both preserves the one-level merge and self-heals a pre-migration central that
+ *     still has pins)
  *   - `defaultBrowserProfile:` from the device file (device is the sole source;
  *     the field is stripped from central on write, so nothing to merge against)
  *   - `versions:` from the history JSON (wholesale replace; falls back to
@@ -651,6 +662,8 @@ function overlayMachineLocal(meta) {
             const dm = yaml.parse(fs.readFileSync(devicePath, 'utf-8'));
             if (dm?.agents)
                 meta.agents = { ...meta.agents, ...dm.agents };
+            if (dm?.isolatedAgents)
+                meta.isolatedAgents = { ...meta.isolatedAgents, ...dm.isolatedAgents };
             if (dm?.defaultBrowserProfile)
                 meta.defaultBrowserProfile = dm.defaultBrowserProfile;
         }

package/dist/lib/subagents-registry.d.ts

@@ -27,6 +27,8 @@ export interface SubagentTarget {
     names(dir: string): string[];
     /** On-disk paths subagent `name` occupies (for removal / soft-delete). */
     occupied(dir: string, name: string): OccupiedEntry[];
+    /** Cross-item files this target owns outside any one subagent's occupied paths. */
+    finalizeOccupied?(dir: string): OccupiedEntry[];
     /** Rich metadata for `name`; `null` skips it from the listing. */
     read(dir: string, name: string): SubagentMeta | null;
     /** Optional post-sync pass over the just-synced subagents (Kimi's parent index). */

package/dist/lib/subagents-registry.js

@@ -213,6 +213,9 @@ const kimiTarget = {
             { path: safeJoin(dir, `${name}.system.md`), kind: 'file' },
         ];
     },
+    finalizeOccupied(dir) {
+        return [{ path: safeJoin(dir, KIMI_SUBAGENTS_PARENT_FILE), kind: 'file' }];
+    },
     read(dir, name) {
         const yamlPath = path.join(dir, `${name}.yaml`);
         if (!fs.existsSync(yamlPath) || !fs.statSync(yamlPath).isFile())