@saiteja1123/mcp-server 1.1.5 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saiteja1123/mcp-server",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "private": false,
   "license": "MIT",
   "description": "Vibesecur MCP security scanner — universal account config, multi-project CRU, folder locking, cross-IDE",

package/src/cli.js

@@ -18,7 +18,6 @@
 
 import fs from 'fs/promises';
 import path from 'path';
-import os from 'os';
 import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 import {
@@ -30,6 +29,16 @@ import {
   isRuntimeCompatibleLock,
 } from './lock.mjs';
 import { pingBackend, requestServerBind, verifyInstallBinding } from './api-scan.mjs';
+import {
+  DEFAULT_API_BASE,
+  NPM_PACKAGE_NAME,
+  buildLegacyEnv,
+  buildUniversalEnv,
+  formatIdeConfigBlocks,
+  IDE_CONFIG_TARGETS,
+  isUniversalMode,
+  publishedServerCmd,
+} from './mcp-config.mjs';
 import {
   DeepScanRuntime,
   LocalDeepScanStore,
@@ -41,8 +50,7 @@ import {
 
 const require = createRequire(import.meta.url);
 const mcpPkg = require('../package.json');
-const NPM_PACKAGE_NAME = mcpPkg.name || '@saiteja1123/mcp-server';
-const DEFAULT_API_BASE = 'https://vibesecur.onrender.com';
+const NPM_PACKAGE = NPM_PACKAGE_NAME;
 
 const serverPath = fileURLToPath(new URL('./server.js', import.meta.url));
 
@@ -85,17 +93,25 @@ function allowLocalFallback() {
 function serverCmd() {
   const normalizedPath = serverPath.replace(/\\/g, '/');
   if (normalizedPath.includes('/node_modules/')) {
-    return { command: 'npx', args: ['-y', NPM_PACKAGE_NAME, 'start'] };
+    return publishedServerCmd();
   }
   return { command: 'node', args: [serverPath] };
 }
 
 function buildEnv(folder, token, apiBase) {
-  return {
-    VIBESECUR_INSTALL_TOKEN: token,
-    VIBESECUR_BOUND_ROOT: folder,
-    VIBESECUR_API_BASE: apiBase || DEFAULT_API_BASE,
-  };
+  return buildLegacyEnv(folder, token, apiBase);
+}
+
+function printIdeBlocks(sc, env, options = {}) {
+  for (const block of formatIdeConfigBlocks(sc, env, options)) {
+    if (block.title === 'Mode') {
+      console.log(`${DIM}${block.body}${RESET}\n`);
+      continue;
+    }
+    console.log(`${BOLD}-- ${block.title} --${RESET}`);
+    console.log(block.body);
+    console.log();
+  }
 }
 
 function printLocalDiagnosticNotice(folder) {
@@ -137,20 +153,30 @@ async function createServerIssuedLock({ folder, account, authToken, apiBase, act
   return { ok: false, remote };
 }
 
-function printIdeBlocks(sc, env) {
-  console.log(`${BOLD}-- Cursor (~/.cursor/mcp.json) --${RESET}`);
-  console.log(JSON.stringify({ mcpServers: { vibesecur: { command: sc.command, args: sc.args, env } } }, null, 2));
+function printIdeBlocksLegacy(sc, env) {
+  printIdeBlocks(sc, env, { universal: false });
+}
+
+async function runUniversalSetup({ apiBase, authToken, folder, write }) {
+  const sc = serverCmd();
+  const env = buildUniversalEnv(apiBase, authToken);
 
-  console.log(`\n${BOLD}-- VS Code (project .vscode/mcp.json) --${RESET}`);
-  console.log(JSON.stringify({ servers: { vibesecur: { type: 'stdio', command: sc.command, args: sc.args, env } } }, null, 2));
+  console.log(ok('Universal account MCP config (works in Cursor, Windsurf, VS Code, Claude Desktop, Continue)'));
+  console.log(dim('No per-folder bind required. Use projectUpsert in the IDE before scanning a new codebase.\n'));
 
-  console.log(`\n${BOLD}-- Windsurf (~/.codeium/windsurf/mcp_config.json) --${RESET}`);
-  console.log(JSON.stringify({ mcpServers: { vibesecur: { command: sc.command, args: sc.args, env } } }, null, 2));
+  console.log(`${BOLD}Next:${RESET} paste ONE block below into your IDE MCP settings, then reload the IDE.\n`);
+  printIdeBlocks(sc, env, { universal: true });
 
-  console.log(`\n${BOLD}-- Generic env (paste into your MCP client) --${RESET}`);
-  console.log(`command: ${sc.command} ${sc.args.join(' ')}`);
-  Object.entries(env).forEach(([k, v]) => console.log(`  ${k}=${v}`));
-  console.log();
+  if (write) {
+    const w = String(write).toLowerCase();
+    const allowed = ['cursor', 'vscode', 'windsurf', 'claude', 'all'];
+    if (!allowed.includes(w)) {
+      console.log(err(`Invalid --write=${write}. Use: ${allowed.join(' | ')}`));
+      process.exit(1);
+    }
+    await writeIdeConfig(w, sc, env, folder);
+    console.log(dim('Reload your IDE so it picks up the new MCP config.'));
+  }
 }
 
 async function mergeJsonFile(filePath, merger) {
@@ -166,40 +192,34 @@ async function mergeJsonFile(filePath, merger) {
   await fs.writeFile(filePath, JSON.stringify(next, null, 2), 'utf8');
 }
 
-async function writeIdeConfig(which, sc, env) {
-  const entry = { command: sc.command, args: sc.args, env };
-  const vscodeEntry = { type: 'stdio', command: sc.command, args: sc.args, env };
-
-  if (which === 'cursor' || which === 'all') {
-    const file = path.join(os.homedir(), '.cursor', 'mcp.json');
-    await mergeJsonFile(file, (data) => {
-      const out = { ...data };
-      out.mcpServers = { ...(out.mcpServers || {}), vibesecur: entry };
-      return out;
-    });
-    console.log(ok(`Wrote Cursor MCP config: ${file}`));
-  }
-
-  if (which === 'vscode' || which === 'all') {
-    const folder = env.VIBESECUR_BOUND_ROOT;
-    const file = path.join(folder, '.vscode', 'mcp.json');
-    await mergeJsonFile(file, (data) => {
+async function writeIdeConfig(which, sc, env, folder = process.cwd()) {
+  const writeOne = async (id) => {
+    const target = IDE_CONFIG_TARGETS[id];
+    if (!target) return false;
+    if (target.needsFolder && !folder) {
+      console.log(err(`Skipping ${id}: pass a project folder for .vscode/mcp.json`));
+      return false;
+    }
+    const filePath = target.needsFolder ? target.path(folder) : target.path();
+    const built = target.build(sc, env);
+    const entry = built[target.mergeKey][target.entryKey];
+    await mergeJsonFile(filePath, (data) => {
       const out = { ...data };
-      out.servers = { ...(out.servers || {}), vibesecur: vscodeEntry };
+      out[target.mergeKey] = { ...(out[target.mergeKey] || {}), [target.entryKey]: entry };
       return out;
     });
-    console.log(ok(`Wrote VS Code MCP config: ${file}`));
-  }
+    console.log(ok(`Wrote ${target.label}: ${filePath}`));
+    return true;
+  };
 
-  if (which === 'windsurf' || which === 'all') {
-    const file = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
-    await mergeJsonFile(file, (data) => {
-      const out = { ...data };
-      out.mcpServers = { ...(out.mcpServers || {}), vibesecur: entry };
-      return out;
-    });
-    console.log(ok(`Wrote Windsurf MCP config: ${file}`));
+  if (which === 'all') {
+    await writeOne('cursor');
+    await writeOne('windsurf');
+    await writeOne('claude');
+    await writeOne('vscode');
+    return;
   }
+  await writeOne(which);
 }
 
 function createDeepScanRuntime(folder) {
@@ -544,24 +564,38 @@ async function cmdStatus() {
 
 async function cmdConfig() {
   const folder = path.resolve(arg || process.cwd());
-  const lock = await readLock(folder);
-  const token = lock?.installToken || 'YOUR_INSTALL_TOKEN';
   const apiBase = (flags['api-base'] || process.env.VIBESECUR_API_BASE || DEFAULT_API_BASE).trim();
+  const authToken = flags['auth-token'] || process.env.VIBESECUR_AUTH_TOKEN || '';
 
   console.log(`\n${h('Vibesecur MCP - IDE Config Snippets')}`);
+
+  if (isUniversalMode(flags, authToken)) {
+    if (!authToken) {
+      console.log(err('Universal config requires VIBESECUR_AUTH_TOKEN or --auth-token=<jwt>'));
+      process.exit(1);
+    }
+    console.log(`Mode:   ${BOLD}universal (account-wide)${RESET}`);
+    console.log(`API:    ${apiBase}\n`);
+    const sc = serverCmd();
+    printIdeBlocks(sc, buildUniversalEnv(apiBase, authToken), { universal: true });
+    return;
+  }
+
+  console.log(`Mode:   ${BOLD}legacy (single folder)${RESET}`);
   console.log(`Folder: ${folder}`);
-  if (!lock) console.log(err(`No lock found. Run: vibesecur-mcp bind ${folder}`));
+  const lock = await readLock(folder);
+  const token = lock?.installToken || 'YOUR_INSTALL_TOKEN';
+  if (!lock) console.log(err(`No lock found. Run: vibesecur-mcp init ${folder} --mode=legacy`));
   else if (!isRuntimeCompatibleLock(lock)) {
     console.log(err('Existing lock is local diagnostic-only and will not start the MCP runtime.'));
-    console.log(`Run: VIBESECUR_AUTH_TOKEN=<jwt> vibesecur-mcp bind ${folder}`);
+    console.log(`Run: VIBESECUR_AUTH_TOKEN=<jwt> vibesecur-mcp init --mode=universal`);
     console.log();
     return;
   }
   console.log();
 
-  const env = buildEnv(folder, token, apiBase);
   const sc = serverCmd();
-  printIdeBlocks(sc, env);
+  printIdeBlocks(sc, buildEnv(folder, token, apiBase), { universal: false });
 }
 
 async function cmdInit() {
@@ -570,13 +604,23 @@ async function cmdInit() {
   const account = process.env.VIBESECUR_ACCOUNT || 'anonymous';
   const skipBind = flags['skip-bind'] === true || flags['skip-bind'] === 'true';
   const canFallbackLocal = allowLocalFallback();
+  const authToken = flags['auth-token'] || process.env.VIBESECUR_AUTH_TOKEN || '';
+  const write = flags.write;
 
   console.log(`\n${h('Vibesecur MCP - Init')}`);
   console.log(`Project folder: ${folder}`);
   console.log(`API base:       ${apiBase}`);
-  console.log(`Package:        ${NPM_PACKAGE_NAME}\n`);
+  console.log(`Package:        ${NPM_PACKAGE_NAME}@${mcpPkg.version}\n`);
 
-  const authToken = flags['auth-token'] || process.env.VIBESECUR_AUTH_TOKEN || '';
+  if (isUniversalMode(flags, authToken)) {
+    if (!authToken) {
+      console.log(err('Universal init requires VIBESECUR_AUTH_TOKEN or --auth-token=<jwt> from the dashboard login.'));
+      console.log(dim('Example: npx -y @saiteja1123/mcp-server init --auth-token=<jwt> --write=all'));
+      process.exit(1);
+    }
+    await runUniversalSetup({ apiBase, authToken, folder, write });
+    return;
+  }
 
   let lock = await readLock(folder);
   if (lock && !isRuntimeCompatibleLock(lock) && !skipBind) {
@@ -615,16 +659,15 @@ async function cmdInit() {
   const sc = serverCmd();
 
   console.log(`\n${BOLD}Next:${RESET} paste ONE block below into your IDE MCP settings, then reload the IDE.\n`);
-  printIdeBlocks(sc, env);
+  printIdeBlocks(sc, env, { universal: false });
 
-  const write = flags.write;
   if (write) {
     const w = String(write).toLowerCase();
-    if (!['cursor', 'vscode', 'windsurf', 'all'].includes(w)) {
-      console.log(err(`Invalid --write=${write}. Use: cursor | vscode | windsurf | all`));
+    if (!['cursor', 'vscode', 'windsurf', 'claude', 'all'].includes(w)) {
+      console.log(err(`Invalid --write=${write}. Use: cursor | vscode | windsurf | claude | all`));
       process.exit(1);
     }
-    await writeIdeConfig(w, sc, env);
+    await writeIdeConfig(w, sc, env, folder);
     console.log(dim('Reload your IDE so it picks up the new MCP config.'));
   }
 }
@@ -632,28 +675,42 @@ async function cmdInit() {
 async function cmdDoctor() {
   const folder = path.resolve(arg || process.cwd());
   const apiBase = (flags['api-base'] || process.env.VIBESECUR_API_BASE || DEFAULT_API_BASE).trim();
+  const authToken = flags['auth-token'] || process.env.VIBESECUR_AUTH_TOKEN || '';
+  const universal = isUniversalMode(flags, authToken);
 
   console.log(`\n${h('Vibesecur MCP - Doctor')}`);
   console.log(`Folder:   ${folder}`);
-  console.log(`API base: ${apiBase}\n`);
+  console.log(`API base: ${apiBase}`);
+  console.log(`Mode:     ${universal ? 'universal (account-wide)' : 'legacy (single folder)'}\n`);
 
-  const lock = await readLock(folder);
-  if (!lock) {
-    console.log(err('No lock file. Run: vibesecur-mcp init'));
+  if (universal) {
+    if (authToken) {
+      console.log(ok('VIBESECUR_AUTH_TOKEN present (universal mode ready)'));
+    } else {
+      console.log(err('VIBESECUR_AUTH_TOKEN missing — set it in IDE MCP env or pass --auth-token=<jwt>'));
+    }
+    console.log(dim('Per-project locks are optional in universal mode. Use projectUpsert before scanning a codebase.\n'));
   } else {
-    console.log(ok('Lock file present'));
-    const diag = await diagnosticLock(folder);
-    console.log(diag.healthy ? ok('Lock diagnostic: healthy') : err('Lock diagnostic: issues'));
-    console.log(diag.runtimeCompatible ? ok('Runtime binding: server-issued') : err('Runtime binding: not server-issued'));
-    if (diag.issues?.length) diag.issues.forEach((i) => console.log(`  - ${i}`));
+    const lock = await readLock(folder);
+    if (!lock) {
+      console.log(err('No lock file. Run: vibesecur-mcp init --auth-token=<jwt> for universal mode'));
+    } else {
+      console.log(ok('Lock file present'));
+      const diag = await diagnosticLock(folder);
+      console.log(diag.healthy ? ok('Lock diagnostic: healthy') : err('Lock diagnostic: issues'));
+      console.log(diag.runtimeCompatible ? ok('Runtime binding: server-issued') : err('Runtime binding: not server-issued'));
+      if (diag.issues?.length) diag.issues.forEach((i) => console.log(`  - ${i}`));
+    }
   }
 
   const tokenEnv = process.env.VIBESECUR_INSTALL_TOKEN;
   const rootEnv = process.env.VIBESECUR_BOUND_ROOT;
-  console.log(`\n${BOLD}Shell env (optional; IDE sets these when MCP runs):${RESET}`);
-  console.log(`  VIBESECUR_INSTALL_TOKEN: ${tokenEnv ? dim('set') : dim('not set in this shell (normal)')}`);
-  console.log(`  VIBESECUR_BOUND_ROOT:    ${rootEnv ? dim('set') : dim('not set in this shell (normal)')}`);
-  console.log(`  VIBESECUR_API_BASE:      ${process.env.VIBESECUR_API_BASE ? dim(process.env.VIBESECUR_API_BASE) : dim(`${DEFAULT_API_BASE} (default)`)}`);
+  const authEnv = process.env.VIBESECUR_AUTH_TOKEN;
+  console.log(`\n${BOLD}Shell env (IDE injects these when MCP runs):${RESET}`);
+  console.log(`  VIBESECUR_AUTH_TOKEN:      ${authEnv ? dim('set') : dim('not set in this shell')}`);
+  console.log(`  VIBESECUR_INSTALL_TOKEN:   ${tokenEnv ? dim('set') : dim('not set (OK in universal mode)')}`);
+  console.log(`  VIBESECUR_BOUND_ROOT:      ${rootEnv ? dim('set') : dim('not set (OK in universal mode)')}`);
+  console.log(`  VIBESECUR_API_BASE:        ${process.env.VIBESECUR_API_BASE ? dim(process.env.VIBESECUR_API_BASE) : dim(`${DEFAULT_API_BASE} (default)`)}`);
 
   const ping = await pingBackend(apiBase);
   if (ping.skipped) {
@@ -669,18 +726,19 @@ async function cmdDoctor() {
   }
 
   console.log(`\n${BOLD}CLI:${RESET} ${NPM_PACKAGE_NAME}@${mcpPkg.version}`);
-  console.log(dim('If IDE still fails: run init again, paste fresh config, reload IDE.\n'));
+  console.log(dim('Universal setup: npx -y @saiteja1123/mcp-server init --auth-token=<jwt> --write=all --api-base=URL'));
+  console.log(dim('If IDE still fails: reload IDE after pasting config, then run projectUpsert for your codebase.\n'));
 }
 
 function usage() {
   console.log(`\n${h('Vibesecur MCP')}`);
-  console.log(`  ${dim('Quick start:')} vibesecur-mcp init`);
-  console.log('  init [folder]       server-bind + print IDE configs [--api-base=URL] [--auth-token=JWT] [--write=cursor|vscode|windsurf|all] [--skip-bind] [--allow-local-fallback=true]');
-  console.log('  doctor [folder]     check lock + backend [--api-base=URL]');
-  console.log('  bind <folder>       server-issued bind [--api-base=URL] [--auth-token=JWT] [--allow-local-fallback=true]');
-  console.log('  rebind <folder>     rotate token via server [--api-base=URL] [--auth-token=JWT] [--allow-local-fallback=true]');
-  console.log('  status [folder]   lock health');
-  console.log('  config [folder]   print snippets only');
+  console.log(`  ${dim('Quick start (universal):')} VIBESECUR_AUTH_TOKEN=<jwt> npx -y ${NPM_PACKAGE_NAME} init --write=all`);
+  console.log('  init [folder]       print IDE configs [--auth-token=JWT] [--api-base=URL] [--mode=universal|legacy] [--write=cursor|vscode|windsurf|claude|all]');
+  console.log('  doctor [folder]     check env + backend [--auth-token=JWT] [--api-base=URL] [--mode=universal]');
+  console.log('  bind <folder>       legacy single-folder bind [--auth-token=JWT]');
+  console.log('  rebind <folder>     rotate legacy folder token');
+  console.log('  status [folder]   lock health (legacy mode)');
+  console.log('  config [folder]   print IDE snippets [--auth-token=JWT] [--mode=universal]');
   console.log('  deep-scan-start [folder]   create and run local Deep Scan Project Map, deterministic scan, metadata-only test plan, Ralph tasks, and rerun comparison [--demo=true] [--human-approval=true] [--previous-run-id=<runId>] [--previous-scan-uri=<uri> --previous-scan-hash=<sha256>]');
   console.log('  deep-scan-status <runId> [folder]   inspect local Deep Scan status');
   console.log('  deep-scan-approve <runId> [folder]  record approval metadata');

package/src/mcp-config.mjs

@@ -0,0 +1,161 @@
+import os from 'os';
+import path from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const mcpPkg = require('../package.json');
+
+export const NPM_PACKAGE_NAME = mcpPkg.name || '@saiteja1123/mcp-server';
+export const DEFAULT_API_BASE = 'https://vibesecur.onrender.com';
+export const PUBLISHED_SERVER_ARGS = ['-y', `${NPM_PACKAGE_NAME}@${mcpPkg.version}`, 'start'];
+
+/** Stdio MCP launch via pinned npm package (works in every IDE). */
+export function publishedServerCmd() {
+  return { command: 'npx', args: [...PUBLISHED_SERVER_ARGS] };
+}
+
+/** Legacy single-folder install env. */
+export function buildLegacyEnv(folder, installToken, apiBase) {
+  return {
+    VIBESECUR_INSTALL_TOKEN: installToken,
+    VIBESECUR_BOUND_ROOT: folder,
+    VIBESECUR_API_BASE: apiBase || DEFAULT_API_BASE,
+  };
+}
+
+/** Account-wide universal install env — one config for all projects/IDEs. */
+export function buildUniversalEnv(apiBase, authToken = '<paste-auth-token-from-dashboard>') {
+  const env = {
+    VIBESECUR_API_BASE: apiBase || DEFAULT_API_BASE,
+    VIBESECUR_AUTH_TOKEN: authToken,
+  };
+  return env;
+}
+
+export function isUniversalMode(flags = {}, authToken = '') {
+  const mode = String(flags.mode || flags['config-mode'] || '').toLowerCase();
+  if (mode === 'legacy' || mode === 'folder') return false;
+  if (mode === 'universal' || mode === 'account') return true;
+  return !!authToken;
+}
+
+export function buildMcpServerEntry(sc, env) {
+  return { command: sc.command, args: sc.args, env };
+}
+
+export function buildCursorConfig(sc, env) {
+  return { mcpServers: { vibesecur: buildMcpServerEntry(sc, env) } };
+}
+
+export function buildWindsurfConfig(sc, env) {
+  return { mcpServers: { vibesecur: buildMcpServerEntry(sc, env) } };
+}
+
+export function buildClaudeDesktopConfig(sc, env) {
+  return { mcpServers: { vibesecur: buildMcpServerEntry(sc, env) } };
+}
+
+export function buildVsCodeMcpConfig(sc, env) {
+  return {
+    servers: {
+      vibesecur: { type: 'stdio', command: sc.command, args: sc.args, env },
+    },
+  };
+}
+
+export function buildContinueMcpConfig(sc, env) {
+  return {
+    experimental: {
+      modelContextProtocolServers: [
+        {
+          name: 'vibesecur',
+          transport: {
+            type: 'stdio',
+            command: sc.command,
+            args: sc.args,
+            env,
+          },
+        },
+      ],
+    },
+  };
+}
+
+export const IDE_CONFIG_TARGETS = {
+  cursor: {
+    label: 'Cursor (~/.cursor/mcp.json)',
+    path: () => path.join(os.homedir(), '.cursor', 'mcp.json'),
+    build: buildCursorConfig,
+    mergeKey: 'mcpServers',
+    entryKey: 'vibesecur',
+  },
+  windsurf: {
+    label: 'Windsurf (~/.codeium/windsurf/mcp_config.json)',
+    path: () => path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),
+    build: buildWindsurfConfig,
+    mergeKey: 'mcpServers',
+    entryKey: 'vibesecur',
+  },
+  claude: {
+    label: 'Claude Desktop (%APPDATA%/Claude/claude_desktop_config.json)',
+    path: () => path.join(
+      process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+      'Claude',
+      'claude_desktop_config.json',
+    ),
+    build: buildClaudeDesktopConfig,
+    mergeKey: 'mcpServers',
+    entryKey: 'vibesecur',
+  },
+  vscode: {
+    label: 'VS Code (project .vscode/mcp.json)',
+    path: (folder) => path.join(folder, '.vscode', 'mcp.json'),
+    build: buildVsCodeMcpConfig,
+    mergeKey: 'servers',
+    entryKey: 'vibesecur',
+    needsFolder: true,
+  },
+};
+
+export function formatIdeConfigBlocks(sc, env, { universal = false } = {}) {
+  const lines = [];
+  const note = universal
+    ? 'Universal account config — works across projects. Use projectUpsert before scanning a new codebase.'
+    : 'Single-folder legacy config — bound to one project root.';
+
+  lines.push({ title: 'Mode', body: note });
+
+  for (const [id, target] of Object.entries(IDE_CONFIG_TARGETS)) {
+    if (id === 'vscode') {
+      lines.push({
+        id,
+        title: target.label,
+        body: JSON.stringify(target.build(sc, env), null, 2),
+      });
+      continue;
+    }
+    lines.push({
+      id,
+      title: target.label,
+      body: JSON.stringify(target.build(sc, env), null, 2),
+    });
+  }
+
+  lines.push({
+    id: 'continue',
+    title: 'Continue.dev (~/.continue/config.json fragment)',
+    body: JSON.stringify(buildContinueMcpConfig(sc, env), null, 2),
+  });
+
+  lines.push({
+    id: 'generic',
+    title: 'Generic stdio MCP client',
+    body: [
+      `command: ${sc.command}`,
+      `args: ${sc.args.join(' ')}`,
+      ...Object.entries(env).map(([k, v]) => `${k}=${v}`),
+    ].join('\n'),
+  });
+
+  return lines;
+}