@nucleoicons/skills 0.1.4 → 0.1.6

package/README.md

@@ -25,9 +25,9 @@ npx @nucleoicons/skills setup --target react --tools cursor
 npx @nucleoicons/skills setup --target vanilla --tools cursor,claude
 ```
 
-Setup installs the package under your user home (`~/.nucleo/skills`) and configures the editors you choose.
+Setup installs the package under your user home (`~/.nucleo/skills`) and configures the editors you choose (skills + MCP, no manual config step).
 
-After setup, follow any MCP steps printed in the terminal, reload MCP in your editor, then ask something like:
+Reload MCP in your editor, then ask something like:
 
 ```text
 What Nucleo icon families do I have?
@@ -47,8 +47,8 @@ After updating, reload MCP in your editor again.
 
 ## Editors
 
-| Tool        | `--tools` value |
-| ----------- | --------------- |
-| Cursor      | `cursor`        |
-| Claude Code | `claude`        |
-| Codex       | `codex`         |
+| Tool        | `--tools` value | Auto-configured |
+| ----------- | --------------- | --------------- |
+| Cursor      | `cursor`        | `~/.cursor/mcp.json` + `~/.cursor/skills/` |
+| Claude Code | `claude`        | `~/.claude.json` + `~/.claude/skills/` |
+| Codex       | `codex`         | `~/.codex/config.toml` + `~/.agents/skills/` |

package/dist/adapters/agents.d.ts

@@ -1,17 +1,25 @@
 import { type AgentTool } from "../config.js";
+/** Remove an existing `[mcp_servers.<name>]` table (+ nested tables), then append `block`. */
+export declare function upsertTomlMcpServer(toml: string, serverName: string, block: string): string;
 /** Merge nucleo-icons into ~/.cursor/mcp.json and copy skills to ~/.cursor/skills */
 export declare function configureCursor(root?: string): Promise<{
     mcpPath: string;
+    skillsPath: string;
     skills: string[];
 }>;
-/** Copy skills to ~/.claude/skills and print MCP snippet (Claude uses `claude mcp add` or config file) */
+/**
+ * Copy skills to ~/.claude/skills and merge MCP into ~/.claude.json
+ * (user-scope mcpServers — same file `claude mcp add --scope user` writes).
+ */
 export declare function configureClaude(root?: string): Promise<{
+    mcpPath: string;
+    skillsPath: string;
     skills: string[];
-    hint: string;
 }>;
-/** Copy skills to ~/.agents/skills and print Codex config.toml snippet */
+/** Copy skills to ~/.agents/skills and merge MCP into ~/.codex/config.toml */
 export declare function configureCodex(root?: string): Promise<{
+    mcpPath: string;
+    skillsPath: string;
     skills: string[];
-    hint: string;
 }>;
 export declare function configureTool(tool: AgentTool, root?: string): Promise<void>;

package/dist/adapters/agents.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { installRoot } from "../config.js";
 import { mcpEntryPath, skillsSourceDir } from "../install.js";
+const MCP_SERVER_NAME = "nucleo-icons";
 async function readJsonFile(path, fallback) {
     if (!existsSync(path)) {
         return fallback;
@@ -40,60 +41,101 @@ function nucleoMcpServerConfig(root = installRoot()) {
         },
     };
 }
+function escapeTomlString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+/** Remove an existing `[mcp_servers.<name>]` table (+ nested tables), then append `block`. */
+export function upsertTomlMcpServer(toml, serverName, block) {
+    const prefix = `mcp_servers.${serverName}`;
+    const lines = toml.length > 0 ? toml.split(/\r?\n/) : [];
+    const kept = [];
+    let skipping = false;
+    for (const line of lines) {
+        const header = line.match(/^\[([^\]]+)\]\s*$/);
+        if (header) {
+            const name = header[1];
+            skipping = name === prefix || name.startsWith(`${prefix}.`);
+        }
+        if (!skipping) {
+            kept.push(line);
+        }
+    }
+    let result = kept.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+    if (result.length > 0) {
+        result += "\n\n";
+    }
+    return `${result}${block.trimEnd()}\n`;
+}
+function nucleoCodexTomlBlock(root = installRoot()) {
+    const entry = escapeTomlString(mcpEntryPath(root));
+    const skillsRoot = escapeTomlString(root);
+    return [
+        `[mcp_servers.${MCP_SERVER_NAME}]`,
+        'command = "node"',
+        `args = ["${entry}"]`,
+        "",
+        `[mcp_servers.${MCP_SERVER_NAME}.env]`,
+        `NUCLEO_SKILLS_ROOT = "${skillsRoot}"`,
+    ].join("\n");
+}
 /** Merge nucleo-icons into ~/.cursor/mcp.json and copy skills to ~/.cursor/skills */
 export async function configureCursor(root = installRoot()) {
     const cursorDir = join(homedir(), ".cursor");
     const mcpPath = join(cursorDir, "mcp.json");
+    const skillsPath = join(cursorDir, "skills");
     await mkdir(cursorDir, { recursive: true });
     const mcp = await readJsonFile(mcpPath, { mcpServers: {} });
     mcp.mcpServers = mcp.mcpServers ?? {};
-    mcp.mcpServers["nucleo-icons"] = nucleoMcpServerConfig(root);
+    mcp.mcpServers[MCP_SERVER_NAME] = nucleoMcpServerConfig(root);
     await writeFile(mcpPath, `${JSON.stringify(mcp, null, 2)}\n`, "utf8");
-    const skills = await copySkillFolders(join(cursorDir, "skills"), root);
-    return { mcpPath, skills };
+    const skills = await copySkillFolders(skillsPath, root);
+    return { mcpPath, skillsPath, skills };
 }
-/** Copy skills to ~/.claude/skills and print MCP snippet (Claude uses `claude mcp add` or config file) */
+/**
+ * Copy skills to ~/.claude/skills and merge MCP into ~/.claude.json
+ * (user-scope mcpServers — same file `claude mcp add --scope user` writes).
+ */
 export async function configureClaude(root = installRoot()) {
     const claudeDir = join(homedir(), ".claude");
-    const skills = await copySkillFolders(join(claudeDir, "skills"), root);
-    const hint = [
-        "Add the MCP server with:",
-        "",
-        `  claude mcp add --scope user --transport stdio nucleo-icons \\`,
-        `    --env NUCLEO_SKILLS_ROOT=${root} \\`,
-        `    -- node ${mcpEntryPath(root)}`,
-        "",
-        "Or merge the same command/args/env into your Claude MCP config.",
-    ].join("\n");
-    return { skills, hint };
+    const mcpPath = join(homedir(), ".claude.json");
+    const skillsPath = join(claudeDir, "skills");
+    await mkdir(claudeDir, { recursive: true });
+    const config = await readJsonFile(mcpPath, {});
+    config.mcpServers = config.mcpServers ?? {};
+    config.mcpServers[MCP_SERVER_NAME] = {
+        type: "stdio",
+        ...nucleoMcpServerConfig(root),
+    };
+    await writeFile(mcpPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    const skills = await copySkillFolders(skillsPath, root);
+    return { mcpPath, skillsPath, skills };
 }
-/** Copy skills to ~/.agents/skills and print Codex config.toml snippet */
+/** Copy skills to ~/.agents/skills and merge MCP into ~/.codex/config.toml */
 export async function configureCodex(root = installRoot()) {
-    const skills = await copySkillFolders(join(homedir(), ".agents", "skills"), root);
-    const hint = [
-        "Add to ~/.codex/config.toml:",
-        "",
-        "[mcp_servers.nucleo-icons]",
-        'command = "node"',
-        `args = ["${mcpEntryPath(root)}"]`,
-        `env = { NUCLEO_SKILLS_ROOT = "${root}" }`,
-    ].join("\n");
-    return { skills, hint };
+    const codexDir = join(homedir(), ".codex");
+    const mcpPath = join(codexDir, "config.toml");
+    const skillsPath = join(homedir(), ".agents", "skills");
+    await mkdir(codexDir, { recursive: true });
+    const existing = existsSync(mcpPath) ? await readFile(mcpPath, "utf8") : "";
+    const next = upsertTomlMcpServer(existing, MCP_SERVER_NAME, nucleoCodexTomlBlock(root));
+    await writeFile(mcpPath, next, "utf8");
+    const skills = await copySkillFolders(skillsPath, root);
+    return { mcpPath, skillsPath, skills };
 }
 export async function configureTool(tool, root = installRoot()) {
     if (tool === "cursor") {
         const result = await configureCursor(root);
         console.log(`  Cursor MCP → ${result.mcpPath}`);
-        console.log(`  Cursor skills → ~/.cursor/skills/ (${result.skills.join(", ")})`);
+        console.log(`  Cursor skills → ${result.skillsPath} (${result.skills.join(", ")})`);
         return;
     }
     if (tool === "claude") {
         const result = await configureClaude(root);
-        console.log(`  Claude skills → ~/.claude/skills/ (${result.skills.join(", ")})`);
-        console.log(result.hint);
+        console.log(`  Claude MCP → ${result.mcpPath}`);
+        console.log(`  Claude skills → ${result.skillsPath} (${result.skills.join(", ")})`);
         return;
     }
     const result = await configureCodex(root);
-    console.log(`  Codex skills → ~/.agents/skills/ (${result.skills.join(", ")})`);
-    console.log(result.hint);
+    console.log(`  Codex MCP → ${result.mcpPath}`);
+    console.log(`  Codex skills → ${result.skillsPath} (${result.skills.join(", ")})`);
 }

package/dist/install.d.ts

@@ -1,5 +1,11 @@
 import { type SkillsReleaseData } from "./api.js";
 import { type InstallManifest, type PackageTarget } from "./config.js";
+/**
+ * Resolve a real npm binary. Prefer the one next to the running Node
+ * (`process.execPath`) so we don't depend on PATH / shell aliases
+ * (common cause of `spawn npm ENOENT` even when `npm -v` works in zsh).
+ */
+export declare function resolveNpmBin(): string;
 export declare function readInstallManifest(root?: string): Promise<InstallManifest | null>;
 export declare function cleanInstallRoot(root?: string): Promise<void>;
 /**

package/dist/install.js

@@ -1,12 +1,47 @@
 import { existsSync } from "node:fs";
-import { cp, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import extract from "extract-zip";
 import { downloadUrlToFile, formatBytes } from "./api.js";
 import { installRoot, nucleoHomeDir } from "./config.js";
 const execFileAsync = promisify(execFile);
+/**
+ * Resolve a real npm binary. Prefer the one next to the running Node
+ * (`process.execPath`) so we don't depend on PATH / shell aliases
+ * (common cause of `spawn npm ENOENT` even when `npm -v` works in zsh).
+ */
+export function resolveNpmBin() {
+    const binDir = dirname(process.execPath);
+    const candidates = process.platform === "win32"
+        ? [join(binDir, "npm.cmd"), join(binDir, "npm.exe"), "npm.cmd", "npm"]
+        : [join(binDir, "npm"), "npm"];
+    for (const candidate of candidates) {
+        if (candidate === "npm" || candidate === "npm.cmd" || existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+async function runNpm(args, cwd) {
+    const npmBin = resolveNpmBin();
+    try {
+        await execFileAsync(npmBin, args, {
+            cwd,
+            env: process.env,
+            // Windows .cmd shims need a shell; Unix absolute paths do not.
+            shell: process.platform === "win32",
+        });
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`${detail}\n` +
+            `Tried to run: ${npmBin} ${args.join(" ")}\n` +
+            `If npm is installed, ensure it sits next to node (${process.execPath}), or run:\n` +
+            `  cd ${cwd} && npm ${args.join(" ")}`);
+    }
+}
 export async function readInstallManifest(root = installRoot()) {
     const path = join(root, "manifest.json");
     if (!existsSync(path)) {
@@ -23,18 +58,49 @@ export async function cleanInstallRoot(root = installRoot()) {
     await rm(root, { recursive: true, force: true });
     await mkdir(root, { recursive: true });
 }
-/** Extract one zip into dest, merging (does not wipe dest first). */
+async function canRunUnzip() {
+    try {
+        await execFileAsync("unzip", ["-v"], { timeout: 5_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract one zip into dest (merge). Prefer system `unzip` — extract-zip + a
+ * full-tree cp of ~40k files is slow and has been hanging/exiting mid-install.
+ */
 async function extractZipMerge(zipPath, dest) {
-    const tmp = join(nucleoHomeDir(), `.extract-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-    await rm(tmp, { recursive: true, force: true });
-    await mkdir(tmp, { recursive: true });
+    await mkdir(dest, { recursive: true });
+    const heartbeat = setInterval(() => {
+        process.stdout.write(".");
+    }, 2_000);
     try {
-        await extract(zipPath, { dir: tmp });
-        await mkdir(dest, { recursive: true });
-        await cp(tmp, dest, { recursive: true });
+        if (await canRunUnzip()) {
+            // -o overwrite, -q quiet (we print our own progress)
+            await execFileAsync("unzip", ["-o", "-q", zipPath, "-d", dest], {
+                maxBuffer: 16 * 1024 * 1024,
+            });
+        }
+        else {
+            // Fallback: extract directly into dest (no tmp + cp)
+            await extract(zipPath, { dir: dest });
+        }
     }
     finally {
-        await rm(tmp, { recursive: true, force: true });
+        clearInterval(heartbeat);
+        process.stdout.write("\n");
+    }
+}
+/** Fail loudly if extract left an empty/incomplete install. */
+async function assertInstallLooksComplete(root) {
+    const required = ["mcp", "skills"];
+    const missing = required.filter((name) => !existsSync(join(root, name)));
+    if (missing.length > 0) {
+        const listing = existsSync(root) ? (await readdir(root)).join(", ") || "(empty)" : "(missing)";
+        throw new Error(`Install looks incomplete at ${root}. Missing: ${missing.join(", ")}. ` +
+            `Contents: ${listing}`);
     }
 }
 /**
@@ -88,17 +154,20 @@ export async function installFromRelease(release, target, root = installRoot())
         console.log("  Extracting…");
         await cleanInstallRoot(root);
         for (const file of downloaded) {
-            console.log(`  ▸ ${file.id}`);
+            const zipInfo = await stat(file.zipPath);
+            process.stdout.write(`  ▸ ${file.id} (${formatBytes(zipInfo.size)}) `);
             try {
                 await extractZipMerge(file.zipPath, root);
+                console.log(`  ✓ ${file.id}`);
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : String(error);
-                throw new Error(`Failed extracting ${file.id} (${formatBytes((await stat(file.zipPath)).size)}). ${detail}\n` +
+                throw new Error(`Failed extracting ${file.id} (${formatBytes(zipInfo.size)}). ${detail}\n` +
                     `If this keeps happening, free disk space or try again with:\n` +
                     `  NODE_OPTIONS=--max-old-space-size=8192 npx @nucleoicons/skills setup …`);
             }
         }
+        await assertInstallLooksComplete(root);
     }
     finally {
         await rm(downloadsDir, { recursive: true, force: true }).catch(() => undefined);
@@ -157,10 +226,7 @@ export async function buildMcp(root = installRoot()) {
     const hasDist = existsSync(distEntry);
     console.log("  npm install (mcp)…");
     try {
-        await execFileAsync("npm", ["install", "--omit=dev"], {
-            cwd: mcpDir,
-            env: process.env,
-        });
+        await runNpm(["install", "--omit=dev"], mcpDir);
     }
     catch (error) {
         const detail = error instanceof Error ? error.message : String(error);
@@ -169,10 +235,7 @@ export async function buildMcp(root = installRoot()) {
     if (!hasDist || existsSync(join(mcpDir, "src"))) {
         console.log("  npm run build (mcp)…");
         try {
-            await execFileAsync("npm", ["run", "build"], {
-                cwd: mcpDir,
-                env: process.env,
-            });
+            await runNpm(["run", "build"], mcpDir);
         }
         catch (error) {
             if (!existsSync(distEntry)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nucleoicons/skills",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "CLI to install and update Nucleo Pro MCP + icon skills",
   "type": "module",
   "bin": {