@girardmedia/bootspring 2.5.6 → 2.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardmedia/bootspring",
-  "version": "2.5.6",
+  "version": "2.5.8",
   "description": "Thin client for Bootspring cloud MCP, hosted agents, and paywalled workflow intelligence",
   "keywords": [
     "ai",

package/scripts/postinstall.cjs

@@ -6,11 +6,15 @@ const path = require('path');
 
 const c = {
   reset: '\x1b[0m',
+  bold: '\x1b[1m',
   green: '\x1b[32m',
+  yellow: '\x1b[33m',
   cyan: '\x1b[36m',
   dim: '\x1b[2m'
 };
 
+const HOME = os.homedir();
+
 function resolveCommandsSource() {
   const fromEnv = process.env.BOOTSPRING_COMMANDS_SOURCE;
   const candidates = [
@@ -108,11 +112,127 @@ function installBootspringSkill(skillsDir) {
   }
 }
 
+// ── MCP Server Registration ───────────────────────────────────────────
+//
+// Each assistant has its own MCP config file format. We register the
+// `bootspring` MCP server so that bootspring_build, bootspring_context,
+// bootspring_quality, etc. are exposed as tools in every project — no
+// per-project .mcp.json required.
+//
+// All registrations are idempotent (skip if already configured) and
+// failure-tolerant (silently skip on permission/IO errors so a broken
+// assistant config never blocks `npm install`).
+
+function registerClaudeMcp() {
+  // Claude Code v2.x reads user-scope MCP servers from ~/.claude.json
+  // (the file at home root, NOT inside the ~/.claude/ directory).
+  const configPath = path.join(HOME, '.claude.json');
+  try {
+    let config = {};
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, 'utf8');
+      config = raw.trim() ? JSON.parse(raw) : {};
+    }
+    if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+      config.mcpServers = {};
+    }
+    // Skip if ANY bootspring entry exists — never clobber user customizations.
+    if (config.mcpServers.bootspring) {
+      return { name: 'Claude Code', status: 'unchanged', path: configPath };
+    }
+    config.mcpServers.bootspring = {
+      type: 'stdio',
+      command: 'bootspring',
+      args: ['mcp'],
+      env: { BOOTSPRING_ASSISTANT: 'claude' }
+    };
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+    return { name: 'Claude Code', status: 'updated', path: configPath };
+  } catch (err) {
+    return { name: 'Claude Code', status: 'skipped', path: configPath, reason: err.message };
+  }
+}
+
+function registerCodexMcp() {
+  // Codex reads MCP servers from ~/.codex/config.toml under [mcp_servers.<name>]
+  const configPath = path.join(HOME, '.codex', 'config.toml');
+  try {
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+    if (existing.includes('[mcp_servers.bootspring]')) {
+      return { name: 'Codex', status: 'unchanged', path: configPath };
+    }
+    const block = '[mcp_servers.bootspring]\ncommand = "bootspring"\nargs = ["mcp"]\nenv = { BOOTSPRING_ASSISTANT = "codex" }\n';
+    const content = existing.length > 0 ? `${existing.trimEnd()}\n\n${block}` : block;
+    fs.writeFileSync(configPath, content, 'utf8');
+    return { name: 'Codex', status: 'updated', path: configPath };
+  } catch (err) {
+    return { name: 'Codex', status: 'skipped', path: configPath, reason: err.message };
+  }
+}
+
+function registerGeminiMcp() {
+  // Gemini CLI reads MCP servers from ~/.gemini/settings.json under "mcpServers"
+  const configPath = path.join(HOME, '.gemini', 'settings.json');
+  try {
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    let settings = {};
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, 'utf8');
+      settings = raw.trim() ? JSON.parse(raw) : {};
+    }
+    if (!settings.mcpServers || typeof settings.mcpServers !== 'object') {
+      settings.mcpServers = {};
+    }
+    // Skip if ANY bootspring entry exists — never clobber user customizations.
+    if (settings.mcpServers.bootspring) {
+      return { name: 'Gemini CLI', status: 'unchanged', path: configPath };
+    }
+    settings.mcpServers.bootspring = {
+      command: 'bootspring',
+      args: ['mcp'],
+      env: { BOOTSPRING_ASSISTANT: 'gemini' }
+    };
+    fs.writeFileSync(configPath, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+    return { name: 'Gemini CLI', status: 'updated', path: configPath };
+  } catch (err) {
+    return { name: 'Gemini CLI', status: 'skipped', path: configPath, reason: err.message };
+  }
+}
+
+function registerAllMcp() {
+  return [registerClaudeMcp(), registerCodexMcp(), registerGeminiMcp()];
+}
+
+function isFirstInstall() {
+  // Heuristic: a first install is one where Claude Code config does NOT yet
+  // have a bootspring entry. Updates to an existing install will already
+  // have one and shouldn't see the welcome screen.
+  try {
+    const claudeConfig = path.join(HOME, '.claude.json');
+    if (!fs.existsSync(claudeConfig)) return true;
+    const raw = fs.readFileSync(claudeConfig, 'utf8');
+    if (!raw.trim()) return true;
+    const parsed = JSON.parse(raw);
+    return !parsed?.mcpServers?.bootspring;
+  } catch {
+    return false;
+  }
+}
+
 function main() {
   if (process.env.CI || process.env.BOOTSPRING_SKIP_POSTINSTALL) {
     return;
   }
 
+  // Capture this BEFORE we run any registration so the welcome message
+  // only fires the first time bootspring is installed on this machine.
+  const firstInstall = isFirstInstall();
+
   let totalCommandsInstalled = 0;
   let totalSkillsInstalled = 0;
   const installedTo = [];
@@ -128,16 +248,53 @@ function main() {
     }
   }
 
-  if (totalCommandsInstalled > 0 || totalSkillsInstalled > 0) {
+  // Register the Bootspring MCP server with each assistant so its tools
+  // (bootspring_build, bootspring_context, bootspring_quality, etc.) are
+  // available everywhere — no per-project .mcp.json needed.
+  const mcpResults = registerAllMcp();
+  const mcpUpdated = mcpResults.filter((r) => r.status === 'updated');
+  const mcpUnchanged = mcpResults.filter((r) => r.status === 'unchanged');
+  const mcpSkipped = mcpResults.filter((r) => r.status === 'skipped');
+
+  const didAnything =
+    totalCommandsInstalled > 0 ||
+    totalSkillsInstalled > 0 ||
+    mcpUpdated.length > 0;
+
+  if (didAnything) {
     console.log(`
 ${c.cyan}⚡ Bootspring${c.reset} assistant integrations installed!
 
 ${c.dim}Installed:${c.reset}
   ${c.green}${totalCommandsInstalled}${c.reset} slash command templates
   ${c.green}${totalSkillsInstalled}${c.reset} Bootspring base skills
+  ${c.green}${mcpUpdated.length}${c.reset} MCP server registrations${mcpUnchanged.length > 0 ? ` ${c.dim}(${mcpUnchanged.length} already configured)${c.reset}` : ''}
+`);
+
+    if (mcpUpdated.length > 0) {
+      console.log(`${c.dim}MCP registered for:${c.reset} ${mcpUpdated.map((r) => r.name).join(', ')}`);
+    }
+    if (installedTo.length > 0) {
+      console.log(`${c.dim}Commands & skills installed to:${c.reset} ${installedTo.join(', ')}`);
+    }
+    if (mcpSkipped.length > 0) {
+      console.log(`${c.yellow}Note:${c.reset} ${c.dim}MCP registration skipped for ${mcpSkipped.map((r) => r.name).join(', ')} — run \`bootspring setup\` to retry.${c.reset}`);
+    }
+
+    if (firstInstall) {
+      console.log(`
+${c.bold}Next steps:${c.reset}
+  ${c.cyan}1.${c.reset} Restart your assistant (Claude Code / Codex / Gemini) so MCP loads
+  ${c.cyan}2.${c.reset} ${c.green}bootspring auth login${c.reset}     ${c.dim}# authenticate (opens browser)${c.reset}
+  ${c.cyan}3.${c.reset} ${c.green}cd${c.reset} into a project, then ${c.green}bootspring go${c.reset}  ${c.dim}# one-shot setup${c.reset}
 
-${c.dim}Installed to: ${installedTo.join(', ')}${c.reset}
+${c.dim}Run ${c.reset}${c.green}bootspring${c.reset}${c.dim} with no args to see the welcome screen.${c.reset}
 `);
+    } else {
+      console.log(`
+${c.dim}Restart your assistant (Claude Code, Codex, or Gemini CLI) to load the bootspring MCP tools.${c.reset}
+`);
+    }
   }
 }