@phnx-labs/agents-cli 1.20.49 → 1.20.51

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);
@@ -1226,6 +1226,40 @@ export async function installVersion(agent, version, onProgress, opts) {
                 /* non-fatal; the install itself succeeded */
             }
         }
+        // The `npm install` above ran with `--ignore-scripts` — the right posture for
+        // the dependency TREE (never run arbitrary transitive postinstalls), but it
+        // also skips the agent package's OWN postinstall, which for some agents is a
+        // required install step. @anthropic-ai/claude-code ships a ~500-byte stub at
+        // `bin/claude.exe` plus per-arch native binaries as optional deps; its
+        // `postinstall` (`node install.cjs`) is what copies the correct native binary
+        // over the stub. Skip it and every launch dies with "native binary not
+        // installed". So run the first-party package's declared postinstall here —
+        // scoped to that one package, never `prepare` (claude-code's `prepare` is an
+        // unconditional `exit 1` publish guard). Same precedent as the keychain-helper
+        // postinstall re-run after a `--ignore-scripts` upgrade (see index.ts).
+        // Best-effort: the integrity gate below is the real backstop — a still-broken
+        // binary (postinstall failed, or a platform with no published native dep)
+        // fails there with the correct message rather than throwing here.
+        if (agentConfig.npmPackage) {
+            // Recompute from installedVersion, not the (possibly renamed) `versionDir`:
+            // the `latest` branch above may have renamed the dir to its concrete version.
+            const pkgRoot = path.join(getVersionDir(agent, installedVersion), 'node_modules', agentConfig.npmPackage);
+            try {
+                const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf-8'));
+                const postinstall = pkg?.scripts?.postinstall;
+                if (typeof postinstall === 'string' && postinstall.trim()) {
+                    onProgress?.(`Running ${agentConfig.name} postinstall...`);
+                    // The declared postinstall is a shell command string (e.g. `node
+                    // install.cjs`), so it must run through a shell on ALL platforms —
+                    // shell:true, empty args. cwd is the package root; install.cjs anchors
+                    // its paths to __dirname, so that is correct and sufficient.
+                    await execFileAsync(postinstall, [], { cwd: pkgRoot, shell: true });
+                }
+            }
+            catch {
+                /* non-fatal; the integrity gate below catches a still-broken binary */
+            }
+        }
         // Integrity gate: confirm the install actually launches, not just that the
         // JS wrapper landed. A gutted install (wrapper present, native platform
         // binary missing) otherwise gets silently pinned as the default and crashes
@@ -1603,9 +1637,16 @@ export async function getInstalledVersion(agent, version) {
  * Deliberately narrow: only the missing-file signature counts. An agent that
  * merely dislikes `--version` (nonzero exit, ordinary error text) or ignores it
  * (times out) must NOT match, so a healthy install is never falsely condemned.
+ *
+ * The trailing phrases catch a gutted install that reports its own breakage
+ * *politely* rather than with a raw ENOENT: @anthropic-ai/claude-code's stub
+ * (run when its postinstall never copied the native binary in) prints "native
+ * binary not installed / postinstall did not run / … optional dependency was not
+ * downloaded" and exits nonzero — which the generic patterns above miss. Anchored
+ * tightly so a healthy `--version` can never emit them.
  */
 export function isMissingBinarySignature(output) {
-    return /\bENOENT\b|no such file|cannot find|command not found|is not recognized/i.test(output);
+    return /\bENOENT\b|no such file|cannot find|command not found|is not recognized|native binary not installed|postinstall did not run|optional dependency was not downloaded/i.test(output);
 }
 /**
  * Verify a freshly-installed agent can actually LAUNCH — not merely that its JS
@@ -1785,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.20.49",
+  "version": "1.20.51",
   "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',
-];