@reeledge/agent-tools 0.1.4 → 0.1.6

package/dist/apps/claude-code.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { claudeMcpAddArgs, mcpEndpoint } from '../mcp.js';
 import { writeSkillTree } from '../skills.js';
+import { buildLocalPlugin, claudePluginDir, pluginDryRunLines, registerAndInstallPlugin, } from './claude-plugin.js';
 import { APP_LABELS, CONNECTOR_NAME, } from './types.js';
 /** Resolve the skills dir: explicit override, else `~/.claude/skills`. */
 function claudeSkillsDir(env) {
@@ -70,29 +71,63 @@ export function makeClaudeCodeAdapter(env) {
     const platform = () => env.platform ?? process.platform;
     const log = (line) => env.log?.(line);
     const desktopPath = () => claudeDesktopConfigPath(env.homeDir, platform());
+    const pluginDir = () => claudePluginDir();
+    // Captured by `writeSkills` so `configureMcp` can fall back to a loose
+    // `~/.claude/skills/` write when the `claude` binary is absent (and the plugin
+    // therefore can't be installed). In the real flow `writeSkills` always runs
+    // first (install.ts); left `[]` the fallback simply writes nothing.
+    let pending = [];
     return {
         id: 'claude-code',
         label: APP_LABELS['claude-code'],
         skillsDir,
         writeSkills(skills) {
-            return skills.flatMap((s) => writeSkillTree(skillsDir(), s.slug, s.files));
+            pending = skills;
+            // Build the self-contained local plugin — the primary skills path. The
+            // actual register/install (and any loose-skills fallback) happens in
+            // `configureMcp`, which can await the `claude` CLI.
+            return buildLocalPlugin(pluginDir(), skills);
         },
         async configureMcp(serverUrl, token) {
-            // 1. Claude Code CLI — best-effort and FULLY ISOLATED: a CLI failure must
-            //    never block the desktop step below. A spawn ENOENT = not installed;
-            //    "already exists" (a re-run / `update`, exit 1) or any other failure is
-            //    logged as skipped, NOT thrown — the connector is already in place, and
-            //    the desktop bridge still gets written.
+            // 1. Claude Code CLI MCP connector — best-effort and FULLY ISOLATED: a CLI
+            //    failure must never block the plugin/desktop steps below. A spawn ENOENT
+            //    = not installed; "already exists" (a re-run / `update`, exit 1) or any
+            //    other failure is logged as skipped, NOT thrown.
+            let claudeMissing = false;
             try {
                 await env.exec('claude', claudeMcpAddArgs(CONNECTOR_NAME, serverUrl, token));
                 log(`Configured Claude Code CLI (${CONNECTOR_NAME})`);
             }
             catch (err) {
-                log(err.code === 'ENOENT'
-                    ? 'Claude Code CLI not found — skipped'
-                    : `Claude Code CLI not configured — skipped (${err.message})`);
+                if (err.code === 'ENOENT') {
+                    claudeMissing = true;
+                    log('Claude Code CLI not found — skipped');
+                }
+                else {
+                    log(`Claude Code CLI not configured — skipped (${err.message})`);
+                }
+            }
+            // 2. Skills plugin — register the local marketplace + install the plugin so
+            //    it auto-loads in the Claude Code CLI AND the Desktop app. If `claude`
+            //    is absent, fall back to a loose `~/.claude/skills/` write so the CLI
+            //    still gets the skills.
+            if (!claudeMissing) {
+                const { claudeFound } = await registerAndInstallPlugin(env.exec, pluginDir());
+                if (claudeFound) {
+                    log('Installed skills plugin (auto-loads in Claude Code + Desktop)');
+                }
+                else {
+                    claudeMissing = true;
+                }
+            }
+            if (claudeMissing && pending.length > 0) {
+                const written = pending.flatMap((s) => writeSkillTree(skillsDir(), s.slug, s.files));
+                for (const file of written)
+                    log(`  wrote ${file}`);
+                log('Claude CLI unavailable — wrote skills to ~/.claude/skills (Claude Code only)');
             }
-            // 2. Claude Desktop — macOS/Windows only; ALWAYS runs, independent of the CLI.
+            // 3. Claude Desktop MCP bridge — macOS/Windows only; ALWAYS runs, independent
+            //    of the CLI (skills reach Desktop via the plugin, above).
             const cfgPath = desktopPath();
             if (cfgPath !== null) {
                 const entry = claudeDesktopEntry(mcpEndpoint(serverUrl), token);
@@ -104,14 +139,12 @@ export function makeClaudeCodeAdapter(env) {
             }
         },
         dryRunPlan(serverUrl, token, skills) {
-            const lines = [];
-            for (const s of skills) {
-                for (const file of s.files) {
-                    lines.push(`would write ${path.join(skillsDir(), s.slug, file.path)}`);
-                }
-            }
+            // Skills plugin build + register/install.
+            const lines = pluginDryRunLines(pluginDir(), skills);
+            // MCP connector.
             const args = claudeMcpAddArgs(CONNECTOR_NAME, serverUrl, token);
             lines.push(`would run: claude ${args.join(' ')}`);
+            // Desktop bridge.
             const cfgPath = desktopPath();
             if (cfgPath !== null) {
                 const entry = claudeDesktopEntry(mcpEndpoint(serverUrl), token);

package/dist/apps/claude-plugin.js

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { configDir } from '../config.js';
+import { writeSkillTree } from '../skills.js';
+/**
+ * Self-contained local Claude Code **plugin** built from the fetched skills, then
+ * registered + installed via the `claude` CLI. This is the primary skills path
+ * for Claude Code: a plugin installed into the shared `~/.claude/plugins/`
+ * registry auto-loads in BOTH the Claude Code **CLI** and the Claude **Desktop**
+ * app (Desktop shares that registry — the loose `~/.claude/skills/` directory is
+ * NOT read by Desktop), with zero manual steps and no GitHub-repo access.
+ *
+ * The plugin is fully self-contained (no symlinks, no remote source): a
+ * `marketplace.json` with one plugin whose `source` is `"./"` (the marketplace
+ * root IS the plugin), a `plugin.json`, and the skill trees under `skills/`.
+ */
+/** Marketplace `name` — how the plugin is referenced (`<plugin>@<marketplace>`). */
+export const MARKETPLACE_NAME = 'reel-edge';
+/** Plugin `name` — becomes the skill namespace (`reel-edge-skills:<skill>`). */
+export const PLUGIN_NAME = 'reel-edge-skills';
+/** Plugin version — bump to push skill-content updates to installed users. */
+export const PLUGIN_VERSION = '1.0.0';
+/** `<plugin>@<marketplace>` reference used by `claude plugin install`. */
+export const PLUGIN_REF = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+/** Clean, user-facing description shared by the marketplace entry + plugin.json. */
+const PLUGIN_DESCRIPTION = 'Read-only domain skills for the Reel Edge MCP server: Reel Explorer (Xano ' +
+    'database query guide), Inbox Scout (player emails), and HubSpot CRM.';
+/**
+ * Absolute directory of the self-contained local plugin. Lives under the CLI's
+ * config home so it's stable across runs and `REELEDGE_CONFIG_DIR`-aware (tests
+ * point it at a temp dir).
+ */
+export function claudePluginDir() {
+    return path.join(configDir(), 'claude-plugin');
+}
+/**
+ * `.claude-plugin/marketplace.json` body: the `reel-edge` marketplace with one
+ * plugin (`reel-edge-skills`) whose `source` is `"./"` — the marketplace root is
+ * the plugin itself, so no external fetch is ever needed.
+ */
+export function marketplaceManifest() {
+    const body = {
+        $schema: 'https://anthropic.com/claude-code/marketplace.schema.json',
+        name: MARKETPLACE_NAME,
+        description: 'Reel Edge agent skills',
+        owner: { name: 'Reel Edge' },
+        plugins: [
+            {
+                name: PLUGIN_NAME,
+                source: './',
+                description: PLUGIN_DESCRIPTION,
+                version: PLUGIN_VERSION,
+                category: 'data',
+            },
+        ],
+    };
+    return `${JSON.stringify(body, null, 2)}\n`;
+}
+/** `.claude-plugin/plugin.json` body for the `reel-edge-skills` plugin. */
+export function pluginManifest() {
+    const body = {
+        name: PLUGIN_NAME,
+        version: PLUGIN_VERSION,
+        description: PLUGIN_DESCRIPTION,
+    };
+    return `${JSON.stringify(body, null, 2)}\n`;
+}
+/**
+ * Build the self-contained plugin at `dir`:
+ *   dir/.claude-plugin/marketplace.json
+ *   dir/.claude-plugin/plugin.json
+ *   dir/skills/<slug>/SKILL.md (+ references/**)
+ * Returns the written absolute file paths (manifests first, then skill files).
+ * Reuses {@link writeSkillTree}, so the same path-traversal guards apply.
+ */
+export function buildLocalPlugin(dir, skills) {
+    const metaDir = path.join(dir, '.claude-plugin');
+    fs.mkdirSync(metaDir, { recursive: true });
+    const marketplacePath = path.join(metaDir, 'marketplace.json');
+    const pluginPath = path.join(metaDir, 'plugin.json');
+    fs.writeFileSync(marketplacePath, marketplaceManifest(), 'utf8');
+    fs.writeFileSync(pluginPath, pluginManifest(), 'utf8');
+    const written = [marketplacePath, pluginPath];
+    const skillsRoot = path.join(dir, 'skills');
+    for (const s of skills) {
+        written.push(...writeSkillTree(skillsRoot, s.slug, s.files));
+    }
+    return written;
+}
+/** argv for `claude plugin marketplace add <dir> --scope user`. */
+export function marketplaceAddArgs(dir) {
+    return ['plugin', 'marketplace', 'add', dir, '--scope', 'user'];
+}
+/** argv for `claude plugin install reel-edge-skills@reel-edge --scope user`. */
+export function pluginInstallArgs() {
+    return ['plugin', 'install', PLUGIN_REF, '--scope', 'user'];
+}
+/** True for a spawn ENOENT (the `claude` binary isn't on PATH). */
+function isEnoent(err) {
+    return err?.code === 'ENOENT';
+}
+/**
+ * Register the local marketplace + install the plugin at **user scope** via the
+ * `claude` CLI, so it auto-loads in the CLI and Desktop.
+ *
+ * - **ENOENT-safe**: a missing `claude` binary short-circuits and returns
+ *   `{ claudeFound: false }` so the caller can fall back to a loose skills write.
+ * - **Idempotent**: a non-ENOENT failure (marketplace/plugin already present on a
+ *   re-run or `update`) is tolerated — same-name `marketplace add` replaces the
+ *   prior entry, and a repeated `install` is a no-op — so re-running is safe.
+ */
+export async function registerAndInstallPlugin(exec, dir) {
+    try {
+        await exec('claude', marketplaceAddArgs(dir));
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return { claudeFound: false };
+        // else: tolerate (idempotent re-run) and still attempt the install.
+    }
+    try {
+        await exec('claude', pluginInstallArgs());
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return { claudeFound: false };
+        // else: tolerate (already installed).
+    }
+    return { claudeFound: true };
+}
+/** `--dry-run` lines describing the plugin build + register/install commands. */
+export function pluginDryRunLines(dir, skills) {
+    const lines = [
+        `would write ${path.join(dir, '.claude-plugin', 'marketplace.json')}`,
+        `would write ${path.join(dir, '.claude-plugin', 'plugin.json')}`,
+    ];
+    const skillsRoot = path.join(dir, 'skills');
+    for (const s of skills) {
+        for (const file of s.files) {
+            lines.push(`would write ${path.join(skillsRoot, s.slug, file.path)}`);
+        }
+    }
+    lines.push(`would run: claude ${marketplaceAddArgs(dir).join(' ')}`);
+    lines.push(`would run: claude ${pluginInstallArgs().join(' ')}`);
+    return lines;
+}

package/dist/apps/codex.js

@@ -8,15 +8,26 @@ import { APP_LABELS, CONNECTOR_NAME, } from './types.js';
  * MCP servers under `[mcp_servers.<name>]`; a remote Streamable-HTTP server is
  * indicated by a `url` key (no `transport`), and a literal `Authorization`
  * header goes in a static `http_headers` inline table. Codex also has a skills
- * concept — per-skill `SKILL.md` directories under `~/.agents/skills/`.
+ * concept — per-skill `SKILL.md` directories (with optional `references/`,
+ * `scripts/`, `assets/` alongside) under `~/.codex/skills/<slug>/`.
  *
- * Verified against https://developers.openai.com/codex/mcp,
- * https://developers.openai.com/codex/config-reference and
- * https://developers.openai.com/codex/skills (Jun 2026).
+ * Skills path corrected (bug fix): user/global skills load from
+ * `~/.codex/skills`, NOT `~/.agents/skills`. The published docs page
+ * (https://developers.openai.com/codex/skills) still lists `~/.agents/skills`
+ * as the user-level dir, but that is stale/aspirational: an openai/codex
+ * maintainer states skills must live in a `.codex` path for Codex to see them
+ * (github.com/openai/codex/discussions/9682, `.agents/skills` being only a
+ * proposed cross-agent standard), a regression thread confirms `~/.agents/skills`
+ * is no longer discovered in new sessions
+ * (community.openai.com/t/.../1379522), and Codex itself keeps its home under
+ * `~/.codex/` (config.toml, auth.json, vendor_imports/, skills/).
+ *
+ * MCP config verified against https://developers.openai.com/codex/mcp and
+ * https://developers.openai.com/codex/config-reference (Jun 2026).
  */
-/** Absolute path to the Codex skills tree. */
+/** Absolute path to the Codex skills tree (`~/.codex/skills`). */
 function codexSkillsDir(env) {
-    return path.join(env.homeDir, '.agents', 'skills');
+    return path.join(env.homeDir, '.codex', 'skills');
 }
 /** Absolute path to the Codex config file. */
 function codexConfigPath(env) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reeledge/agent-tools",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "description": "Reel Edge agent-tools installer CLI — installs/updates the Reel Edge MCP connector + skills for Claude Code / Codex / Droid.",
   "type": "module",