@phnx-labs/agents-cli 1.20.50 → 1.20.52

package/dist/lib/types.d.ts

@@ -128,6 +128,19 @@ export interface AgentConfig {
     capabilities: {
         hooks: Capability;
         mcp: Capability;
+        /**
+         * Whether `mcp add --transport http` is supported. Only true for agents
+         * whose CLI accepts an HTTP-transport MCP server registration; false for
+         * agents that only accept stdio (registerMcp skips HTTP registration with
+         * a clear reason).
+         */
+        mcpHttp: Capability;
+        /**
+         * Whether HTTP-MCP registration accepts `--header` args. Independent of
+         * `mcpHttp`: only Claude's CLI takes headers today; Codex/Gemini accept
+         * HTTP MCP but reject header args.
+         */
+        mcpHeaders: Capability;
         allowlist: Capability;
         skills: Capability;
         commands: Capability;
@@ -164,7 +177,7 @@ export type RulesCapability = false | {
     file: string;
 };
 /** Names of every gateable capability on AgentConfig. */
-export type CapabilityName = 'hooks' | 'mcp' | 'allowlist' | 'skills' | 'commands' | 'plugins' | 'subagents' | 'rules' | 'workflows';
+export type CapabilityName = 'hooks' | 'mcp' | 'mcpHttp' | 'mcpHeaders' | 'allowlist' | 'skills' | 'commands' | 'plugins' | 'subagents' | 'rules' | 'workflows';
 /**
  * Permission modes controlling agent autonomy.
  *   plan  read-only investigation; no writes, no shell side-effects
@@ -639,6 +652,16 @@ export interface Meta {
      * lives separately in ~/.agents/.cache/browser/<profile>/.
      */
     browser?: Record<string, BrowserProfileConfig>;
+    /**
+     * Device-local pointer: the browser profile `agents browser start` resolves to
+     * when no `--profile` is passed (and what an explicit `--profile default`
+     * re-points to). Stored per-machine in `~/.agents/devices/<machine>/agents.yaml`,
+     * NOT central — the target profile may carry machine-local logins, so the choice
+     * must not ride `agents repo push/pull` to other machines. Unset = auto-detect an
+     * installed Chromium-family browser (legacy behavior). Set via
+     * `agents browser profiles set-default <name>`.
+     */
+    defaultBrowserProfile?: string;
     /**
      * Agent-host registry keyed by host name (`agents hosts`). Portable user
      * config synced with `agents repo push/pull`. For `ssh-config` hosts this is

package/dist/lib/versions.d.ts

@@ -379,32 +379,6 @@ export interface SyncResult {
     plugins: string[];
     workflows: string[];
 }
-/** Diff between central ~/.agents/ resources and what is synced to a version home. */
-export interface ResourceDiff {
-    commands: {
-        added: string[];
-        dangling: string[];
-    };
-    skills: {
-        added: string[];
-        dangling: string[];
-    };
-    hooks: {
-        added: string[];
-        dangling: string[];
-    };
-    memory: {
-        added: string[];
-        dangling: string[];
-    };
-    totalAdded: number;
-    totalDangling: number;
-}
-/**
- * Get the diff between central resources (~/.agents/) and what's synced to a version.
- * Uses filesystem state - no tracking needed.
- */
-export declare function getResourceDiff(agent: AgentId, version: string): ResourceDiff;
 /**
  * Enumerate the DotAgent repo names that resources can be scoped to:
  * the fixed `project` / `user` / `system` layers plus every enabled extra

package/dist/lib/versions.js

@@ -21,7 +21,7 @@ import { exec, execFile } from 'child_process';
 import { promisify } from 'util';
 import chalk from 'chalk';
 import { checkbox, select } from '@inquirer/prompts';
-import { getVersionsDir, ensureAgentsDir, readMeta, writeMeta, getCommandsDir, getSkillsDir, getHooksDir, getResolvedRulesDir, getUserRulesDir, getVersionResources, ensureVersionResourcePatterns, getProjectAgentsDir, getPromptcutsPath, getUserPromptcutsPath, getEnabledExtraRepos, getAgentsDir, getUserAgentsDir, getTrashVersionsDir, getActiveRulesPreset, getHomeDir } from './state.js';
+import { getVersionsDir, ensureAgentsDir, readMeta, writeMeta, getSkillsDir, getResolvedRulesDir, getUserRulesDir, getVersionResources, ensureVersionResourcePatterns, getProjectAgentsDir, getPromptcutsPath, getUserPromptcutsPath, getEnabledExtraRepos, getAgentsDir, getUserAgentsDir, getTrashVersionsDir, getActiveRulesPreset, getHomeDir } from './state.js';
 import { defaultPatterns, expandPatterns } from './resource-patterns.js';
 import { listResources } from './resources.js';
 // VERSION_RE + compareVersions are owned by the agent-spec engine primitives
@@ -40,7 +40,7 @@ import { discoverPlugins } from './plugins.js';
 import { loadManifest, saveManifest, buildManifest as buildSyncManifest, isStale } from './staleness/index.js';
 import { emit } from './events.js';
 import { safeJoin } from './paths.js';
-import { listCommandSkillsInVersion, readSkillSourceCommandMarker, shouldInstallCommandAsSkill } from './command-skills.js';
+import { readSkillSourceCommandMarker, shouldInstallCommandAsSkill } from './command-skills.js';
 import { getWriter, getDetector } from './staleness/registry.js';
 /** Promisified exec for running shell commands. */
 const execAsync = promisify(exec);
@@ -1826,149 +1826,6 @@ async function getCliVersionFromPath(agent) {
         return null;
     }
 }
-/**
- * Get the diff between central resources (~/.agents/) and what's synced to a version.
- * Uses filesystem state - no tracking needed.
- */
-export function getResourceDiff(agent, version) {
-    const agentConfig = AGENTS[agent];
-    const versionHome = getVersionHomePath(agent, version);
-    const agentDir = path.join(versionHome, agentConfigDirName(agent));
-    const diff = {
-        commands: { added: [], dangling: [] },
-        skills: { added: [], dangling: [] },
-        hooks: { added: [], dangling: [] },
-        memory: { added: [], dangling: [] },
-        totalAdded: 0,
-        totalDangling: 0,
-    };
-    // Helper to check symlink status
-    const getSymlinkStatus = (linkPath) => {
-        try {
-            const stat = fs.lstatSync(linkPath);
-            if (!stat.isSymbolicLink())
-                return 'none';
-            // Check if target exists
-            try {
-                fs.statSync(linkPath);
-                return 'valid';
-            }
-            catch {
-                return 'dangling';
-            }
-        }
-        catch {
-            return 'none';
-        }
-    };
-    // Commands: check directory symlink (or individual files for Gemini / generated skills for newer Codex)
-    const centralCommands = getCommandsDir();
-    const commandsTarget = path.join(agentDir, agentConfig.commandsSubdir);
-    if (shouldInstallCommandAsSkill(agent, version)) {
-        const centralFiles = fs.existsSync(centralCommands)
-            ? fs.readdirSync(centralCommands).filter(f => f.endsWith('.md'))
-            : [];
-        const centralNames = new Set(centralFiles.map(f => f.replace('.md', '')));
-        const versionNames = new Set(listCommandSkillsInVersion(agentDir));
-        for (const file of centralFiles) {
-            const name = file.replace('.md', '');
-            if (!versionNames.has(name)) {
-                diff.commands.added.push(file);
-            }
-        }
-        for (const name of versionNames) {
-            if (!centralNames.has(name)) {
-                diff.commands.dangling.push(`${name}.md`);
-            }
-        }
-    }
-    else if (agentConfig.format === 'toml') {
-        // Gemini: compare .md files in central vs .toml files in version
-        if (fs.existsSync(centralCommands)) {
-            const centralFiles = fs.readdirSync(centralCommands).filter(f => f.endsWith('.md'));
-            const versionFiles = fs.existsSync(commandsTarget)
-                ? fs.readdirSync(commandsTarget).filter(f => f.endsWith('.toml'))
-                : [];
-            const versionNames = new Set(versionFiles.map(f => f.replace('.toml', '')));
-            for (const file of centralFiles) {
-                const name = file.replace('.md', '');
-                if (!versionNames.has(name)) {
-                    diff.commands.added.push(file);
-                }
-            }
-            // Check for dangling (toml exists but no md source)
-            const centralNames = new Set(centralFiles.map(f => f.replace('.md', '')));
-            for (const file of versionFiles) {
-                const name = file.replace('.toml', '');
-                if (!centralNames.has(name)) {
-                    diff.commands.dangling.push(file);
-                }
-            }
-        }
-    }
-    else {
-        // Other agents: check directory symlink
-        const status = getSymlinkStatus(commandsTarget);
-        if (status === 'none' && fs.existsSync(centralCommands)) {
-            const files = fs.readdirSync(centralCommands).filter(f => f.endsWith('.md'));
-            diff.commands.added = files;
-        }
-        else if (status === 'dangling') {
-            diff.commands.dangling = ['commands/'];
-        }
-    }
-    // Skills: check directory symlink (skip if agent natively reads ~/.agents/skills/)
-    if (!agentConfig.nativeAgentsSkillsDir) {
-        const centralSkills = getSkillsDir();
-        const skillsTarget = path.join(agentDir, 'skills');
-        const skillsStatus = getSymlinkStatus(skillsTarget);
-        if (skillsStatus === 'none' && fs.existsSync(centralSkills)) {
-            const dirs = fs.readdirSync(centralSkills).filter(f => {
-                const stat = fs.statSync(path.join(centralSkills, f));
-                return stat.isDirectory() && !f.startsWith('.');
-            });
-            diff.skills.added = dirs;
-        }
-        else if (skillsStatus === 'dangling') {
-            diff.skills.dangling = ['skills/'];
-        }
-    }
-    // Hooks: check directory symlink (if agent supports hooks)
-    if (agentConfig.supportsHooks) {
-        const centralHooks = getHooksDir();
-        const hooksTarget = path.join(agentDir, 'hooks');
-        const hooksStatus = getSymlinkStatus(hooksTarget);
-        if (hooksStatus === 'none' && fs.existsSync(centralHooks)) {
-            const files = fs.readdirSync(centralHooks).filter(f => !f.startsWith('.'));
-            diff.hooks.added = files;
-        }
-        else if (hooksStatus === 'dangling') {
-            diff.hooks.dangling = ['hooks/'];
-        }
-    }
-    // Rules: check individual file symlinks
-    const systemRulesDir = getResolvedRulesDir();
-    if (fs.existsSync(systemRulesDir)) {
-        const ruleFiles = fs.readdirSync(systemRulesDir).filter(f => f.endsWith('.md') && f !== RULES_DOC_FILENAME);
-        for (const file of ruleFiles) {
-            const targetName = file === 'AGENTS.md' ? agentConfig.instructionsFile : file;
-            const targetPath = path.join(agentDir, targetName);
-            const status = getSymlinkStatus(targetPath);
-            if (status === 'none') {
-                diff.memory.added.push(file);
-            }
-            else if (status === 'dangling') {
-                diff.memory.dangling.push(targetName);
-            }
-        }
-    }
-    // Calculate totals
-    diff.totalAdded = diff.commands.added.length + diff.skills.added.length +
-        diff.hooks.added.length + diff.memory.added.length;
-    diff.totalDangling = diff.commands.dangling.length + diff.skills.dangling.length +
-        diff.hooks.dangling.length + diff.memory.dangling.length;
-    return diff;
-}
 /**
  * Enumerate the DotAgent repo names that resources can be scoped to:
  * the fixed `project` / `user` / `system` layers plus every enabled extra

package/dist/lib/warn-unpushed.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Whether a just-finished run should be checked for stranded work: only
+ * writable modes can leave commits (plan is read-only), and only non-interactive
+ * runs need the warning (an interactive user sees their own shell). Centralizes
+ * the gate so every exit path in the run command applies it identically.
+ */
+export declare function shouldWarnUnpushed(mode: string, interactive: boolean): boolean;
+export interface UnpushedState {
+    /** cwd is inside a git work tree. */
+    isRepo: boolean;
+    /** current branch, or null when detached / not a repo. */
+    branch: string | null;
+    /** the branch has an upstream tracking ref configured. */
+    hasUpstream: boolean;
+    /** commits reachable from HEAD but not from any remote-tracking ref. */
+    unpushed: {
+        sha: string;
+        subject: string;
+    }[];
+}
+/**
+ * Inspect `cwd` for commits on the current branch that have not reached any
+ * remote. Uses `git log --not --remotes` so it is correct even when the branch
+ * has no upstream set: commits already present on some `origin/*` ref are NOT
+ * reported (no false positive), and a never-pushed branch reports all its
+ * commits. Returns an inert result — never throws — for a non-repo cwd, a
+ * detached HEAD, or a repo with no remotes (nothing to push to).
+ */
+export declare function getUnpushedState(cwd: string): Promise<UnpushedState>;
+/**
+ * Render the warning for an unpushed state, or null when there is nothing to
+ * warn about. Split out from the printer so it is directly testable.
+ */
+export declare function formatUnpushedWarning(state: UnpushedState, cwd: string): string | null;
+/**
+ * If the just-finished run left committed-but-unpushed work in `cwd`, print a
+ * loud stderr warning with the exact push / PR commands. Non-fatal by contract:
+ * any failure is swallowed so it can never break a run's exit path.
+ */
+export declare function warnUnpushedWork(cwd: string): Promise<void>;

package/dist/lib/warn-unpushed.js

@@ -0,0 +1,128 @@
+/**
+ * Post-run guard against silently stranded work.
+ *
+ * A headless `agents run` in a writable mode can end with the agent having
+ * committed on a branch but never pushed it — the CLI's exit path does no git
+ * work, so those commits sit invisible in a worktree until someone audits the
+ * box. This module detects that state and prints a loud stderr warning with the
+ * exact push / PR commands. It is advisory only: it never pushes, never mutates
+ * the repo, and never throws (a non-repo cwd or any git error yields an inert
+ * result), so it can sit on the run's exit path without ever breaking it.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import chalk from 'chalk';
+const execFileAsync = promisify(execFile);
+// Unit-separator byte (0x1f) as the git-log field delimiter: it cannot occur in
+// a commit subject, so splitting on it never truncates a subject with spaces.
+const SEP = '\x1f';
+/**
+ * Whether a just-finished run should be checked for stranded work: only
+ * writable modes can leave commits (plan is read-only), and only non-interactive
+ * runs need the warning (an interactive user sees their own shell). Centralizes
+ * the gate so every exit path in the run command applies it identically.
+ */
+export function shouldWarnUnpushed(mode, interactive) {
+    return mode !== 'plan' && !interactive;
+}
+const INERT = { isRepo: false, branch: null, hasUpstream: false, unpushed: [] };
+async function git(args, cwd) {
+    // These are all local, non-prompting reads, but the call sits on a run's exit
+    // path — a hard timeout guarantees a wedged git can never delay exit unbounded.
+    const { stdout } = await execFileAsync('git', args, { cwd, timeout: 5000 });
+    return stdout.trim();
+}
+/**
+ * Inspect `cwd` for commits on the current branch that have not reached any
+ * remote. Uses `git log --not --remotes` so it is correct even when the branch
+ * has no upstream set: commits already present on some `origin/*` ref are NOT
+ * reported (no false positive), and a never-pushed branch reports all its
+ * commits. Returns an inert result — never throws — for a non-repo cwd, a
+ * detached HEAD, or a repo with no remotes (nothing to push to).
+ */
+export async function getUnpushedState(cwd) {
+    let branch;
+    try {
+        branch = await git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    }
+    catch {
+        return INERT; // not a git repo
+    }
+    // Detached HEAD: agents commit on branches; nothing nameable to push.
+    if (!branch || branch === 'HEAD') {
+        return { isRepo: true, branch: null, hasUpstream: false, unpushed: [] };
+    }
+    // No remote configured -> `--remotes` matches nothing and would report the
+    // entire history as "unpushed". There's nowhere to push, so stay silent.
+    let hasRemote = false;
+    try {
+        hasRemote = (await git(['remote'], cwd)).length > 0;
+    }
+    catch {
+        hasRemote = false;
+    }
+    if (!hasRemote) {
+        return { isRepo: true, branch, hasUpstream: false, unpushed: [] };
+    }
+    let unpushed = [];
+    try {
+        // HEAD must precede `--not`: everything after `--not` is negated, so
+        // `--not --remotes HEAD` would negate HEAD too and always return empty.
+        const out = await git(['log', 'HEAD', '--not', '--remotes', `--pretty=format:%h${SEP}%s`], cwd);
+        unpushed = out
+            ? out.split('\n').map((line) => {
+                const idx = line.indexOf(SEP);
+                return idx === -1
+                    ? { sha: line, subject: '' }
+                    : { sha: line.slice(0, idx), subject: line.slice(idx + 1) };
+            })
+            : [];
+    }
+    catch {
+        return { isRepo: true, branch, hasUpstream: false, unpushed: [] };
+    }
+    let hasUpstream = false;
+    try {
+        await git(['rev-parse', '--abbrev-ref', '@{u}'], cwd);
+        hasUpstream = true;
+    }
+    catch {
+        hasUpstream = false;
+    }
+    return { isRepo: true, branch, hasUpstream, unpushed };
+}
+/**
+ * Render the warning for an unpushed state, or null when there is nothing to
+ * warn about. Split out from the printer so it is directly testable.
+ */
+export function formatUnpushedWarning(state, cwd) {
+    if (!state.isRepo || !state.branch || state.unpushed.length === 0)
+        return null;
+    const n = state.unpushed.length;
+    const lines = [`\n⚠ agent left ${n} commit${n === 1 ? '' : 's'} on '${state.branch}' not pushed to any remote:`];
+    for (const c of state.unpushed.slice(0, 5))
+        lines.push(`    ${c.sha} ${c.subject}`);
+    if (n > 5)
+        lines.push(`    … and ${n - 5} more`);
+    const pushCmd = state.hasUpstream
+        ? `git -C "${cwd}" push`
+        : `git -C "${cwd}" push -u origin ${state.branch}`;
+    lines.push(`  push them:  ${pushCmd}`);
+    lines.push(`  open a PR:  gh pr create --head ${state.branch}`);
+    return lines.join('\n');
+}
+/**
+ * If the just-finished run left committed-but-unpushed work in `cwd`, print a
+ * loud stderr warning with the exact push / PR commands. Non-fatal by contract:
+ * any failure is swallowed so it can never break a run's exit path.
+ */
+export async function warnUnpushedWork(cwd) {
+    try {
+        const warning = formatUnpushedWarning(await getUnpushedState(cwd), cwd);
+        if (warning)
+            process.stderr.write(chalk.yellow(warning) + '\n');
+    }
+    catch {
+        // Advisory only — never break the run over a warning.
+    }
+}

package/dist/lib/whats-new.d.ts

@@ -1,8 +1,10 @@
 /**
  * Render a compact "What's new" summary from a CHANGELOG.md body: one bullet
- * per feature/fix heading (the `**...**` lines) for each version in the range
- * the user actually moved through, `(fromVersion, toVersion]`. The verbose
- * sub-bullets are intentionally dropped — the full notes live in the changelog.
+ * per feature/fix heading for each version in the range the user actually
+ * moved through, `(fromVersion, toVersion]`. Headings are recognized in both
+ * changelog formats — the current `- **Title.** prose…` single-line bullets
+ * and the older standalone `**Heading**` lines. The verbose prose/sub-bullets
+ * are intentionally dropped — the full notes live in the changelog.
  *
  * Returns colored lines ready to print, empty when nothing is in range.
  */

package/dist/lib/whats-new.js

@@ -2,15 +2,23 @@ import chalk from 'chalk';
 import { compareVersions } from './agent-spec/primitives.js';
 /**
  * Render a compact "What's new" summary from a CHANGELOG.md body: one bullet
- * per feature/fix heading (the `**...**` lines) for each version in the range
- * the user actually moved through, `(fromVersion, toVersion]`. The verbose
- * sub-bullets are intentionally dropped — the full notes live in the changelog.
+ * per feature/fix heading for each version in the range the user actually
+ * moved through, `(fromVersion, toVersion]`. Headings are recognized in both
+ * changelog formats — the current `- **Title.** prose…` single-line bullets
+ * and the older standalone `**Heading**` lines. The verbose prose/sub-bullets
+ * are intentionally dropped — the full notes live in the changelog.
  *
  * Returns colored lines ready to print, empty when nothing is in range.
  */
 export function renderWhatsNew(changelog, fromVersion, toVersion) {
     const out = [];
     let inRelevantSection = false;
+    // Whether the CURRENT version section uses the old standalone-heading format.
+    // Old sections nest `-` sub-bullets under each `**Heading**` line, and some
+    // sub-bullets are themselves bold-led (`- **Claim.** detail…`) — once a
+    // standalone heading is seen, `- **` lines in that section are sub-bullets,
+    // not entries, and must not render.
+    let sectionUsesStandaloneHeadings = false;
     for (const line of changelog.split('\n')) {
         const versionMatch = line.match(/^## (\d+\.\d+\.\d+)/);
         if (versionMatch) {
@@ -20,15 +28,27 @@ export function renderWhatsNew(changelog, fromVersion, toVersion) {
             inRelevantSection =
                 compareVersions(currentVersion, fromVersion) > 0 &&
                     compareVersions(currentVersion, toVersion) <= 0;
+            sectionUsesStandaloneHeadings = false;
             if (inRelevantSection) {
                 out.push('');
                 out.push(chalk.bold(`v${currentVersion}`));
             }
             continue;
         }
-        // Only the bold headings — one bullet per feature/fix.
-        if (inRelevantSection && line.startsWith('**') && line.endsWith('**')) {
+        // Only the entry headings — one bullet per feature/fix. Two formats exist
+        // across the changelog's history: the current single-line bullets
+        // (`- **Title.** verbose prose…`, heading kept, prose dropped) and the
+        // older standalone `**Heading**` lines with `-` sub-bullets beneath.
+        if (!inRelevantSection)
+            continue;
+        if (line.startsWith('**') && line.endsWith('**')) {
+            sectionUsesStandaloneHeadings = true;
             out.push(`  ${chalk.cyan('•')} ${line.replace(/\*\*/g, '')}`);
+            continue;
+        }
+        const entryBullet = sectionUsesStandaloneHeadings ? null : line.match(/^- \*\*(.+?)\*\*/);
+        if (entryBullet) {
+            out.push(`  ${chalk.cyan('•')} ${entryBullet[1].replace(/\*\*/g, '')}`);
         }
     }
     return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.50",
+  "version": "1.20.52",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",
@@ -98,12 +98,14 @@
     "proper-lockfile": "4.1.2",
     "simple-git": "3.36.0",
     "smol-toml": "1.7.0",
+    "ws": "^8.21.0",
     "yaml": "2.9.0"
   },
   "devDependencies": {
     "@types/diff": "8.0.0",
     "@types/marked-terminal": "6.1.1",
     "@types/node": "26.1.0",
+    "@types/ws": "^8.18.1",
     "tsx": "4.23.0",
     "typescript": "6.0.3",
     "vitest": "4.1.9"

package/dist/lib/resources/index.d.ts

@@ -1,53 +0,0 @@
-/**
- * Unified resource system - exports all handlers and provides a registry.
- *
- * Usage:
- *   import { handlers, getHandler } from './resources/index.js';
- *   const cmds = handlers.commands.listAll('claude');
- */
-export * from './types.js';
-export { CommandsHandler, commandsHandler, type CommandItem } from './commands.js';
-export { HooksHandler, type HookItem } from './hooks.js';
-export { SkillsHandler, type SkillItem } from './skills.js';
-export { RulesHandler, type RuleItem } from './rules.js';
-export { McpHandler, getMcpConfigPath, type McpItem } from './mcp.js';
-export { PermissionsHandler, type PermissionItem } from './permissions.js';
-export { SubagentsHandler, subagentsHandler, type SubagentItem } from './subagents.js';
-export { WorkflowsHandler, type WorkflowItem } from './workflows.js';
-import type { ResourceKind, ResourceHandler } from './types.js';
-/** All resource handlers keyed by kind. */
-export declare const handlers: {
-    readonly command: import("./commands.js").CommandsHandler;
-    readonly commands: import("./commands.js").CommandsHandler;
-    readonly hook: ResourceHandler<import("../types.js").ManifestHook>;
-    readonly hooks: ResourceHandler<import("../types.js").ManifestHook>;
-    readonly skill: ResourceHandler<import("./skills.js").SkillItem>;
-    readonly skills: ResourceHandler<import("./skills.js").SkillItem>;
-    readonly rule: ResourceHandler<import("./rules.js").RuleItem>;
-    readonly rules: ResourceHandler<import("./rules.js").RuleItem>;
-    readonly mcp: ResourceHandler<import("./mcp.js").McpItem>;
-    readonly permission: ResourceHandler<import("../types.js").PermissionSet>;
-    readonly permissions: ResourceHandler<import("../types.js").PermissionSet>;
-    readonly subagent: import("./subagents.js").SubagentsHandler;
-    readonly subagents: import("./subagents.js").SubagentsHandler;
-    readonly workflow: {
-        readonly kind: "workflow";
-        listAll(_agent: import("./types.js").AgentId, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem>[];
-        resolve(_agent: import("./types.js").AgentId, name: string, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem> | null;
-        sync(_agent: import("./types.js").AgentId, _versionHome: string, _cwd?: string): void;
-        format(_agent: import("./types.js").AgentId): "md";
-        targetDir(_agent: import("./types.js").AgentId): string;
-    };
-    readonly workflows: {
-        readonly kind: "workflow";
-        listAll(_agent: import("./types.js").AgentId, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem>[];
-        resolve(_agent: import("./types.js").AgentId, name: string, cwd?: string): import("./types.js").ResolvedItem<import("./workflows.js").WorkflowItem> | null;
-        sync(_agent: import("./types.js").AgentId, _versionHome: string, _cwd?: string): void;
-        format(_agent: import("./types.js").AgentId): "md";
-        targetDir(_agent: import("./types.js").AgentId): string;
-    };
-};
-/** Get a handler by resource kind. */
-export declare function getHandler(kind: ResourceKind): ResourceHandler<unknown> | null;
-/** All resource kinds. */
-export declare const RESOURCE_KINDS: ResourceKind[];

package/dist/lib/resources/index.js

@@ -1,76 +0,0 @@
-/**
- * Unified resource system - exports all handlers and provides a registry.
- *
- * Usage:
- *   import { handlers, getHandler } from './resources/index.js';
- *   const cmds = handlers.commands.listAll('claude');
- */
-export * from './types.js';
-export { CommandsHandler, commandsHandler } from './commands.js';
-export { HooksHandler } from './hooks.js';
-export { SkillsHandler } from './skills.js';
-export { RulesHandler } from './rules.js';
-export { McpHandler, getMcpConfigPath } from './mcp.js';
-export { PermissionsHandler } from './permissions.js';
-export { SubagentsHandler, subagentsHandler } from './subagents.js';
-export { WorkflowsHandler } from './workflows.js';
-import { commandsHandler } from './commands.js';
-import { HooksHandler } from './hooks.js';
-import { SkillsHandler } from './skills.js';
-import { RulesHandler } from './rules.js';
-import { McpHandler } from './mcp.js';
-import { PermissionsHandler } from './permissions.js';
-import { subagentsHandler } from './subagents.js';
-import { WorkflowsHandler } from './workflows.js';
-/** All resource handlers keyed by kind. */
-export const handlers = {
-    command: commandsHandler,
-    commands: commandsHandler,
-    hook: HooksHandler,
-    hooks: HooksHandler,
-    skill: SkillsHandler,
-    skills: SkillsHandler,
-    rule: RulesHandler,
-    rules: RulesHandler,
-    mcp: McpHandler,
-    permission: PermissionsHandler,
-    permissions: PermissionsHandler,
-    subagent: subagentsHandler,
-    subagents: subagentsHandler,
-    workflow: WorkflowsHandler,
-    workflows: WorkflowsHandler,
-};
-/** Get a handler by resource kind. */
-export function getHandler(kind) {
-    switch (kind) {
-        case 'command':
-            return commandsHandler;
-        case 'hook':
-            return HooksHandler;
-        case 'skill':
-            return SkillsHandler;
-        case 'rule':
-            return RulesHandler;
-        case 'mcp':
-            return McpHandler;
-        case 'permission':
-            return PermissionsHandler;
-        case 'subagent':
-            return subagentsHandler;
-        case 'workflow':
-            return WorkflowsHandler;
-        default:
-            return null;
-    }
-}
-/** All resource kinds. */
-export const RESOURCE_KINDS = [
-    'command',
-    'hook',
-    'skill',
-    'rule',
-    'mcp',
-    'permission',
-    'subagent',
-    'workflow',
-];