@shomra/agent 0.3.16 → 0.3.18

package/src/inventory/discovery/mcp-servers.mjs

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { readJson } from './fs-read.mjs';
+import { redactEnv } from './model-keys.mjs';
+import { APPDATA, HOME, PLAT, vscodeUserDir } from './platform.mjs';
+import { walkWorkspace } from './workspace.mjs';
+
+export function vendorFromPath(file) {
+  if (/[\\/]\.cursor[\\/]/.test(file)) return 'cursor';
+  if (/[\\/]\.vscode[\\/]/.test(file)) return 'vscode';
+  if (/[\\/]\.gemini[\\/]/.test(file)) return 'gemini';
+  if (/[\\/]\.zed[\\/]/.test(file)) return 'zed';
+  return 'project';
+}
+
+function globalMcpCandidates() {
+  const c = [];
+  if (PLAT === 'win32') c.push({ vendor: 'claude', file: path.join(APPDATA, 'Claude', 'claude_desktop_config.json') });
+  else if (PLAT === 'darwin') c.push({ vendor: 'claude', file: path.join(HOME, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json') });
+  else c.push({ vendor: 'claude', file: path.join(HOME, '.config', 'Claude', 'claude_desktop_config.json') });
+  c.push({ vendor: 'cursor', file: path.join(HOME, '.cursor', 'mcp.json') });
+  c.push({ vendor: 'windsurf', file: path.join(HOME, '.codeium', 'windsurf', 'mcp_config.json') });
+  c.push({ vendor: 'continue', file: path.join(HOME, '.continue', 'config.json') });
+  c.push({ vendor: 'claude-code', file: path.join(HOME, '.claude.json') });
+  c.push({ vendor: 'gemini', file: path.join(HOME, '.gemini', 'settings.json') });
+  c.push({ vendor: 'cline', file: path.join(vscodeUserDir(), 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json') });
+  c.push({ vendor: 'roo', file: path.join(vscodeUserDir(), 'globalStorage', 'rooveterinaryinc.roo-cline', 'settings', 'mcp_settings.json') });
+
+  c.push({ vendor: 'vscode', file: path.join(vscodeUserDir(), 'mcp.json') });
+  c.push({ vendor: 'vscode', file: path.join(vscodeUserDir(), 'settings.json') });
+  c.push({ vendor: 'cursor', file: path.join(vscodeUserDir('Cursor'), 'settings.json') });
+  c.push({ vendor: 'zed', file: PLAT === 'darwin' ? path.join(HOME, 'Library', 'Application Support', 'Zed', 'settings.json') : path.join(HOME, '.config', 'zed', 'settings.json') });
+  return c;
+}
+
+function extractServers(json) {
+  if (!json || typeof json !== 'object') return {};
+  return (
+    json.mcpServers ||
+    json.servers ||
+    json['mcp.servers'] ||
+    json.mcp?.servers ||
+    json.context_servers ||
+    {}
+  );
+}
+
+export function discoverMcpServers(roots = [process.cwd()], files = null) {
+  const walk = files || walkWorkspace(roots);
+  const candidates = [
+    ...globalMcpCandidates(),
+    ...walk.mcp.map(({ file }) => ({ vendor: vendorFromPath(file), file })),
+  ];
+  const assets = [];
+  const seen = new Set();
+  for (const { vendor, file } of candidates) {
+    const json = readJson(file);
+    if (!json) continue;
+    const servers = extractServers(json);
+    for (const [name, cfg] of Object.entries(servers)) {
+      if (!cfg || typeof cfg !== 'object') continue;
+      const command = [cfg.command, ...(Array.isArray(cfg.args) ? cfg.args : [])].filter(Boolean).join(' ');
+      const identifier = cfg.url || cfg.serverUrl || command || name;
+      const key = `${name}:${identifier}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      assets.push({
+        type: 'MCP_SERVER',
+        name,
+        identifier,
+        vendor,
+        metadata: { command, url: cfg.url || cfg.serverUrl || null, configFile: file, env: redactEnv(cfg.env) },
+
+        content: JSON.stringify({ command, url: cfg.url || cfg.serverUrl, env: cfg.env || {} }),
+      });
+    }
+  }
+  return assets;
+}

package/src/inventory/discovery/model-keys.mjs

@@ -0,0 +1,97 @@
+import { readText } from './fs-read.mjs';
+import { walkWorkspace } from './workspace.mjs';
+
+const KEY_NAME_VENDOR = {
+  OPENAI_API_KEY: 'openai', AZURE_OPENAI_API_KEY: 'azure-openai', AZURE_OPENAI_KEY: 'azure-openai',
+  ANTHROPIC_API_KEY: 'anthropic', GOOGLE_API_KEY: 'google', GOOGLE_GENAI_API_KEY: 'google',
+  GEMINI_API_KEY: 'google', MISTRAL_API_KEY: 'mistral', GROQ_API_KEY: 'groq', COHERE_API_KEY: 'cohere',
+  HUGGINGFACE_API_KEY: 'huggingface', HUGGINGFACEHUB_API_TOKEN: 'huggingface', HF_TOKEN: 'huggingface',
+  OPENROUTER_API_KEY: 'openrouter', XAI_API_KEY: 'xai', DEEPSEEK_API_KEY: 'deepseek',
+  TOGETHER_API_KEY: 'together', TOGETHERAI_API_KEY: 'together', PERPLEXITY_API_KEY: 'perplexity',
+  REPLICATE_API_TOKEN: 'replicate', FIREWORKS_API_KEY: 'fireworks', DASHSCOPE_API_KEY: 'alibaba',
+  AI21_API_KEY: 'ai21', ANYSCALE_API_KEY: 'anyscale', VOYAGE_API_KEY: 'voyage', NVIDIA_API_KEY: 'nvidia',
+  CEREBRAS_API_KEY: 'cerebras', STABILITY_API_KEY: 'stability', ELEVENLABS_API_KEY: 'elevenlabs',
+  WATSONX_APIKEY: 'ibm', LANGCHAIN_API_KEY: 'langsmith', LANGSMITH_API_KEY: 'langsmith',
+  PINECONE_API_KEY: 'pinecone', WEAVIATE_API_KEY: 'weaviate',
+};
+
+const KEY_VALUE_PATTERNS = [
+  { re: /^sk-ant-[A-Za-z0-9_-]{20,}/, vendor: 'anthropic' },
+  { re: /^sk-or-[A-Za-z0-9_-]{20,}/, vendor: 'openrouter' },
+  { re: /^sk-proj-[A-Za-z0-9_-]{20,}/, vendor: 'openai' },
+  { re: /^sk-[A-Za-z0-9]{32,}/, vendor: 'openai' },
+  { re: /^AIza[0-9A-Za-z_-]{30,}/, vendor: 'google' },
+  { re: /^gsk_[A-Za-z0-9]{20,}/, vendor: 'groq' },
+  { re: /^hf_[A-Za-z0-9]{20,}/, vendor: 'huggingface' },
+  { re: /^xai-[A-Za-z0-9]{20,}/, vendor: 'xai' },
+  { re: /^r8_[A-Za-z0-9]{20,}/, vendor: 'replicate' },
+  { re: /^pplx-[A-Za-z0-9]{20,}/, vendor: 'perplexity' },
+  { re: /^fw_[A-Za-z0-9]{20,}/, vendor: 'fireworks' },
+];
+
+function classifyKey(name, value) {
+  if (KEY_NAME_VENDOR[name]) return KEY_NAME_VENDOR[name];
+  for (const { re, vendor } of KEY_VALUE_PATTERNS) if (re.test(value)) return vendor;
+
+  if (/(_API_KEY|_API_TOKEN|_APIKEY)$/.test(name) && /(LLM|AI|GPT|CLAUDE|MODEL|OPENAI|ANTHROPIC|GEMINI)/.test(name)) return 'unknown';
+  return null;
+}
+
+export function discoverDotenvKeys(roots = [process.cwd()], files = null) {
+  const walk = files || walkWorkspace(roots);
+  const assets = [];
+  const seen = new Set();
+  for (const { file } of walk.env) {
+    const text = readText(file, 100_000);
+    if (text == null) continue;
+    for (const line of text.split(/\r?\n/)) {
+      const m = line.match(/^\s*(?:export\s+)?([A-Z0-9_]+)\s*=\s*(.*)$/);
+      if (!m) continue;
+      const name = m[1];
+      let value = m[2].trim().replace(/^["']|["']$/g, '');
+      if (!value || value.length < 8 || /^\$\{/.test(value) || /(your|xxx|placeholder|changeme|<|example)/i.test(value)) continue;
+      const vendor = classifyKey(name, value);
+      if (!vendor) continue;
+      const key = `${name}:${file}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      assets.push({
+        type: 'MODEL_KEY',
+        name,
+        identifier: `dotenv:${file}:${name}`,
+        vendor,
+        metadata: { source: 'dotenv', file, fingerprint: `${value.slice(0, 3)}…${value.slice(-2)}` },
+
+      });
+    }
+  }
+  return assets;
+}
+
+export function discoverModelKeys() {
+  const assets = [];
+  for (const [name, v] of Object.entries(process.env)) {
+    if (!v || v.length < 8) continue;
+    const vendor = KEY_NAME_VENDOR[name] || (/(_API_KEY|_API_TOKEN|_APIKEY)$/.test(name) ? classifyKey(name, v) : null);
+    if (!vendor) continue;
+    assets.push({
+      type: 'MODEL_KEY',
+      name,
+      identifier: `env:${name}`,
+      vendor,
+      metadata: { source: 'environment', fingerprint: `${v.slice(0, 3)}…${v.slice(-2)}` },
+
+    });
+  }
+  return assets;
+}
+
+export function redactEnv(env) {
+  if (!env || typeof env !== 'object') return {};
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    const s = String(v ?? '');
+    out[k] = s.length > 8 ? `${s.slice(0, 3)}…${s.slice(-2)}` : s;
+  }
+  return out;
+}

package/src/inventory/discovery/platform.mjs

@@ -0,0 +1,16 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export const HOME = os.homedir();
+
+export const APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
+
+export const LOCALAPPDATA = process.env.LOCALAPPDATA || path.join(HOME, 'AppData', 'Local');
+
+export const PLAT = process.platform;
+
+export function vscodeUserDir(variant = 'Code') {
+  if (PLAT === 'win32') return path.join(APPDATA, variant, 'User');
+  if (PLAT === 'darwin') return path.join(HOME, 'Library', 'Application Support', variant, 'User');
+  return path.join(HOME, '.config', variant, 'User');
+}

package/src/inventory/discovery/rules-files.mjs

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { readText } from './fs-read.mjs';
+import { vendorFromPath } from './mcp-servers.mjs';
+import { walkWorkspace } from './workspace.mjs';
+
+export function discoverRulesFiles(roots = [process.cwd()], files = null) {
+  const walk = files || walkWorkspace(roots);
+  const assets = [];
+  const seen = new Set();
+  for (const { file } of walk.rules) {
+    if (seen.has(file)) continue;
+    seen.add(file);
+    const content = readText(file, 50_000);
+    if (content == null) continue;
+    assets.push({
+      type: 'AI_RULES',
+      name: path.basename(file),
+      identifier: file,
+      vendor: vendorFromPath(file) === 'project' ? 'rules' : vendorFromPath(file),
+      metadata: { bytes: content.length, dir: path.dirname(file) },
+      content: content.slice(0, 50_000),
+    });
+  }
+  return assets;
+}

package/src/inventory/discovery/vector-stores.mjs

@@ -0,0 +1,176 @@
+import path from 'node:path';
+import { PY_VECTOR, VECTOR_ENV, vectorLibInfo } from './ai-dependencies.mjs';
+import { readJson, readText } from './fs-read.mjs';
+import { walkWorkspace } from './workspace.mjs';
+
+const MAX_ENV_BYTES = 100_000;
+const MAX_INDEX_FILES = 20;
+const MAX_MANIFESTS = 10;
+const MAX_HOSTS = 5;
+const PLACEHOLDER_VALUE = /(your|xxx|placeholder|changeme|<|example)/i;
+const ENV_ASSIGNMENT = /^\s*(?:export\s+)?([A-Z0-9_]+)\s*=\s*(.*)$/;
+const URL_HOST = /^[a-z]+:\/\/([^/:?#\s]+)/i;
+const BARE_HOST = /^[a-z0-9.-]+\.[a-z]{2,}(:\d+)?$/i;
+
+function unquote(value) {
+  return String(value || '').trim().replace(/^["']|["']$/g, '');
+}
+
+function endpointHost(value) {
+  const raw = unquote(value);
+  if (!raw) return null;
+  const url = raw.match(URL_HOST);
+  if (url) return url[1];
+  return BARE_HOST.test(raw) ? raw.split(':')[0] : null;
+}
+
+function engineFromIndexFiles(names) {
+  if (names.includes('chroma.sqlite3') || names.some((name) => name.startsWith('chroma-'))) return 'chroma';
+  if (names.includes('index.faiss')) return 'faiss';
+  if (names.some((name) => name.endsWith('.lance'))) return 'lancedb';
+  if (names.some((name) => name.endsWith('.usearch'))) return 'usearch';
+  if (names.includes('docstore.json') || names.includes('default__vector_store.json')) return 'llamaindex';
+  return null;
+}
+
+function localIndexAssets(vectorFiles) {
+  const byDirectory = new Map();
+  for (const { file } of vectorFiles) {
+    const directory = path.dirname(file);
+    if (!byDirectory.has(directory)) byDirectory.set(directory, []);
+    byDirectory.get(directory).push(path.basename(file).toLowerCase());
+  }
+
+  const assets = [];
+  for (const [directory, names] of byDirectory) {
+    const engine = engineFromIndexFiles(names);
+    if (!engine) continue;
+    assets.push({
+      type: 'VECTOR_STORE',
+      name: `${engine} index (${path.basename(directory)})`,
+      identifier: `vector:local:${directory}`,
+      vendor: engine,
+      metadata: {
+        surface: 'local-index',
+        engine,
+        hosted: false,
+        pickleBacked: engine === 'faiss' && names.includes('index.pkl'),
+        dir: directory,
+        files: names.slice(0, MAX_INDEX_FILES),
+      },
+    });
+  }
+  return assets;
+}
+
+function npmVectorLibraries(file) {
+  const json = readJson(file);
+  if (!json) return [];
+  const dependencies = {
+    ...(json.dependencies || {}),
+    ...(json.devDependencies || {}),
+    ...(json.peerDependencies || {}),
+    ...(json.optionalDependencies || {}),
+  };
+  return Object.keys(dependencies).map(vectorLibInfo).filter(Boolean);
+}
+
+function pythonVectorLibraries(file) {
+  const text = readText(file, MAX_ENV_BYTES);
+  if (text == null) return [];
+  return PY_VECTOR
+    .filter((pkg) => {
+      const escaped = pkg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      return new RegExp(`(^|[^a-z0-9_.-])${escaped}([^a-z0-9_.-]|$)`, 'im').test(text);
+    })
+    .map(vectorLibInfo)
+    .filter(Boolean);
+}
+
+function clientLibraryAssets(manifestFiles) {
+  const byEngine = new Map();
+  for (const { file } of manifestFiles) {
+    const libraries = path.basename(file) === 'package.json'
+      ? npmVectorLibraries(file)
+      : pythonVectorLibraries(file);
+    for (const { engine, hosted } of libraries) {
+      if (!byEngine.has(engine)) byEngine.set(engine, { hosted, manifests: new Set() });
+      byEngine.get(engine).manifests.add(file);
+    }
+  }
+
+  return [...byEngine].map(([engine, { hosted, manifests }]) => {
+    const list = [...manifests];
+    return {
+      type: 'VECTOR_STORE',
+      name: `${engine} client`,
+      identifier: `vector:client:${engine}`,
+      vendor: engine,
+      metadata: {
+        surface: 'client-lib',
+        engine,
+        hosted,
+        usedInProjects: list.length,
+        manifests: list.slice(0, MAX_MANIFESTS),
+      },
+    };
+  });
+}
+
+function collectCloudSettings(envFiles) {
+  const byEngine = new Map();
+  for (const { file } of envFiles) {
+    const text = readText(file, MAX_ENV_BYTES);
+    if (text == null) continue;
+
+    for (const line of text.split(/\r?\n/)) {
+      const assignment = line.match(ENV_ASSIGNMENT);
+      if (!assignment) continue;
+      const setting = VECTOR_ENV[assignment[1]];
+      if (!setting) continue;
+
+      const value = unquote(assignment[2]);
+      if (!value || PLACEHOLDER_VALUE.test(value)) continue;
+
+      if (!byEngine.has(setting.engine)) {
+        byEngine.set(setting.engine, { hosts: new Set(), hasKey: false, hasEndpoint: false, files: new Set() });
+      }
+      const entry = byEngine.get(setting.engine);
+      entry.files.add(file);
+      if (setting.kind === 'key') {
+        entry.hasKey = true;
+      } else {
+        entry.hasEndpoint = true;
+        const host = endpointHost(value);
+        if (host) entry.hosts.add(host);
+      }
+    }
+  }
+  return byEngine;
+}
+
+function cloudEndpointAssets(envFiles) {
+  return [...collectCloudSettings(envFiles)].map(([engine, entry]) => ({
+    type: 'VECTOR_STORE',
+    name: `${engine} (cloud)`,
+    identifier: `vector:cloud:${engine}`,
+    vendor: engine,
+    metadata: {
+      surface: 'cloud-endpoint',
+      engine,
+      hosted: true,
+      hasApiKey: entry.hasKey,
+      hosts: [...entry.hosts].slice(0, MAX_HOSTS),
+      files: [...entry.files].slice(0, MAX_MANIFESTS),
+    },
+  }));
+}
+
+export function discoverVectorStores(roots = [process.cwd()], files = null) {
+  const walk = files || walkWorkspace(roots);
+  return [
+    ...localIndexAssets(walk.vector),
+    ...clientLibraryAssets(walk.manifests),
+    ...cloudEndpointAssets(walk.env),
+  ];
+}

package/src/inventory/discovery/workspace.mjs

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isAiUsageScannable } from '../../detect/ai-usage.mjs';
+import { exists } from './fs-read.mjs';
+import { HOME } from './platform.mjs';
+
+const IGNORE_DIRS = new Set([
+  'node_modules', '.git', '.hg', '.svn', 'dist', 'build', 'out', '.next', '.nuxt',
+  '.cache', '.venv', 'venv', 'env', '__pycache__', '.tox', 'target', 'vendor',
+  'bin', 'obj', '.gradle', '.idea', 'coverage', '.pytest_cache', '.mypy_cache',
+  'Pods', '.terraform', '.expo', 'tmp', 'temp', '.turbo', '.parcel-cache',
+  '.svelte-kit', 'bower_components', '.pnpm-store', 'site-packages', '.yarn',
+]);
+
+function workspaceParents() {
+  const names = [
+    'Desktop', 'Documents', 'source', 'source/repos', 'repos', 'Repos',
+    'projects', 'Projects', 'dev', 'Dev', 'Developer', 'git', 'Git', 'code',
+    'Code', 'workspace', 'Workspace', 'work', 'src', 'go/src', 'ghq',
+    'OneDrive/Desktop', 'OneDrive/Documents',
+  ];
+  return names.map((n) => path.join(HOME, n)).filter(exists);
+}
+
+export function resolveRoots(roots, autoExpand) {
+  const out = new Set();
+  for (const r of roots || []) if (r) out.add(path.resolve(r));
+  if (autoExpand) {
+    out.add(HOME);
+    for (const parent of workspaceParents()) {
+      out.add(parent);
+      try {
+        for (const e of fs.readdirSync(parent, { withFileTypes: true })) {
+          if (e.isDirectory() && !e.name.startsWith('.') && !IGNORE_DIRS.has(e.name)) {
+            out.add(path.join(parent, e.name));
+          }
+        }
+      } catch {
+
+      }
+    }
+  }
+  return [...out].slice(0, 500);
+}
+
+const RULE_NAMES = new Set([
+  '.cursorrules', '.windsurfrules', '.clinerules', '.roorules', '.aider.conf.yml',
+  '.aider.conf.yaml', 'AGENTS.md', 'CLAUDE.md', 'GEMINI.md', 'copilot-instructions.md',
+]);
+
+const MANIFEST_NAMES = new Set([
+  'package.json', 'requirements.txt', 'requirements-dev.txt', 'pyproject.toml',
+  'Pipfile', 'environment.yml', 'environment.yaml',
+]);
+
+const isEnvFile = (base) =>
+  /^\.env(\..+)?$/.test(base) && !/(example|sample|template|dist)/i.test(base);
+
+const VECTOR_INDEX_BASENAMES = new Set([
+  'chroma.sqlite3',
+  'index.faiss', 'index.pkl',
+  'docstore.json', 'default__vector_store.json',
+  'chroma-embeddings.parquet', 'chroma-collections.parquet',
+]);
+
+const VECTOR_INDEX_EXTS = new Set(['faiss', 'lance', 'usearch']);
+
+const isVectorIndex = (base) =>
+  VECTOR_INDEX_BASENAMES.has(base.toLowerCase()) ||
+  VECTOR_INDEX_EXTS.has((base.slice(base.lastIndexOf('.') + 1) || '').toLowerCase());
+
+const MAX_SOURCE_FILES = 600;
+
+export function walkWorkspace(roots) {
+  const found = { mcp: [], rules: [], manifests: [], env: [], vector: [], source: [] };
+  const seenDir = new Set();
+  let budget = 40_000;
+  const maxDepth = 6;
+
+  const consider = (base, full, parentBase) => {
+    if (base === '.mcp.json' || base === 'mcp.json') found.mcp.push({ file: full, parentBase });
+    else if (base === 'settings.json' && (parentBase === '.gemini' || parentBase === '.zed'))
+      found.mcp.push({ file: full, parentBase });
+    else if (RULE_NAMES.has(base)) {
+      if (base === 'copilot-instructions.md' && parentBase !== '.github') return;
+      found.rules.push({ file: full, parentBase });
+    } else if (MANIFEST_NAMES.has(base)) found.manifests.push({ file: full, parentBase });
+    else if (isEnvFile(base)) found.env.push({ file: full, parentBase });
+    else if (isVectorIndex(base)) found.vector.push({ file: full, parentBase });
+
+    else if (found.source.length < MAX_SOURCE_FILES && isAiUsageScannable(base)) found.source.push({ file: full, parentBase });
+  };
+
+  for (const root of roots) {
+    const queue = [{ dir: root, depth: 0 }];
+    while (queue.length && budget > 0) {
+      const { dir, depth } = queue.shift();
+      let real;
+      try {
+        real = fs.realpathSync(dir);
+      } catch {
+        continue;
+      }
+      if (seenDir.has(real)) continue;
+      seenDir.add(real);
+      budget--;
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+          if (depth < maxDepth && !IGNORE_DIRS.has(e.name)) queue.push({ dir: full, depth: depth + 1 });
+        } else if (e.isFile()) {
+          consider(e.name, full, path.basename(dir));
+        }
+      }
+    }
+  }
+  return found;
+}

package/src/inventory/discovery.mjs

@@ -0,0 +1,10 @@
+export { discoverAiDependencies, discoverAiUsageInCode } from './discovery/ai-dependencies.mjs';
+export { discoverAiTools } from './discovery/ai-tools.mjs';
+export { discoverAll } from './discovery/all.mjs';
+export { discoverCodingAgents } from './discovery/coding-agents.mjs';
+export { discoverLocalRuntimes } from './discovery/local-runtimes.mjs';
+export { discoverMcpClients } from './discovery/mcp-clients.mjs';
+export { discoverMcpServers } from './discovery/mcp-servers.mjs';
+export { discoverDotenvKeys, discoverModelKeys } from './discovery/model-keys.mjs';
+export { discoverRulesFiles } from './discovery/rules-files.mjs';
+export { discoverVectorStores } from './discovery/vector-stores.mjs';

package/src/mcp/child-process.mjs

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const CHILD_STDIO = ['pipe', 'pipe', 'inherit'];
+const UNQUOTABLE_FOR_CMD = /[%!]/;
+const CMD_WRAPPER = /\.(cmd|bat)$/i;
+
+function quoteForCmd(argument) {
+  return `"${String(argument).replace(/"/g, '""')}"`;
+}
+
+function resolveWindowsExecutable(command) {
+  if (command.includes('\\') || command.includes('/')) return fs.existsSync(command) ? command : null;
+  const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
+  for (const directory of (process.env.PATH || '').split(path.delimiter).filter(Boolean)) {
+    for (const extension of ['', ...extensions]) {
+      const candidate = path.join(directory, command + extension);
+      try {
+        if (fs.statSync(candidate).isFile()) return candidate;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+
+function spawnThroughCmd(executable, args) {
+  const hostile = [executable, ...args].find((argument) => UNQUOTABLE_FOR_CMD.test(String(argument)));
+  if (hostile) {
+    throw new Error(
+      `the launch line contains a character that cannot be safely quoted for cmd.exe (${hostile}). `
+      + 'Point the server at its executable directly instead of a .cmd wrapper.',
+    );
+  }
+  const shell = process.env.ComSpec || 'cmd.exe';
+  const line = [executable, ...args].map(quoteForCmd).join(' ');
+  return spawn(shell, ['/d', '/s', '/c', `"${line}"`], { stdio: CHILD_STDIO, windowsVerbatimArguments: true });
+}
+
+export function spawnGuardedServer(command, args) {
+  if (process.platform !== 'win32') return spawn(command, args, { stdio: CHILD_STDIO });
+
+  const executable = resolveWindowsExecutable(command);
+  if (!executable || !CMD_WRAPPER.test(executable)) {
+    return spawn(executable || command, args, { stdio: CHILD_STDIO });
+  }
+  return spawnThroughCmd(executable, args);
+}

package/src/mcp/config-wrapping.mjs

@@ -0,0 +1,75 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function serversOf(config) {
+  const servers = config?.mcpServers || config?.servers;
+  return servers && typeof servers === 'object' ? servers : null;
+}
+
+function isShimmed(entry, selfPath) {
+  const args = entry.args ?? [];
+  return args.includes('mcp-guard') && args.some((argument) => String(argument) === selfPath);
+}
+
+function skipReason(entry) {
+  if (!entry.command) return entry.url ? 'http - mediated by the gateway' : 'no launch command';
+  return null;
+}
+
+export function wrapMcpConfig(config, selfPath, execPath) {
+  const servers = serversOf(config);
+  if (!servers) return { wrapped: [], skipped: [] };
+
+  const wrapped = [];
+  const skipped = [];
+  for (const [name, entry] of Object.entries(servers)) {
+    if (!entry || typeof entry !== 'object') continue;
+    const reason = skipReason(entry);
+    if (reason) {
+      skipped.push({ name, why: reason });
+      continue;
+    }
+    if (isShimmed(entry, selfPath)) {
+      skipped.push({ name, why: 'already guarded' });
+      continue;
+    }
+    servers[name] = {
+      ...entry,
+      command: execPath,
+      args: [selfPath, 'mcp-guard', '--name', name, '--', entry.command, ...(entry.args ?? [])],
+    };
+    wrapped.push(name);
+  }
+  return { wrapped, skipped };
+}
+
+export function unwrapMcpConfig(config, selfPath) {
+  const servers = serversOf(config);
+  if (!servers) return { restored: [] };
+
+  const restored = [];
+  for (const [name, entry] of Object.entries(servers)) {
+    if (!entry || typeof entry !== 'object' || !isShimmed(entry, selfPath)) continue;
+    const args = entry.args ?? [];
+    const separator = args.indexOf('--');
+    if (separator === -1 || !args[separator + 1]) continue;
+    servers[name] = { ...entry, command: args[separator + 1], args: args.slice(separator + 2) };
+    if (!servers[name].args.length) delete servers[name].args;
+    restored.push(name);
+  }
+  return { restored };
+}
+
+export function mcpConfigCandidates() {
+  const home = os.homedir();
+  const cwd = process.cwd();
+  return [
+    { label: 'Claude Code (project)', file: path.join(cwd, '.mcp.json') },
+    { label: 'Claude Code (global)', file: path.join(home, '.claude.json') },
+    { label: 'Cursor (project)', file: path.join(cwd, '.cursor', 'mcp.json') },
+    { label: 'Cursor (global)', file: path.join(home, '.cursor', 'mcp.json') },
+    { label: 'Windsurf', file: path.join(home, '.codeium', 'windsurf', 'mcp_config.json') },
+    { label: 'Gemini CLI', file: path.join(home, '.gemini', 'settings.json') },
+  ].filter((candidate) => fs.existsSync(candidate.file));
+}