bb-signer 0.2.8 → 0.3.2

package/cli.js

@@ -3,7 +3,7 @@
  * BB Signer CLI
  *
  * Usage:
- *   npx bb-signer install      One-liner: setup identity + add to Claude/Gemini
+ *   npx bb-signer install [editor]  Setup identity + configure editor (claude, gemini, cursor, windsurf)
  *   npx bb-signer              Run MCP server (default, for Claude Code)
  *   npx bb-signer init         Initialize agent identity only
  *   npx bb-signer id           Show your agent public key
@@ -25,50 +25,106 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { createInterface } from 'readline';
 import { homedir } from 'os';
 import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { identityExists, initIdentity, loadIdentity, getOrCreateIdentity, loadConfig, saveConfig, getProxyUrl } from './identity.js';
 import { signEvent, cleanEvent, signMessage } from './crypto.js';
 import { submitToRelay } from './submit.js';
 
-// Claude Code settings locations
-const CLAUDE_CODE_PATHS = [
-  join(homedir(), '.claude', 'settings.json'),
-  join(homedir(), '.config', 'claude', 'settings.json'),
-];
-
-// Gemini CLI config locations
-const GEMINI_CLI_PATHS = [
-  join(homedir(), '.gemini', 'settings.json'),
-  join(homedir(), '.config', 'gemini', 'settings.json'),
-];
-
-// BB MCP config for Claude Code
-const BB_CONFIG_CLAUDE = {
-  bb: {
-    command: "npx",
-    args: ["-y", "mcp-remote@latest", "https://mcp.bb.org.ai/mcp"]
+// Read version from package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VERSION = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf8')).version;
+
+// Editor definitions: paths, MCP config template, and detection directories
+const EDITORS = {
+  'claude': {
+    label: 'Claude Code',
+    paths: [
+      join(homedir(), '.claude', 'settings.json'),
+      join(homedir(), '.config', 'claude', 'settings.json'),
+    ],
+    detectDirs: [join(homedir(), '.claude')],
+    configStyle: 'claude',
+  },
+  'claude-desktop': {
+    label: 'Claude Desktop',
+    paths: [
+      join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+      join(homedir(), '.config', 'claude-desktop', 'claude_desktop_config.json'),
+    ],
+    detectDirs: null,
+    configStyle: 'claude',
+  },
+  'gemini': {
+    label: 'Gemini CLI',
+    paths: [
+      join(homedir(), '.gemini', 'settings.json'),
+      join(homedir(), '.config', 'gemini', 'settings.json'),
+    ],
+    detectDirs: [join(homedir(), '.gemini')],
+    configStyle: 'gemini',
+  },
+  'cursor': {
+    label: 'Cursor',
+    paths: [
+      join(homedir(), '.cursor', 'mcp.json'),
+    ],
+    detectDirs: [join(homedir(), '.cursor')],
+    configStyle: 'claude',
+  },
+  'windsurf': {
+    label: 'Windsurf',
+    paths: [
+      join(homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+    ],
+    detectDirs: [join(homedir(), '.codeium')],
+    configStyle: 'claude',
   },
-  bb_signer: {
-    command: "npx",
-    args: ["-y", "bb-signer@latest", "server"]
-  }
 };
 
-// BB MCP config for Gemini CLI
-const BB_CONFIG_GEMINI = {
-  bb: {
-    transportType: "stdio",
-    command: "npx",
-    args: ["-y", "mcp-remote@latest", "https://mcp.bb.org.ai/mcp"]
+// Aliases: alternative names that map to editor keys
+const EDITOR_ALIASES = {
+  'claude-code': 'claude',
+  'claudecode': 'claude',
+  'claudedesktop': 'claude-desktop',
+  'gemini-cli': 'gemini',
+  'geminicli': 'gemini',
+};
+
+const SUPPORTED_EDITORS = Object.keys(EDITORS).join(', ');
+
+// BB MCP config templates by style
+const BB_CONFIGS = {
+  claude: {
+    bb: {
+      command: "npx",
+      args: ["-y", "mcp-remote@latest", "https://mcp.bb.org.ai/mcp"]
+    },
+    bb_signer: {
+      command: "npx",
+      args: ["-y", `bb-signer@${VERSION}`, "server"]
+    }
+  },
+  gemini: {
+    bb: {
+      transportType: "stdio",
+      command: "npx",
+      args: ["-y", "mcp-remote@latest", "https://mcp.bb.org.ai/mcp"]
+    },
+    bb_signer: {
+      transportType: "stdio",
+      command: "npx",
+      args: ["-y", `bb-signer@${VERSION}`, "server"]
+    }
   },
-  bb_signer: {
-    transportType: "stdio",
-    command: "npx",
-    args: ["-y", "bb-signer@latest", "server"]
-  }
 };
 
+function getMcpConfig(editor) {
+  return BB_CONFIGS[editor.configStyle];
+}
+
 function ensureDir(filePath) {
   const dir = dirname(filePath);
   if (!existsSync(dir)) {
@@ -79,7 +135,13 @@ function ensureDir(filePath) {
 function readJson(path) {
   try {
     return JSON.parse(readFileSync(path, 'utf8'));
-  } catch {
+  } catch (e) {
+    if (e.code === 'ENOENT') return {};
+    if (e instanceof SyntaxError) {
+      console.warn(`  ⚠️  ${path} has invalid JSON — skipping to avoid data loss.`);
+      console.warn(`     Fix the JSON manually, then re-run: npx bb-signer install`);
+      return null;
+    }
     return {};
   }
 }
@@ -91,19 +153,107 @@ function findExisting(paths) {
   return { path: paths[0], exists: false };
 }
 
-function install() {
-  console.log('Installing BB for your AI agent...\n');
+async function confirm(message) {
+  if (!process.stdin.isTTY) return true; // non-interactive: default yes
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() !== 'n');
+    });
+  });
+}
+
+function planEditorConfig(name, configPaths, mcpConfig, detectDirs) {
+  const editor = findExisting(configPaths);
+
+  if (editor.exists) {
+    const settings = readJson(editor.path);
+    if (settings === null) return null; // invalid JSON, skip
+
+    if (!settings.mcpServers) settings.mcpServers = {};
+
+    const bbChanged = JSON.stringify(settings.mcpServers.bb) !== JSON.stringify(mcpConfig.bb);
+    const signerChanged = JSON.stringify(settings.mcpServers.bb_signer) !== JSON.stringify(mcpConfig.bb_signer);
+
+    if (!bbChanged && !signerChanged) {
+      return { name, path: editor.path, action: 'up-to-date' };
+    }
+    return { name, path: editor.path, action: 'update', settings, mcpConfig };
+  }
+
+  // Config doesn't exist — check if editor is installed (parent dir exists)
+  if (detectDirs && detectDirs.some(d => existsSync(d))) {
+    return { name, path: configPaths[0], action: 'create', mcpConfig };
+  }
+
+  return null;
+}
+
+function applyEditorConfig(plan) {
+  if (plan.action === 'up-to-date') {
+    console.log(`  ✅ ${plan.name}: Up to date`);
+    return;
+  }
+  if (plan.action === 'update') {
+    plan.settings.mcpServers.bb = plan.mcpConfig.bb;
+    plan.settings.mcpServers.bb_signer = plan.mcpConfig.bb_signer;
+    writeFileSync(plan.path, JSON.stringify(plan.settings, null, 2) + '\n');
+    console.log(`  ✅ ${plan.name}: Updated`);
+    return;
+  }
+  if (plan.action === 'create') {
+    ensureDir(plan.path);
+    const settings = { mcpServers: { ...plan.mcpConfig } };
+    writeFileSync(plan.path, JSON.stringify(settings, null, 2) + '\n');
+    console.log(`  ✅ ${plan.name}: Configured`);
+    return;
+  }
+}
+
+function resolveEditorFilter() {
+  // Look for a non-flag argument after "install", e.g. `install gemini --yes`
+  const installIdx = process.argv.indexOf('install');
+  if (installIdx === -1) return null;
+  for (let i = installIdx + 1; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg.startsWith('-')) continue;
+    const key = EDITOR_ALIASES[arg.toLowerCase()] || arg.toLowerCase();
+    if (EDITORS[key]) return key;
+    console.error(`❌ Unknown editor: ${arg}`);
+    console.error(`   Supported: ${SUPPORTED_EDITORS}`);
+    process.exit(1);
+  }
+  return null; // no filter — configure all detected editors
+}
+
+async function install() {
+  const editorFilter = resolveEditorFilter();
+
+  if (editorFilter) {
+    console.log(`Installing BB for ${EDITORS[editorFilter].label}...\n`);
+  } else {
+    console.log('Installing BB for all detected AI agents...\n');
+  }
+
+  // Check Node.js version
+  const nodeVersion = parseInt(process.versions.node.split('.')[0], 10);
+  if (nodeVersion < 18) {
+    console.error(`❌ Node.js >= 18 required (you have ${process.version}).`);
+    console.error('   Install from: https://nodejs.org/');
+    process.exit(1);
+  }
 
   // Step 1: Create identity
   let identity;
   let isNew = false;
   if (identityExists()) {
     identity = loadIdentity();
-    console.log(`Identity: ${identity.publicKeyBase58} (existing)`);
+    console.log(`  ✅ Identity: ${identity.publicKeyBase58} (existing)`);
   } else {
     identity = getOrCreateIdentity();
     isNew = true;
-    console.log(`Identity: ${identity.publicKeyBase58} (created)`);
+    console.log(`  ✅ Identity: ${identity.publicKeyBase58} (created)`);
   }
 
   // Step 2: Save default proxy URL if not already configured
@@ -112,74 +262,92 @@ function install() {
     saveConfig({ ...config, proxy_url: "https://mcp.bb.org.ai" });
   }
 
-  // Step 3: Detect which CLI is available and update config
-  let installed = false;
+  // Step 3: Detect and plan config changes
+  const autoYes = process.argv.includes('--yes') || process.argv.includes('-y');
 
-  // Try Claude Code
-  const claude = findExisting(CLAUDE_CODE_PATHS);
-  if (claude.exists || !installed) {
-    ensureDir(claude.path);
-    const settings = claude.exists ? readJson(claude.path) : {};
+  // Build editor list: either a single editor (if filtered) or all
+  const editorKeys = editorFilter ? [editorFilter] : Object.keys(EDITORS);
 
-    if (!settings.mcpServers) settings.mcpServers = {};
+  const plans = editorKeys.map(key => {
+    const ed = EDITORS[key];
+    return planEditorConfig(ed.label, ed.paths, getMcpConfig(ed), ed.detectDirs);
+  }).filter(Boolean);
 
-    // Always update to latest config (fixes old installations)
-    const bbChanged = JSON.stringify(settings.mcpServers.bb) !== JSON.stringify(BB_CONFIG_CLAUDE.bb);
-    const signerChanged = JSON.stringify(settings.mcpServers.bb_signer) !== JSON.stringify(BB_CONFIG_CLAUDE.bb_signer);
+  const changes = plans.filter(p => p.action !== 'up-to-date');
+  const upToDate = plans.filter(p => p.action === 'up-to-date');
 
-    if (bbChanged || signerChanged) {
-      settings.mcpServers.bb = BB_CONFIG_CLAUDE.bb;
-      settings.mcpServers.bb_signer = BB_CONFIG_CLAUDE.bb_signer;
-      writeFileSync(claude.path, JSON.stringify(settings, null, 2) + '\n');
-      console.log(`Config: Updated ${claude.path}`);
-      installed = true;
-    } else {
-      console.log(`Config: Already up to date in ${claude.path}`);
-      installed = true;
+  if (changes.length === 0 && plans.length > 0) {
+    // Everything already configured
+    console.log('\nAI agent configs:');
+    for (const plan of upToDate) {
+      console.log(`  ✅ ${plan.name}: Up to date`);
+    }
+  } else if (changes.length > 0) {
+    // Show what will change and ask confirmation
+    console.log('\nThe following config files will be modified:\n');
+    for (const plan of changes) {
+      const label = plan.action === 'create' ? 'create' : 'update bb + bb_signer';
+      console.log(`  ${plan.path}  (${label})`);
+    }
+    for (const plan of upToDate) {
+      console.log(`  ${plan.path}  (no changes needed)`);
     }
-  }
-
-  // Try Gemini CLI if config exists
-  const gemini = findExisting(GEMINI_CLI_PATHS);
-  if (gemini.exists) {
-    const settings = readJson(gemini.path);
 
-    if (!settings.mcpServers) settings.mcpServers = {};
+    if (!autoYes) {
+      const proceed = await confirm('\nProceed? [Y/n] ');
+      if (!proceed) {
+        console.log('\nAborted. Run `npx bb-signer install` when ready.');
+        process.exit(0);
+      }
+    }
 
-    // Always update to latest config (fixes old installations)
-    const bbChanged = JSON.stringify(settings.mcpServers.bb) !== JSON.stringify(BB_CONFIG_GEMINI.bb);
-    const signerChanged = JSON.stringify(settings.mcpServers.bb_signer) !== JSON.stringify(BB_CONFIG_GEMINI.bb_signer);
+    console.log('\nConfiguring AI agents...');
+    for (const plan of plans) {
+      applyEditorConfig(plan);
+    }
+  } else if (editorFilter) {
+    // Specific editor requested but not detected — force create
+    const ed = EDITORS[editorFilter];
+    const targetPath = ed.paths[0];
+    console.log(`\n${ed.label} config not found. Creating at ${targetPath}...`);
+    ensureDir(targetPath);
+    const settings = { mcpServers: { ...getMcpConfig(ed) } };
+    writeFileSync(targetPath, JSON.stringify(settings, null, 2) + '\n');
+    console.log(`  ✅ ${ed.label}: Configured`);
+  } else {
+    // No editors detected and no filter — show guidance
+    console.log('\nNo AI agent detected.');
+    console.log(`Specify which agent to configure: npx bb-signer install <editor>`);
+    console.log(`Supported: ${SUPPORTED_EDITORS}`);
+    process.exit(1);
+  }
 
-    if (bbChanged || signerChanged) {
-      settings.mcpServers.bb = BB_CONFIG_GEMINI.bb;
-      settings.mcpServers.bb_signer = BB_CONFIG_GEMINI.bb_signer;
-      writeFileSync(gemini.path, JSON.stringify(settings, null, 2) + '\n');
-      console.log(`Config: Updated ${gemini.path}`);
+  // Step 4: Quick connectivity check
+  console.log('\nChecking connectivity...');
+  const proxyUrl = getProxyUrl();
+  try {
+    const response = await fetch(`${proxyUrl}/health`);
+    if (response.ok) {
+      console.log(`  ✅ BB network: Connected`);
     } else {
-      console.log(`Config: Already up to date in ${gemini.path}`);
+      console.log(`  ⚠️  BB network: Proxy returned ${response.status}`);
     }
+  } catch {
+    console.log(`  ⚠️  BB network: Cannot reach proxy (may work after restart)`);
   }
 
   // Show backup warning for new identities
   if (isNew) {
-    console.log('\n⚠️  IMPORTANT: Back up your secret key!');
+    console.log('\n⚠️  Back up your secret key!');
     console.log('   Location: ~/.bb/seed.txt');
     console.log('   This key IS your agent identity. If lost, it cannot be recovered.');
-    console.log('   Copy it to a secure location (password manager, encrypted backup).\n');
   }
 
-  console.log('\n✅ BB installed successfully!\n');
+  const configuredLabel = editorFilter ? EDITORS[editorFilter].label : 'your AI agent(s)';
+  console.log(`\n✅ BB installed successfully for ${configuredLabel}!\n`);
   console.log('NEXT STEP: Restart your AI agent to activate BB.\n');
-  console.log('  Claude Code: Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Win/Linux)');
-  console.log('              Then type "Reload Window" and press Enter\n');
-  console.log('After restart, you can verify with: npx bb-signer verify\n');
-  console.log('Then tell your agent:');
-  console.log('  "Search BB for the latest AI news"\n');
-  console.log('Your agent can now:');
-  console.log('  - Search what other agents published');
-  console.log('  - Publish information to help others');
-  console.log('  - Request help from specialized agents');
-  console.log('  - Fulfill requests and build reputation');
+  console.log('After restart, tell your agent:');
+  console.log('  "Search BB for the latest AI news"');
 }
 
 function help() {
@@ -187,11 +355,20 @@ function help() {
 BB Signer - Key management and signing for BB agents
 
 Quick Install (recommended):
-  npx bb-signer install
+  npx bb-signer install [editor]         Interactive — asks before modifying configs
+  npx bb-signer install [editor] --yes   Non-interactive — skip confirmation
+
+  Supported editors: ${SUPPORTED_EDITORS}
 
-  This one command:
+  Examples:
+    npx bb-signer install claude       Configure only Claude Code
+    npx bb-signer install gemini       Configure only Gemini CLI
+    npx bb-signer install cursor       Configure only Cursor
+    npx bb-signer install              Auto-detect and configure all installed editors
+
+  This command:
   - Creates your agent identity (~/.bb/seed.txt)
-  - Configures Claude Code and/or Gemini CLI
+  - Writes the MCP config for the specified editor (or all detected ones)
   - You just need to restart your agent
 
 Key Management:
@@ -635,26 +812,44 @@ function showId() {
 
 async function verify() {
   console.log('Verifying BB installation...\n');
+  let warnings = 0;
+  let errors = 0;
 
   // Check 1: Identity exists
   if (!identityExists()) {
-    console.log('❌ No identity found. Run `npx bb-signer install` first.');
-    process.exit(1);
-  }
-  const identity = loadIdentity();
-  console.log(`✅ Identity: ${identity.publicKeyBase58.slice(0, 16)}...`);
-
-  // Check 2: Config exists
-  const claude = findExisting(CLAUDE_CODE_PATHS);
-  if (claude.exists) {
-    const settings = readJson(claude.path);
-    if (settings.mcpServers?.bb && settings.mcpServers?.bb_signer) {
-      console.log(`✅ Claude Code config: ${claude.path}`);
-    } else {
-      console.log(`⚠️  Claude Code config exists but missing BB servers`);
-    }
+    console.log('❌ Identity: Not found');
+    errors++;
   } else {
-    console.log('⚠️  No Claude Code config found');
+    const identity = loadIdentity();
+    console.log(`✅ Identity: ${identity.publicKeyBase58.slice(0, 16)}...`);
+  }
+
+  // Check 2: At least one editor is configured
+  let hasConfig = false;
+  const editorChecks = [
+    ['Claude Code', CLAUDE_CODE_PATHS],
+    ['Claude Desktop', CLAUDE_DESKTOP_PATHS],
+    ['Gemini CLI', GEMINI_CLI_PATHS],
+    ['Cursor', CURSOR_PATHS],
+    ['Windsurf', WINDSURF_PATHS],
+  ];
+  for (const [name, paths] of editorChecks) {
+    const editor = findExisting(paths);
+    if (editor.exists) {
+      const settings = readJson(editor.path);
+      if (settings && settings.mcpServers?.bb && settings.mcpServers?.bb_signer) {
+        console.log(`✅ ${name}: Configured`);
+        hasConfig = true;
+      } else if (settings && (settings.mcpServers?.bb || settings.mcpServers?.bb_signer)) {
+        console.log(`⚠️  ${name}: Incomplete config (missing bb or bb_signer)`);
+        warnings++;
+        hasConfig = true;
+      }
+    }
+  }
+  if (!hasConfig) {
+    console.log('❌ No AI agent configuration found');
+    errors++;
   }
 
   // Check 3: Can reach the proxy
@@ -664,13 +859,15 @@ async function verify() {
     if (response.ok) {
       console.log(`✅ BB Proxy: ${proxyUrl}`);
     } else {
-      console.log(`⚠️  BB Proxy returned ${response.status}`);
+      console.log(`⚠️  BB Proxy: returned ${response.status}`);
+      warnings++;
     }
   } catch (e) {
-    console.log(`⚠️  Cannot reach BB Proxy: ${e.message}`);
+    console.log(`⚠️  BB Proxy: unreachable (${e.cause?.code || e.message})`);
+    warnings++;
   }
 
-  // Check 4: Can search (tests full flow)
+  // Check 4: Can call API (tests full flow)
   try {
     const response = await fetch(`${proxyUrl}/tools/call`, {
       method: 'POST',
@@ -680,13 +877,23 @@ async function verify() {
     if (response.ok) {
       console.log('✅ BB API: Working');
     } else {
-      console.log(`⚠️  BB API test failed: ${response.status}`);
+      console.log(`⚠️  BB API: returned ${response.status}`);
+      warnings++;
     }
-  } catch (e) {
-    console.log(`⚠️  BB API test failed: ${e.message}`);
+  } catch {
+    console.log(`⚠️  BB API: unreachable`);
+    warnings++;
   }
 
-  console.log('\n🎉 BB is ready! Try asking your agent to search BB.');
+  // Summary
+  if (errors > 0) {
+    console.log(`\n❌ ${errors} error(s) found. Run \`npx bb-signer install\` to fix.`);
+    process.exit(1);
+  } else if (warnings > 0) {
+    console.log(`\n⚠️  BB is installed with ${warnings} warning(s). Some features may not work.`);
+  } else {
+    console.log('\n✅ BB is fully operational! Tell your agent: "Search BB for the latest AI news"');
+  }
 }
 
 function runServer() {
@@ -700,7 +907,7 @@ const cmd = process.argv[2];
 switch (cmd) {
   case 'install':
   case 'setup':
-    install();
+    install().catch(e => { console.error(`Error: ${e.message}`); process.exit(1); });
     break;
   case 'init':
     initId();

package/crypto.js

@@ -29,7 +29,7 @@ export function signMessage(message, secretKey) {
  * Create the canonical signing bytes for an event (excludes sig and embeddings)
  *
  * IMPORTANT: Field order must match bb-core's canonical_signing_bytes exactly:
- * v -> kind -> agent_pubkey -> created_at -> topic -> to -> refs -> tags -> payload -> encryption fields
+ * v -> kind -> agent_pubkey -> created_at -> topic -> to -> refs -> parents -> tags -> payload -> encryption fields
  *
  * @param {Object} event - Event object (without sig)
  * @returns {Uint8Array} - Canonical bytes for signing
@@ -49,7 +49,7 @@ function canonicalSigningBytes(event) {
     signingObj.to = event.to;
   }
 
-  if (event.refs && (event.refs.request_id || event.refs.fulfill_id)) {
+  if (event.refs && (event.refs.request_id || event.refs.fulfill_id || event.refs.parent_aeid)) {
     signingObj.refs = {};
     if (event.refs.request_id) {
       signingObj.refs.request_id = event.refs.request_id;
@@ -57,6 +57,14 @@ function canonicalSigningBytes(event) {
     if (event.refs.fulfill_id) {
       signingObj.refs.fulfill_id = event.refs.fulfill_id;
     }
+    if (event.refs.parent_aeid) {
+      signingObj.refs.parent_aeid = event.refs.parent_aeid;
+    }
+  }
+
+  // Parents for request chaining (must come after refs, before tags)
+  if (event.parents && event.parents.length > 0) {
+    signingObj.parents = event.parents;
   }
 
   // Tags must be sorted by key for deterministic serialization

package/index.js

@@ -28,12 +28,19 @@ import {
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 import * as ed from "@noble/ed25519";
 import bs58 from "bs58";
 import { getOrCreateIdentity, getProxyUrl } from "./identity.js";
 import { signEvent, cleanEvent } from "./crypto.js";
 import { submitToRelay } from "./submit.js";
 
+// Read version from package.json
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CURRENT_VERSION = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf8")).version;
+
 // Validation limits (matching bb-core)
 const MAX_TOPIC_LENGTH = 200;
 const MAX_PAYLOAD_SIZE = 48 * 1024;
@@ -57,6 +64,23 @@ try {
 const proxyUrl = getProxyUrl();
 console.error(`BB Signer: Proxy URL: ${proxyUrl}`);
 
+// Background version check (non-blocking, runs 5s after startup)
+let updateNotice = null;
+setTimeout(async () => {
+  try {
+    const resp = await fetch("https://registry.npmjs.org/bb-signer/latest", {
+      signal: AbortSignal.timeout(5000),
+    });
+    const data = await resp.json();
+    if (data.version && data.version !== CURRENT_VERSION) {
+      updateNotice = `Update available: bb-signer ${CURRENT_VERSION} → ${data.version}. Run: npx bb-signer@latest install`;
+      console.error(`BB Signer: ${updateNotice}`);
+    }
+  } catch {
+    // Silently ignore - version check is best-effort
+  }
+}, 5000);
+
 // --- Helpers ---
 
 function validateTopic(topic) {
@@ -101,10 +125,13 @@ async function buildSignSubmit(kind, topic, payload, opts = {}) {
 }
 
 function ok(data) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(data) }],
-    isError: false,
-  };
+  const content = [{ type: "text", text: JSON.stringify(data) }];
+  // Append update notice to first tool response after detection
+  if (updateNotice) {
+    content.push({ type: "text", text: `\n${updateNotice}` });
+    updateNotice = null; // Show only once per session
+  }
+  return { content, isError: false };
 }
 
 function err(msg) {
@@ -118,7 +145,7 @@ function err(msg) {
 const server = new Server(
   {
     name: "bb_signer",
-    version: "0.2.7",
+    version: CURRENT_VERSION,
   },
   {
     capabilities: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bb-signer",
-  "version": "0.2.8",
+  "version": "0.3.2",
   "description": "Minimal local signer for BB - signs events for the agent collaboration network",
   "type": "module",
   "main": "index.js",
@@ -13,10 +13,12 @@
   "keywords": [
     "mcp",
     "claude",
+    "gemini",
+    "cursor",
+    "windsurf",
     "ai",
     "agents",
     "bb",
-    "anthropic",
     "signer"
   ],
   "repository": {