@saiteja1123/mcp-server 1.1.2

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@saiteja1123/mcp-server",
+  "version": "1.1.2",
+  "private": false,
+  "description": "Vibesecur MCP security scanner - one-folder locking, cross-IDE, Cursor/VSCode/Windsurf",
+  "type": "module",
+  "main": "./src/index.js",
+  "bin": {
+    "vibesecur-mcp": "./src/cli.js"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node ./src/server.js",
+    "dev": "node --watch ./src/server.js",
+    "bind": "node ./src/cli.js bind",
+    "test": "node --input-type=module --eval \"import('./src/server.js')\""
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./server": "./src/server.js",
+    "./lock": "./src/lock.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "fast-glob": "^3.3.3",
+    "zod": "^4.3.6"
+  },
+  "bundledDependencies": [],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "security",
+    "vibesecur",
+    "cursor",
+    "windsurf",
+    "scanner",
+    "supabase-rls"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vibesecur/vibesecur"
+  },
+  "homepage": "https://vibesecur.com/docs/mcp-setup"
+}

package/src/api-scan.mjs

@@ -0,0 +1,58 @@
+import crypto from 'crypto';
+import path from 'path';
+
+function sha256Hex(input) {
+  return crypto.createHash('sha256').update(input, 'utf8').digest('hex');
+}
+
+export function getMcpSessionId() {
+  const fromEnv = process.env.VIBESECUR_SESSION_ID;
+  if (typeof fromEnv === 'string' && fromEnv.trim().length > 0) {
+    return fromEnv.trim().slice(0, 64);
+  }
+  const basis = `mcp:${process.env.USER || process.env.USERNAME || 'anon'}:${process.cwd()}`;
+  return sha256Hex(basis);
+}
+
+export function getProjectHashForPath(rootPath) {
+  const resolved = path.resolve(rootPath || '.');
+  return sha256Hex(`vibesecur:mcp:${resolved}`);
+}
+
+function normalizeApiBase(raw) {
+  if (!raw || typeof raw !== 'string') return '';
+  const u = raw.trim().replace(/\/$/, '');
+  return u.endsWith('/api/v1') ? u : `${u}/api/v1`;
+}
+
+export async function postRemoteLocalScan({
+  code,
+  lang = 'auto',
+  projectRoot = '.',
+  platform = 'mcp',
+  token,
+} = {}) {
+  const apiBase = normalizeApiBase(process.env.VIBESECUR_API_BASE || process.env.VIBESECUR_API_URL || '');
+  if (!apiBase) {
+    return { skipped: true, reason: 'VIBESECUR_API_BASE not set' };
+  }
+
+  const projectHash = getProjectHashForPath(projectRoot);
+  const headers = {
+    'Content-Type': 'application/json',
+    'x-session-id': getMcpSessionId(),
+  };
+  const bearer = token || process.env.VIBESECUR_AUTH_TOKEN || process.env.VIBESECUR_TOKEN;
+  if (bearer) {
+    headers.Authorization = bearer.startsWith('Bearer ') ? bearer : `Bearer ${bearer}`;
+  }
+
+  const res = await fetch(`${apiBase}/scan/local`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ code, lang, platform, projectHash }),
+  });
+
+  const json = await res.json().catch(() => ({}));
+  return { apiBase, status: res.status, ok: res.ok, json };
+}

package/src/cli.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * vibesecur-mcp CLI
+ * Usage:
+ *   vibesecur-mcp bind <folder>
+ *   vibesecur-mcp rebind <folder>
+ *   vibesecur-mcp status [folder]
+ *   vibesecur-mcp config <folder>
+ *   vibesecur-mcp start
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createLock, rebindLock, diagnosticLock, readLock } from './lock.mjs';
+
+const [, , command, arg] = process.argv;
+
+const BOLD = '\x1b[1m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+function h(t) { return `${BOLD}${CYAN}${t}${RESET}`; }
+function ok(t) { return `${GREEN}✓ ${t}${RESET}`; }
+function err(t) { return `${RED}✗ ${t}${RESET}`; }
+function dim(t) { return `${DIM}${t}${RESET}`; }
+
+const serverPath = fileURLToPath(new URL('./server.js', import.meta.url));
+
+function serverCmd() {
+  if (serverPath.includes('node_modules')) {
+    return { command: 'npx', args: ['-y', '@vibesecur/mcp-server', 'start'] };
+  }
+  return { command: 'node', args: [serverPath] };
+}
+
+async function cmdBind() {
+  const folder = path.resolve(arg || process.cwd());
+  const account = process.env.VIBESECUR_ACCOUNT || 'anonymous';
+  console.log(`\n${h('Vibesecur MCP - Bind Install')}`);
+  console.log(`Folder : ${folder}`);
+  console.log(`Account: ${account}\n`);
+  const lock = await createLock({ rootPath: folder, account });
+  console.log(ok(`Lock created: ${folder}/.vibesecur/lock.json`));
+  console.log(`\n${BOLD}Install token (keep private):${RESET}`);
+  console.log(`  ${lock.installToken}\n`);
+  console.log('Add to MCP config env:');
+  console.log(`  VIBESECUR_INSTALL_TOKEN=${lock.installToken}`);
+  console.log(`  VIBESECUR_BOUND_ROOT=${folder}`);
+  console.log(`\n${dim(`Run: vibesecur-mcp config ${folder} for IDE snippets`)}\n`);
+}
+
+async function cmdRebind() {
+  const folder = path.resolve(arg || process.cwd());
+  const account = process.env.VIBESECUR_ACCOUNT || 'anonymous';
+  console.log(`\n${h('Vibesecur MCP - Rebind Install')}`);
+  console.log(`Folder : ${folder}\n`);
+  const result = await rebindLock({ rootPath: folder, account });
+  console.log(ok('Rebind complete. Previous token is now invalid.'));
+  console.log(`Previous: ${dim(result.previousToken || 'none')}`);
+  console.log(`\n${BOLD}New install token:${RESET}`);
+  console.log(`  ${result.newToken}\n`);
+  console.log('Update MCP config env:');
+  console.log(`  VIBESECUR_INSTALL_TOKEN=${result.newToken}`);
+  console.log(`  VIBESECUR_BOUND_ROOT=${result.boundRoot}\n`);
+}
+
+async function cmdStatus() {
+  const folder = path.resolve(arg || process.cwd());
+  console.log(`\n${h('Vibesecur MCP - Lock Diagnostic')}`);
+  const diag = await diagnosticLock(folder);
+  console.log(diag.healthy ? ok('Lock healthy') : err('Lock has issues'));
+  console.log(`Bound root  : ${diag.boundRoot || 'unknown'}`);
+  console.log(`Account     : ${diag.account || 'unknown'}`);
+  console.log(`Created     : ${diag.createdAt || 'unknown'}`);
+  console.log(`RootHash OK : ${diag.rootHash?.ok ? `${GREEN}yes${RESET}` : `${RED}NO${RESET}`}`);
+  console.log(`In scope    : ${diag.pathInBoundFolder ? `${GREEN}yes${RESET}` : `${RED}NO${RESET}`}`);
+  if (diag.issues?.length) {
+    console.log(`\n${RED}Issues:${RESET}`);
+    diag.issues.forEach((i) => console.log(`  - ${i}`));
+    console.log(`\nFix: vibesecur-mcp rebind ${diag.boundRoot || folder}`);
+  }
+  console.log();
+}
+
+async function cmdConfig() {
+  const folder = path.resolve(arg || process.cwd());
+  const lock = await readLock(folder);
+  const token = lock?.installToken || 'YOUR_INSTALL_TOKEN';
+
+  console.log(`\n${h('Vibesecur MCP - IDE Config Snippets')}`);
+  console.log(`Folder: ${folder}`);
+  if (!lock) console.log(err(`No lock found. Run: vibesecur-mcp bind ${folder}`));
+  console.log();
+
+  const env = {
+    VIBESECUR_INSTALL_TOKEN: token,
+    VIBESECUR_BOUND_ROOT: folder,
+    VIBESECUR_API_BASE: 'https://api.vibesecur.com',
+  };
+  const sc = serverCmd();
+
+  console.log(`${BOLD}-- Cursor (.cursor/mcp.json) --${RESET}`);
+  console.log(JSON.stringify({ mcpServers: { vibesecur: { command: sc.command, args: sc.args, env } } }, null, 2));
+
+  console.log(`\n${BOLD}-- VS Code (.vscode/mcp.json) --${RESET}`);
+  console.log(JSON.stringify({ servers: { vibesecur: { type: 'stdio', command: sc.command, args: sc.args, env } } }, null, 2));
+
+  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(`\n${BOLD}-- Generic / Claude Desktop / Continue.dev --${RESET}`);
+  console.log(`command: ${sc.command} ${sc.args.join(' ')}`);
+  Object.entries(env).forEach(([k, v]) => console.log(`  ${k}=${v}`));
+  console.log();
+}
+
+function usage() {
+  console.log(`\n${h('Vibesecur MCP')}`);
+  console.log('  bind <folder>    bind install to a project folder');
+  console.log('  rebind <folder>  revoke old token, issue new lock');
+  console.log('  status [folder]  check lock health');
+  console.log('  config <folder>  print IDE config snippets');
+  console.log('  start            start MCP server (stdio)\n');
+  process.exit(1);
+}
+
+try {
+  switch (command) {
+    case 'bind': await cmdBind(); break;
+    case 'rebind': await cmdRebind(); break;
+    case 'status': await cmdStatus(); break;
+    case 'config': await cmdConfig(); break;
+    case 'start':
+    case undefined: await import('./server.js'); break;
+    default: usage();
+  }
+} catch (e) {
+  console.error(`\x1b[31m✗ ${e.message}\x1b[0m`);
+  process.exit(1);
+}

package/src/index.js

@@ -0,0 +1,6 @@
+/**
+ * Re-exports the Vibesecur rule engine for MCP servers, Cursor hooks, or other tooling.
+ * Implement MCP protocol handlers in a separate file that imports from here or from
+ * `@vibesecur/rule-engine` directly.
+ */
+export * from '@vibesecur/rule-engine';

package/src/lock.mjs

@@ -0,0 +1,175 @@
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import os from 'os';
+
+export function sha256Hex(input) {
+  return crypto.createHash('sha256').update(String(input), 'utf8').digest('hex');
+}
+
+export function randomToken() {
+  return crypto.randomBytes(32).toString('hex');
+}
+
+export function deriveLockDir(rootPath) {
+  return path.join(path.resolve(rootPath), '.vibesecur');
+}
+
+export function deriveLockFile(rootPath) {
+  return path.join(deriveLockDir(rootPath), 'lock.json');
+}
+
+export async function readLock(rootPath) {
+  try {
+    const raw = await fs.readFile(deriveLockFile(rootPath), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function writeLock(rootPath, lockData) {
+  const dir = deriveLockDir(rootPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(deriveLockFile(rootPath), JSON.stringify(lockData, null, 2), 'utf8');
+}
+
+export async function createLock({ rootPath, account }) {
+  const resolved = path.resolve(rootPath);
+  const rootHash = sha256Hex(`vibesecur:lock:${resolved}`);
+  const installToken = randomToken();
+  const lock = {
+    installToken,
+    rootHash,
+    boundRoot: resolved,
+    createdAt: new Date().toISOString(),
+    account: account || 'anonymous',
+    version: 1,
+  };
+  await writeLock(resolved, lock);
+  return lock;
+}
+
+export async function validateScanPath(requestedPath, installToken) {
+  const resolved = path.resolve(requestedPath);
+  const lock = await findLockForPath(resolved);
+
+  if (!lock) {
+    return {
+      ok: false,
+      code: 'LOCK_NOT_FOUND',
+      httpStatus: 403,
+      message:
+        'No Vibesecur lock found for this install. ' +
+        'Run "vibesecur-mcp bind <folder>" to bind this install to a project folder.',
+      rebindHint: `vibesecur-mcp bind ${resolved}`,
+    };
+  }
+
+  if (installToken && lock.installToken !== installToken) {
+    return {
+      ok: false,
+      code: 'TOKEN_MISMATCH',
+      message:
+        'Install token does not match the lock for this folder. ' +
+        'Run "vibesecur-mcp rebind" to get a new token.',
+      rebindHint: `vibesecur-mcp rebind ${lock.boundRoot}`,
+    };
+  }
+
+  const boundRoot = path.resolve(lock.boundRoot);
+  if (!resolved.startsWith(boundRoot + path.sep) && resolved !== boundRoot) {
+    return {
+      ok: false,
+      code: 'OUT_OF_FOLDER',
+      httpStatus: 403,
+      message:
+        `Path "${resolved}" is outside the locked project folder "${boundRoot}". ` +
+        'Vibesecur MCP is bound to one folder per install. ' +
+        'To scan a different folder, run "vibesecur-mcp rebind <new-folder>".',
+      rebindHint: `vibesecur-mcp rebind ${resolved}`,
+    };
+  }
+
+  const expectedHash = sha256Hex(`vibesecur:lock:${boundRoot}`);
+  if (lock.rootHash !== expectedHash) {
+    return {
+      ok: false,
+      code: 'HASH_MISMATCH',
+      message: 'Lock rootHash does not match bound folder. The lock file may be corrupted. Rebind.',
+      rebindHint: `vibesecur-mcp rebind ${boundRoot}`,
+    };
+  }
+
+  return { ok: true, lock, boundRoot };
+}
+
+export async function findLockForPath(startPath) {
+  let current = path.resolve(startPath);
+  const homeDir = os.homedir();
+  const fsRoot = path.parse(current).root;
+
+  for (let i = 0; i < 20; i += 1) {
+    const lockFile = deriveLockFile(current);
+    try {
+      const raw = await fs.readFile(lockFile, 'utf8');
+      const lock = JSON.parse(raw);
+      if (lock.installToken && lock.rootHash && lock.boundRoot) {
+        return lock;
+      }
+    } catch {
+      // keep walking up
+    }
+    const parent = path.dirname(current);
+    if (parent === current || parent === homeDir || parent === fsRoot) break;
+    current = parent;
+  }
+  return null;
+}
+
+export async function rebindLock({ rootPath, account }) {
+  const resolved = path.resolve(rootPath);
+  const oldLock = await readLock(resolved);
+  const newLock = await createLock({ rootPath: resolved, account });
+
+  return {
+    previousToken: oldLock?.installToken || null,
+    newToken: newLock.installToken,
+    boundRoot: newLock.boundRoot,
+    rootHash: newLock.rootHash,
+    message: 'Lock rebound. Previous token is now invalid. Copy your new install token.',
+  };
+}
+
+export async function diagnosticLock(rootPath) {
+  const resolved = path.resolve(rootPath || process.cwd());
+  const lock = await findLockForPath(resolved);
+
+  if (!lock) {
+    return {
+      healthy: false,
+      issue: 'LOCK_NOT_FOUND',
+      message: 'No lock file found. Run vibesecur-mcp bind <folder> to initialize.',
+      resolved,
+    };
+  }
+
+  const expectedHash = sha256Hex(`vibesecur:lock:${path.resolve(lock.boundRoot)}`);
+  const hashOk = lock.rootHash === expectedHash;
+  const boundRoot = path.resolve(lock.boundRoot);
+  const inFolder = resolved.startsWith(boundRoot + path.sep) || resolved === boundRoot;
+
+  return {
+    healthy: hashOk && inFolder,
+    lockFile: deriveLockFile(lock.boundRoot),
+    boundRoot: lock.boundRoot,
+    account: lock.account,
+    createdAt: lock.createdAt,
+    rootHash: { expected: expectedHash, stored: lock.rootHash, ok: hashOk },
+    pathInBoundFolder: inFolder,
+    issues: [
+      !hashOk ? 'rootHash mismatch - lock may be corrupted' : null,
+      !inFolder ? `requested path ${resolved} is outside bound folder ${boundRoot}` : null,
+    ].filter(Boolean),
+  };
+}

package/src/repo-scan.mjs

@@ -0,0 +1,200 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import fg from 'fast-glob';
+import { CHECKLIST, localScan } from './rule-engine/index.js';
+
+export const DEFAULT_INCLUDE = [
+  '**/*.{js,jsx,ts,tsx,mjs,cjs,py,json,go,java,kt,kts,rb,php,cs,rs,swift,scala,sh,bash,zsh,yml,yaml,toml,ini,env,sql}',
+];
+export const DEFAULT_EXCLUDE = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/.next/**',
+  '**/.venv/**',
+  '**/venv/**',
+  '**/.cursor/**',
+  '**/AppData/**',
+  '**/Application Data/**',
+  '**/$RECYCLE.BIN/**',
+  '**/System Volume Information/**',
+];
+
+export function inferLang(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.py') return 'py';
+  if (ext === '.json') return 'json';
+  if (ext === '.ts' || ext === '.tsx') return 'ts';
+  return 'js';
+}
+
+export function normalizeRootPath(rootPath) {
+  const raw = (rootPath || process.cwd()).trim();
+  if (!raw || raw.includes('your-other-repo')) {
+    return process.cwd();
+  }
+  if (raw.startsWith('~')) {
+    return path.resolve(process.env.USERPROFILE || process.env.HOME || '', raw.slice(1));
+  }
+  return path.resolve(raw);
+}
+
+export function isUnsafeWorkspaceRoot(candidatePath) {
+  const normalized = candidatePath.replace(/\//g, '\\').toLowerCase();
+  return (
+    normalized.includes('\\application data') ||
+    normalized.includes('\\appdata\\') ||
+    normalized.includes('\\windows\\') ||
+    normalized.includes('\\program files')
+  );
+}
+
+export function isHomePath(candidatePath) {
+  const home = path.resolve(os.homedir()).toLowerCase();
+  const resolved = path.resolve(candidatePath).toLowerCase();
+  return resolved === home;
+}
+
+export function detectWorkspacePath() {
+  const candidates = [
+    process.env.CURSOR_WORKSPACE_PATH,
+    process.env.CURSOR_PROJECT_PATH,
+    process.env.WORKSPACE_PATH,
+    process.env.PWD,
+    process.env.INIT_CWD,
+    process.cwd(),
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const resolved = normalizeRootPath(candidate);
+    if (resolved && !isUnsafeWorkspaceRoot(resolved) && !isHomePath(resolved)) return resolved;
+  }
+  return process.cwd();
+}
+
+export async function ensureDirectory(targetPath) {
+  const stat = await fs.stat(targetPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Path is not a directory: ${targetPath}`);
+  }
+}
+
+export function aggregateScanResults(fileResults) {
+  const allFindings = fileResults.flatMap((r) => r.result.findings || []);
+  const bySeverity = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const finding of allFindings) {
+    bySeverity[finding.severity] = (bySeverity[finding.severity] || 0) + 1;
+  }
+
+  const totalIssues =
+    bySeverity.critical + bySeverity.high + bySeverity.medium + bySeverity.low;
+  let score = 100;
+  score -= bySeverity.critical * 20;
+  score -= bySeverity.high * 10;
+  score -= bySeverity.medium * 5;
+  score -= bySeverity.low * 2;
+  score = Math.max(0, Math.min(100, Math.round(score)));
+
+  const checklist = CHECKLIST.map((item) => ({
+    id: item.id,
+    item: item.item,
+    critical: item.critical,
+    pass: !item.ruleIds.some((rid) => allFindings.some((f) => f.ruleId === rid)),
+  }));
+
+  return {
+    summary: {
+      filesScanned: fileResults.length,
+      totalIssues,
+      bySeverity,
+      score,
+    },
+    checklist,
+  };
+}
+
+export async function readGitignoreChecks(rootPath) {
+  const gitignorePath = path.join(rootPath, '.gitignore');
+  try {
+    const content = await fs.readFile(gitignorePath, 'utf8');
+    const hasEnvPattern = /(^|\n)\s*\.env(\.\*)?\s*($|\n)/m.test(content);
+    return {
+      gitignoreExists: true,
+      hasEnvPattern,
+      gitignorePath,
+    };
+  } catch {
+    return {
+      gitignoreExists: false,
+      hasEnvPattern: false,
+      gitignorePath,
+    };
+  }
+}
+
+export async function gatherRepoScan(rootPath, includeGlobs, excludeGlobs, maxFiles) {
+  const files = await fg(includeGlobs, {
+    cwd: rootPath,
+    onlyFiles: true,
+    absolute: true,
+    ignore: excludeGlobs,
+    suppressErrors: true,
+    followSymbolicLinks: false,
+  });
+
+  const matchedFiles =
+    files.length === 0
+      ? await fg(['**/*'], {
+          cwd: rootPath,
+          onlyFiles: true,
+          absolute: true,
+          ignore: [
+            ...excludeGlobs,
+            '**/*.png',
+            '**/*.jpg',
+            '**/*.jpeg',
+            '**/*.gif',
+            '**/*.webp',
+            '**/*.pdf',
+            '**/*.zip',
+          ],
+          suppressErrors: true,
+          followSymbolicLinks: false,
+        })
+      : files;
+
+  const limitedFiles = matchedFiles.slice(0, maxFiles);
+  const fileResults = [];
+  for (const absPath of limitedFiles) {
+    const code = await fs.readFile(absPath, 'utf8');
+    const lang = inferLang(absPath);
+    const result = localScan(code, lang);
+    fileResults.push({
+      filePath: absPath,
+      lang,
+      result,
+    });
+  }
+
+  const aggregate = aggregateScanResults(fileResults);
+  const topRiskFiles = fileResults
+    .map((f) => ({
+      filePath: f.filePath,
+      score: f.result.score,
+      findings: f.result.findings.length,
+      critical: f.result.findings.filter((x) => x.severity === 'critical').length,
+      high: f.result.findings.filter((x) => x.severity === 'high').length,
+    }))
+    .sort((a, b) => b.critical - a.critical || b.high - a.high || b.findings - a.findings)
+    .slice(0, 20);
+
+  return {
+    matchedFiles,
+    limitedFiles,
+    fileResults,
+    aggregate,
+    topRiskFiles,
+  };
+}

package/src/rule-engine/index.js

@@ -0,0 +1,9 @@
+/**
+ * rule-engine/index.js
+ * Bundled inline - no external @vibesecur/rule-engine dep needed.
+ * This allows `npx @vibesecur/mcp-server` to work standalone.
+ */
+export { JS_RULES, PY_RULES, CHECKLIST } from './rules.js';
+export { localScan } from './localScan.js';
+export { buildClaudePrompt } from './prompt.js';
+export { calculateScore, getGrade, getVerdict } from './score.js';

package/src/rule-engine/localScan.js

@@ -0,0 +1,58 @@
+import crypto from 'crypto';
+import { JS_RULES, PY_RULES, CHECKLIST } from './rules.js';
+import { calculateScore, getGrade, getVerdict } from './score.js';
+
+export function localScan(code, lang = 'js') {
+  const rules = lang === 'py'
+    ? PY_RULES
+    : lang === 'auto'
+      ? [...JS_RULES, ...PY_RULES]
+      : JS_RULES;
+
+  const findings = [];
+
+  for (const rule of rules) {
+    const matches = [...code.matchAll(rule.re)];
+    for (const match of matches) {
+      if (rule.id === 'A003' && /expiresIn|['"]exp['"]|,\s*exp\s*:/.test(match[0])) continue;
+
+      const lineNumber = code.substring(0, match.index).split('\n').length;
+      const snippet = match[0].substring(0, 80) + (match[0].length > 80 ? '...' : '');
+      findings.push({
+        ruleId: rule.id,
+        ruleName: rule.name,
+        severity: rule.sev,
+        category: rule.cat,
+        lineNumber,
+        snippet,
+        fix: rule.fix,
+      });
+    }
+  }
+
+  const score = calculateScore(findings);
+  const grade = getGrade(score);
+  const verdict = getVerdict(score);
+  const codeHash = crypto.createHash('sha256').update(code).digest('hex');
+
+  const checklist = CHECKLIST.map((cl) => ({
+    ...cl,
+    pass: !cl.ruleIds.some((rid) => findings.find((f) => f.ruleId === rid)),
+  }));
+
+  return {
+    score,
+    grade,
+    verdict,
+    findings,
+    checklist,
+    codeHash,
+    linesAnalysed: code.split('\n').length,
+    engine: 'local',
+    summary: `Local engine found ${findings.length} issue${findings.length !== 1 ? 's' : ''}. ${
+      findings.length === 0
+        ? 'No common vibe coding vulnerabilities detected.'
+        : 'Fix critical items before deploying to production.'
+    }`,
+  };
+}

package/src/rule-engine/prompt.js

@@ -0,0 +1,52 @@
+export function buildClaudePrompt(code, platform, mode, lang) {
+  const isSupabase = mode === 'supabase' || code.toLowerCase().includes('supabase');
+  const isPython = lang === 'py' || code.includes('import os') || code.includes('def ');
+  const deepMode = mode === 'deep' ? 'DEEP MODE: find subtle and complex issues.' : '';
+  const sbMode = isSupabase ? 'Focus especially on Supabase RLS policies and service key exposure.' : '';
+
+  return `You are Vibesecur, an expert AI security scanner for AI-generated code. Analyse this ${lang.toUpperCase()} code from ${platform}.
+Return ONLY valid JSON - no markdown, no explanation, no backticks.
+
+\`\`\`${lang}
+${code.substring(0, 8000)}
+\`\`\`
+
+Return exactly this JSON structure:
+{
+  "score": <0-100>,
+  "grade": "<A|B|C|D|F>",
+  "verdict": "<one sentence>",
+  "summary": "<2-3 sentences about this specific codebase's risk profile>",
+  "findings": [
+    {
+      "ruleId": "<S001|RLS1|P001 etc>",
+      "ruleName": "<descriptive name>",
+      "severity": "<critical|high|medium|low>",
+      "lineNumber": <integer or null>,
+      "category": "<Secrets|Auth|Injection|CORS|RLS|Exposure|Python|SSRF>",
+      "description": "<what was found - be specific>",
+      "fix": "<exact actionable code fix>"
+    }
+  ],
+  "checklist": [
+    {"id":"CL01","item":"No API keys hardcoded","critical":true,"pass":<bool>},
+    {"id":"CL02","item":".env in .gitignore","critical":true,"pass":<bool>},
+    {"id":"CL03","item":"bcrypt/argon2 for passwords","critical":true,"pass":<bool>},
+    {"id":"CL04","item":"JWT expiry set","critical":true,"pass":<bool>},
+    {"id":"CL05","item":"Rate limiting on auth","critical":true,"pass":<bool>},
+    {"id":"CL06","item":"CORS restricted","critical":true,"pass":<bool>},
+    {"id":"CL07","item":"No SQL injection","critical":true,"pass":<bool>},
+    {"id":"CL08","item":"Supabase RLS enabled","critical":${isSupabase},"pass":<bool>},
+    {"id":"CL09","item":"Firebase rules restricted","critical":false,"pass":<bool>},
+    {"id":"CL10","item":"No stack traces","critical":false,"pass":<bool>},
+    {"id":"CL11","item":"eval() not used","critical":true,"pass":<bool>},
+    {"id":"CL12","item":"No debug mode","critical":false,"pass":<bool>}
+  ],
+  "aiInsight": "<3-4 sentences of specific insight about this codebase's security posture>",
+  "envVars": ["<VAR_NAME: what it replaces>"],
+  "policies": ["<specific action: exact detail>"]
+}
+
+Scoring: start 100, subtract 20 per critical, 10 per high, 5 per medium. ${deepMode} ${sbMode}
+Be specific about ${isPython ? 'Python eval/pickle/subprocess patterns' : 'auth patterns and Supabase RLS'}.`;
+}

package/src/rule-engine/rules.js

@@ -0,0 +1,51 @@
+export const JS_RULES = [
+  { id: 'S001', name: 'Hardcoded API Key', sev: 'critical', re: /api[_-]?key\s*[:=]\s*['"][a-zA-Z0-9_\-]{16,}['"]/gi, fix: 'Move to .env: process.env.API_KEY', cat: 'Secrets' },
+  { id: 'S002', name: 'Hardcoded Password', sev: 'critical', re: /password\s*[:=]\s*['"][^'"]{4,}['"]/gi, fix: 'Use env var: process.env.PASSWORD', cat: 'Secrets' },
+  { id: 'S003', name: 'JWT Secret Hardcoded', sev: 'critical', re: /jwt[_-]?secret\s*[:=]\s*['"][^'"]{6,}['"]/gi, fix: 'Move to .env: JWT_SECRET=...', cat: 'Secrets' },
+  { id: 'S004', name: 'Database URL Exposed', sev: 'critical', re: /(mongodb|mysql|postgres|supabase):\/\/[^\s'"]{8,}/gi, fix: 'Move to .env: DATABASE_URL=...', cat: 'Secrets' },
+  { id: 'S005', name: 'AWS Access Key', sev: 'critical', re: /AKIA[0-9A-Z]{16}/g, fix: 'Rotate immediately. Use IAM roles.', cat: 'Secrets' },
+  { id: 'S006', name: 'Stripe Key Exposed', sev: 'critical', re: /(sk_live|sk_test)_[a-zA-Z0-9]{20,}/g, fix: 'Move to .env: STRIPE_SECRET_KEY=...', cat: 'Secrets' },
+  { id: 'S007', name: 'Private Key in Code', sev: 'critical', re: /-----BEGIN[A-Z ]*PRIVATE KEY-----/g, fix: 'Never commit private keys. Use a secrets manager.', cat: 'Secrets' },
+  { id: 'A001', name: 'MD5 Password Hashing', sev: 'critical', re: /md5\s*\(/gi, fix: 'Use bcrypt: await bcrypt.hash(password, 12)', cat: 'Auth' },
+  { id: 'A002', name: 'SHA1 Password Hashing', sev: 'critical', re: /sha1\s*\(/gi, fix: 'Use bcrypt or argon2 for passwords', cat: 'Auth' },
+  { id: 'A003', name: 'JWT Without Expiry', sev: 'critical', re: /jwt\.sign\s*\([^)]{0,200}\)/g, fix: 'Add: { expiresIn: "1h" }', cat: 'Auth' },
+  { id: 'A004', name: 'eval() Usage', sev: 'critical', re: /\beval\s*\(/g, fix: 'Never use eval() - arbitrary code execution', cat: 'Injection' },
+  { id: 'A005', name: 'SQL Injection Risk', sev: 'critical', re: /(SELECT|INSERT|UPDATE|DELETE)[^;`]{0,120}(\+\s*(req\.|user\.)|\$\{(req\.|user\.))/gi, fix: 'Use parameterized queries: db.query("?", [val])', cat: 'Injection' },
+  { id: 'A006', name: 'Wildcard CORS', sev: 'critical', re: /origin\s*:\s*['"]\*['"]/gi, fix: 'cors({ origin: process.env.ALLOWED_ORIGIN })', cat: 'CORS' },
+  { id: 'A007', name: 'Missing Rate Limit', sev: 'high', re: /app\.(post|put)\s*\(['"]\/(login|auth|register)/gi, fix: 'Add rateLimit({ windowMs:900000, max:5 }) middleware', cat: 'Auth' },
+  { id: 'RLS1', name: 'Supabase - Missing RLS', sev: 'critical', re: /supabase\.from\(['"`][^'"`]+['"`]\)\.(select|insert|update|delete)/gi, fix: 'ENABLE ROW LEVEL SECURITY on this table', cat: 'RLS' },
+  { id: 'RLS2', name: 'Supabase Service Key FE', sev: 'critical', re: /service_role|supabase_service/gi, fix: 'Service key must be server-side only - never in browser', cat: 'RLS' },
+  { id: 'RLS3', name: 'Firebase Open Rules', sev: 'critical', re: /allow read, write:\s*if true/gi, fix: 'Restrict: allow read if request.auth != null', cat: 'RLS' },
+  { id: 'E001', name: 'Credentials in Logs', sev: 'high', re: /console\.log\(.*?(password|token|secret|key)/gi, fix: 'Remove console.log with sensitive data', cat: 'Exposure' },
+  { id: 'E002', name: 'Debug Mode On', sev: 'high', re: /debug\s*[:=]\s*true/gi, fix: 'Set debug: false in production', cat: 'Exposure' },
+  { id: 'E003', name: 'Stack Trace Exposed', sev: 'high', re: /res\.(send|json)\(.*?err\.(stack|message)/gi, fix: 'return { error: "Server error" } only', cat: 'Exposure' },
+  { id: 'E004', name: 'TODO Security Note', sev: 'medium', re: /\/\/\s*(TODO|FIXME).*?(auth|security|password|token)/gi, fix: 'Resolve all security TODOs before deploy', cat: 'Exposure' },
+  { id: 'E005', name: 'Sensitive GET Params', sev: 'medium', re: /\?.*?(token|password|secret|key)=/gi, fix: 'Use POST body - never sensitive data in URL params', cat: 'Exposure' },
+];
+
+export const PY_RULES = [
+  { id: 'P001', name: 'Python eval()', sev: 'critical', re: /\beval\s*\(/g, fix: 'Never use eval() - arbitrary code execution', cat: 'Injection' },
+  { id: 'P002', name: 'Python pickle.loads()', sev: 'critical', re: /pickle\.loads?\s*\(/g, fix: 'Never unpickle untrusted data - use JSON', cat: 'Injection' },
+  { id: 'P003', name: 'Python SQL Concatenation', sev: 'critical', re: /cursor\.execute\s*\([^)]*%\s*|f"SELECT.*\{/gi, fix: 'Use parameterized queries: cursor.execute("?", (v,))', cat: 'Injection' },
+  { id: 'P004', name: 'Python Hardcoded Secret', sev: 'critical', re: /(password|api_key|secret|token)\s*=\s*['"][^'"]{6,}['"]/gi, fix: 'Use os.environ.get("SECRET")', cat: 'Secrets' },
+  { id: 'P005', name: 'Python subprocess shell', sev: 'high', re: /subprocess\.[^(]+\([^)]*shell\s*=\s*True/gi, fix: 'Avoid shell=True - use list args', cat: 'Injection' },
+  { id: 'P006', name: 'Python MD5 Passwords', sev: 'critical', re: /hashlib\.(md5|sha1)/gi, fix: 'Use bcrypt or argon2-cffi for passwords', cat: 'Auth' },
+  { id: 'P007', name: 'Python DEBUG=True', sev: 'high', re: /DEBUG\s*=\s*True/g, fix: 'Set DEBUG=False in production settings', cat: 'Exposure' },
+  { id: 'P008', name: 'Python Open Redirect', sev: 'medium', re: /redirect\s*\([^)]*request\.(args|form|params)/gi, fix: 'Validate redirect URLs against allowlist', cat: 'Auth' },
+  { id: 'P009', name: 'Python SSRF Risk', sev: 'high', re: /requests\.(get|post)\s*\([^)]*request\./gi, fix: 'Validate and allowlist URLs before fetching', cat: 'SSRF' },
+];
+
+export const CHECKLIST = [
+  { id: 'CL01', item: 'No API keys hardcoded', critical: true, ruleIds: ['S001', 'S002', 'S003', 'S005', 'S006', 'P004'] },
+  { id: 'CL02', item: '.env in .gitignore', critical: true, ruleIds: [] },
+  { id: 'CL03', item: 'bcrypt/argon2 for passwords', critical: true, ruleIds: ['A001', 'A002', 'P006'] },
+  { id: 'CL04', item: 'JWT expiry set', critical: true, ruleIds: ['A003'] },
+  { id: 'CL05', item: 'Rate limiting on auth routes', critical: true, ruleIds: ['A007'] },
+  { id: 'CL06', item: 'CORS restricted', critical: true, ruleIds: ['A006'] },
+  { id: 'CL07', item: 'No SQL injection patterns', critical: true, ruleIds: ['A005', 'P003'] },
+  { id: 'CL08', item: 'Supabase RLS enabled', critical: true, ruleIds: ['RLS1', 'RLS2'] },
+  { id: 'CL09', item: 'Firebase rules restricted', critical: false, ruleIds: ['RLS3'] },
+  { id: 'CL10', item: 'No stack traces exposed', critical: false, ruleIds: ['E003'] },
+  { id: 'CL11', item: 'eval() not used', critical: true, ruleIds: ['A004', 'P001', 'P002'] },
+  { id: 'CL12', item: 'No debug mode in production', critical: false, ruleIds: ['E002', 'P007'] },
+];

package/src/rule-engine/score.js

@@ -0,0 +1,22 @@
+export function calculateScore(findings) {
+  const WEIGHTS = { critical: 20, high: 10, medium: 5, low: 2 };
+  let score = 100;
+  for (const f of findings) score -= (WEIGHTS[f.severity] || 2);
+  const cats = new Set(findings.map((f) => f.category));
+  if (cats.size >= 4) score -= 5;
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+
+export function getGrade(score) {
+  if (score >= 90) return 'A';
+  if (score >= 80) return 'B';
+  if (score >= 70) return 'C';
+  if (score >= 60) return 'D';
+  return 'F';
+}
+
+export function getVerdict(score) {
+  if (score >= 80) return 'Safe to Deploy';
+  if (score >= 60) return 'Review Before Deploy';
+  return 'Critical Issues - Do Not Ship';
+}

package/src/server.js

@@ -0,0 +1,491 @@
+import { createRequire } from 'module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z from 'zod';
+import fs from 'fs/promises';
+import path from 'path';
+import {
+  CHECKLIST, JS_RULES, PY_RULES,
+  buildClaudePrompt, localScan,
+} from './rule-engine/index.js';
+import {
+  DEFAULT_INCLUDE, DEFAULT_EXCLUDE,
+  inferLang, normalizeRootPath, ensureDirectory,
+  gatherRepoScan, readGitignoreChecks,
+  detectWorkspacePath, isHomePath,
+} from './repo-scan.mjs';
+import { postRemoteLocalScan } from './api-scan.mjs';
+import { validateScanPath, diagnosticLock } from './lock.mjs';
+
+const require = createRequire(import.meta.url);
+const mcpPkg = require('../package.json');
+
+const INSTALL_TOKEN = process.env.VIBESECUR_INSTALL_TOKEN || null;
+const BOUND_ROOT = process.env.VIBESECUR_BOUND_ROOT
+  ? path.resolve(process.env.VIBESECUR_BOUND_ROOT)
+  : null;
+
+if (!INSTALL_TOKEN || !BOUND_ROOT) {
+  process.stderr.write(
+    '[vibesecur] WARNING: VIBESECUR_INSTALL_TOKEN and VIBESECUR_BOUND_ROOT are not set.\n' +
+    '[vibesecur] Run: vibesecur-mcp bind <folder> then vibesecur-mcp config <folder>\n' +
+    '[vibesecur] Scans will be restricted to process.cwd() as fallback.\n',
+  );
+}
+
+const server = new McpServer({
+  name: 'vibesecur-mcp-server',
+  version: mcpPkg.version || '2.0.0',
+});
+
+const SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+
+async function guardPath(requestedPath) {
+  const target = normalizeRootPath(requestedPath);
+  if (!BOUND_ROOT) {
+    const cwd = path.resolve(process.cwd());
+    if (!target.startsWith(cwd + path.sep) && target !== cwd) {
+      return {
+        ok: false,
+        httpStatus: 403,
+        code: 'NO_LOCK_OUT_OF_CWD',
+        message:
+          `No lock configured and "${target}" is outside process.cwd() "${cwd}". ` +
+          'Run vibesecur-mcp bind <folder> and add VIBESECUR_BOUND_ROOT to your MCP config.',
+      };
+    }
+    return { ok: true, resolvedRoot: target };
+  }
+  if (!target.startsWith(BOUND_ROOT + path.sep) && target !== BOUND_ROOT) {
+    return {
+      ok: false,
+      httpStatus: 403,
+      code: 'OUT_OF_FOLDER',
+      message:
+        `Path "${target}" is outside the locked project folder "${BOUND_ROOT}". ` +
+        'Vibesecur MCP is bound to one folder per install. ' +
+        'To scan a different folder, run "vibesecur-mcp rebind <new-folder>".',
+      rebindHint: `vibesecur-mcp rebind ${target}`,
+    };
+  }
+  const result = await validateScanPath(target, INSTALL_TOKEN);
+  if (!result.ok) return result;
+  return { ok: true, resolvedRoot: target, lock: result.lock };
+}
+
+function guardError(guard) {
+  const status = guard.httpStatus ? ` (${guard.httpStatus})` : '';
+  const text = JSON.stringify({
+    error: guard.code || 'SCAN_BLOCKED',
+    message: guard.message,
+    rebindHint: guard.rebindHint || null,
+    docs: 'https://vibesecur.com/docs/mcp-setup',
+  }, null, 2);
+  return {
+    content: [{ type: 'text', text: `Security Lock Error${status}:\n${text}` }],
+    isError: true,
+  };
+}
+
+function buildScanMeta(resolvedRoot, includeGlobs, excludeGlobs, maxFiles, matchedLen, scannedLen) {
+  return {
+    resolvedRoot,
+    includeGlobsUsed: includeGlobs,
+    excludeGlobsUsed: excludeGlobs,
+    maxFiles,
+    matchedFiles: matchedLen,
+    scannedFiles: scannedLen,
+    cappedByMaxFiles: matchedLen > maxFiles,
+    boundRoot: BOUND_ROOT || 'unconfigured',
+  };
+}
+
+function humanRepoSummary(meta, agg) {
+  const { bySeverity, score, totalIssues } = agg.summary;
+  const parts = [`Scanned ${meta.scannedFiles} file(s) of ${meta.matchedFiles} matched under "${meta.resolvedRoot}".`];
+  if (meta.cappedByMaxFiles) parts.push(`More files matched than maxFiles (${meta.maxFiles}); increase maxFiles for full coverage.`);
+  parts.push(`Score ${score} - ${totalIssues} issue(s): ${bySeverity.critical} critical, ${bySeverity.high} high, ${bySeverity.medium} medium, ${bySeverity.low} low.`);
+  return parts.join(' ');
+}
+
+function flattenFindings(fileResults) {
+  return fileResults.flatMap((fr) =>
+    (fr.result.findings || []).map((f) => ({ ...f, filePath: fr.filePath })),
+  );
+}
+
+function pickTopFindings(fileResults, n) {
+  const flat = flattenFindings(fileResults);
+  flat.sort((a, b) => {
+    const da = SEVERITY_ORDER[a.severity] ?? 9;
+    const db = SEVERITY_ORDER[b.severity] ?? 9;
+    return da !== db ? da - db : (a.filePath || '').localeCompare(b.filePath || '');
+  });
+  return flat.slice(0, n).map((f) => ({
+    filePath: f.filePath,
+    lineNumber: f.lineNumber,
+    ruleId: f.ruleId,
+    ruleName: f.ruleName,
+    severity: f.severity,
+    snippetPreview: (f.snippet || '').slice(0, 120),
+  }));
+}
+
+server.registerTool('health', {
+  title: 'MCP Health',
+  description: 'Server version, rule counts, lock status, and workspace hints.',
+  inputSchema: { detail: z.enum(['brief', 'full']).default('brief') },
+}, async ({ detail = 'brief' }) => {
+  const cwd = process.cwd();
+  const detected = detectWorkspacePath();
+  const diagRoot = BOUND_ROOT || cwd;
+  const diag = await diagnosticLock(diagRoot).catch(() => ({ healthy: false, issue: 'diagnostic_error' }));
+  const payload = {
+    ok: true,
+    server: { name: 'vibesecur-mcp-server', version: mcpPkg.version },
+    lock: {
+      configured: !!(INSTALL_TOKEN && BOUND_ROOT),
+      boundRoot: BOUND_ROOT || null,
+      healthy: diag.healthy,
+      issues: diag.issues || [],
+    },
+    rules: {
+      jsRuleCount: JS_RULES.length,
+      pyRuleCount: PY_RULES.length,
+      totalRules: JS_RULES.length + PY_RULES.length,
+      checklistItems: CHECKLIST.length,
+    },
+    paths: { processCwd: cwd, detectedWorkspace: detected, detectedIsUserHome: isHomePath(detected) },
+    ide: {
+      supported: ['cursor', 'vscode-mcp', 'windsurf', 'claude-desktop', 'continue-dev', 'cline'],
+      setupGuide: 'https://vibesecur.com/docs/mcp-setup',
+      configTool: 'vibesecur-mcp config <folder>',
+    },
+  };
+
+  if (detail === 'full') {
+    payload.envHints = {
+      VIBESECUR_INSTALL_TOKEN: INSTALL_TOKEN ? '***set***' : 'NOT SET',
+      VIBESECUR_BOUND_ROOT: BOUND_ROOT || 'NOT SET',
+      VIBESECUR_API_BASE: process.env.VIBESECUR_API_BASE || 'NOT SET',
+      CURSOR_WORKSPACE_PATH: process.env.CURSOR_WORKSPACE_PATH ?? null,
+      WORKSPACE_PATH: process.env.WORKSPACE_PATH ?? null,
+    };
+    payload.lockDiagnostic = diag;
+  }
+
+  const brief = {
+    ok: true,
+    version: mcpPkg.version,
+    lockConfigured: payload.lock.configured,
+    lockHealthy: payload.lock.healthy,
+    boundRoot: BOUND_ROOT || null,
+    totalRules: JS_RULES.length + PY_RULES.length,
+    processCwd: cwd,
+  };
+
+  return {
+    content: [{ type: 'text', text: JSON.stringify(detail === 'full' ? payload : brief, null, 2) }],
+    structuredContent: payload,
+  };
+});
+
+server.registerTool('installDiagnostic', {
+  title: 'Install Diagnostic',
+  description: 'Full diagnostic of lock health, token validity, and config suggestions.',
+  inputSchema: { path: z.string().default('.') },
+}, async ({ path: reqPath = '.' }) => {
+  const target = normalizeRootPath(reqPath);
+  const diag = await diagnosticLock(target);
+  const payload = {
+    ...diag,
+    installToken: INSTALL_TOKEN ? '***set***' : 'NOT SET - run: vibesecur-mcp bind <folder>',
+    boundRoot: BOUND_ROOT || 'NOT SET - run: vibesecur-mcp bind <folder>',
+    apiBase: process.env.VIBESECUR_API_BASE || 'NOT SET (offline mode)',
+    setupDocs: 'https://vibesecur.com/docs/mcp-setup',
+    configCommand: `vibesecur-mcp config ${target}`,
+    rebindCommand: `vibesecur-mcp rebind ${target}`,
+  };
+  if (!diag.healthy) {
+    payload.resolution =
+      `Run: vibesecur-mcp rebind ${BOUND_ROOT || target}` +
+      '\nThen copy the new token to your IDE MCP config env.';
+  }
+  return {
+    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+    structuredContent: payload,
+    isError: !diag.healthy,
+  };
+});
+
+server.registerTool('localScan', {
+  title: 'Local Security Scan',
+  description: 'Run Vibesecur rule-engine on code. Restricted to bound project folder.',
+  inputSchema: {
+    code: z.string().min(1).max(50000).describe('Source code to scan'),
+    lang: z.enum(['js', 'ts', 'py', 'json', 'auto']).default('auto'),
+    projectRoot: z.string().default('.').describe('Must be inside bound folder'),
+  },
+}, async ({ code, lang = 'auto', projectRoot = '.' }) => {
+  const guard = await guardPath(projectRoot);
+  if (!guard.ok) return guardError(guard);
+  const remote = await postRemoteLocalScan({
+    code,
+    lang,
+    projectRoot: guard.resolvedRoot,
+    platform: 'mcp',
+    token: INSTALL_TOKEN,
+  });
+  if (!remote.skipped && remote.status === 402) {
+    return {
+      content: [{ type: 'text', text: JSON.stringify({ ...remote.json, upgradeUrl: 'https://vibesecur.com/#pricing' }, null, 2) }],
+      isError: true,
+    };
+  }
+  if (!remote.skipped && remote.ok && remote.json?.success && remote.json?.data) {
+    const data = remote.json.data;
+    const humanSummary = `${data.verdict || ''} Score ${data.score} (${data.grade}) - ${(data.findings || []).length} finding(s).`;
+    const enriched = { ...data, humanSummary, engineVersion: mcpPkg.version, quota: remote.json.quota };
+    return { content: [{ type: 'text', text: JSON.stringify(enriched, null, 2) }], structuredContent: enriched };
+  }
+  const result = localScan(code, lang);
+  const humanSummary = `${result.verdict} Score ${result.score} (${result.grade}) - ${result.findings.length} finding(s).`;
+  const enriched = { ...result, humanSummary, engineVersion: mcpPkg.version, mode: 'offline' };
+  return { content: [{ type: 'text', text: JSON.stringify(enriched, null, 2) }], structuredContent: enriched };
+});
+
+server.registerTool('scanFile', {
+  title: 'Scan File',
+  description: 'Scan a single file. Must be inside the bound project folder.',
+  inputSchema: {
+    filePath: z.string().min(1).describe('Absolute or relative file path (must be inside bound folder)'),
+    lang: z.enum(['js', 'ts', 'py', 'json', 'auto']).default('auto'),
+  },
+}, async ({ filePath, lang = 'auto' }) => {
+  try {
+    const resolvedPath = path.resolve(filePath);
+    const guard = await guardPath(path.dirname(resolvedPath));
+    if (!guard.ok) return guardError(guard);
+    const code = await fs.readFile(resolvedPath, 'utf8');
+    const useLang = lang === 'auto' ? inferLang(resolvedPath) : lang;
+    const remote = await postRemoteLocalScan({
+      code,
+      lang: useLang,
+      projectRoot: guard.resolvedRoot,
+      platform: 'mcp',
+      token: INSTALL_TOKEN,
+    });
+    let result;
+    if (!remote.skipped && remote.ok && remote.json?.success && remote.json?.data) {
+      result = remote.json.data;
+    } else if (!remote.skipped && remote.status === 402) {
+      return { content: [{ type: 'text', text: JSON.stringify(remote.json, null, 2) }], isError: true };
+    } else {
+      result = localScan(code, useLang);
+    }
+    const findings = result.findings || [];
+    const bySev = findings.reduce((a, f) => {
+      a[f.severity] = (a[f.severity] || 0) + 1;
+      return a;
+    }, { critical: 0, high: 0, medium: 0, low: 0 });
+    const humanSummary = `File "${resolvedPath}": score ${result.score} (${result.grade}), ${findings.length} issue(s).`;
+    const body = {
+      humanSummary,
+      filePath: resolvedPath,
+      lang: useLang,
+      score: result.score,
+      grade: result.grade,
+      findings: findings.length,
+      bySeverity: bySev,
+      checklist: result.checklist,
+      result,
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(body, null, 2) }], structuredContent: body };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `scanFile failed: ${e.message}` }], isError: true };
+  }
+});
+
+server.registerTool('scanRepo', {
+  title: 'Scan Repository',
+  description: 'Scan files in a repo. rootPath must be inside the bound project folder.',
+  inputSchema: {
+    rootPath: z.string().default('.').describe('Repo root (must be inside bound folder)'),
+    includeGlobs: z.array(z.string()).default(DEFAULT_INCLUDE),
+    excludeGlobs: z.array(z.string()).default(DEFAULT_EXCLUDE),
+    maxFiles: z.number().int().min(1).max(5000).default(300),
+  },
+}, async ({ rootPath, includeGlobs = DEFAULT_INCLUDE, excludeGlobs = DEFAULT_EXCLUDE, maxFiles = 300 }) => {
+  try {
+    const guard = await guardPath(rootPath);
+    if (!guard.ok) return guardError(guard);
+    const resolvedRoot = guard.resolvedRoot;
+    await ensureDirectory(resolvedRoot);
+    const { matchedFiles, limitedFiles, fileResults, aggregate, topRiskFiles } =
+      await gatherRepoScan(resolvedRoot, includeGlobs, excludeGlobs, maxFiles);
+    const meta = buildScanMeta(resolvedRoot, includeGlobs, excludeGlobs, maxFiles, matchedFiles.length, limitedFiles.length);
+    const body = {
+      meta,
+      humanSummary: humanRepoSummary(meta, aggregate),
+      rootPath: resolvedRoot,
+      scannedFiles: limitedFiles.length,
+      matchedFiles: matchedFiles.length,
+      cappedByMaxFiles: matchedFiles.length > maxFiles,
+      summary: aggregate.summary,
+      checklist: aggregate.checklist,
+      topRiskFiles,
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(body, null, 2) }], structuredContent: { ...body, fileResults } };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `scanRepo failed: ${e.message}` }], isError: true };
+  }
+});
+
+server.registerTool('scanSummary', {
+  title: 'Scan Summary',
+  description: 'Compact scan summary for chat. rootPath must be inside bound folder.',
+  inputSchema: {
+    rootPath: z.string().default('.'),
+    includeGlobs: z.array(z.string()).default(DEFAULT_INCLUDE),
+    excludeGlobs: z.array(z.string()).default(DEFAULT_EXCLUDE),
+    maxFiles: z.number().int().min(1).max(5000).default(200),
+    topFindings: z.number().int().min(1).max(50).default(20),
+  },
+}, async ({ rootPath, includeGlobs = DEFAULT_INCLUDE, excludeGlobs = DEFAULT_EXCLUDE, maxFiles = 200, topFindings = 20 }) => {
+  try {
+    const guard = await guardPath(rootPath);
+    if (!guard.ok) return guardError(guard);
+    const resolvedRoot = guard.resolvedRoot;
+    await ensureDirectory(resolvedRoot);
+    const { matchedFiles, limitedFiles, fileResults, aggregate } =
+      await gatherRepoScan(resolvedRoot, includeGlobs, excludeGlobs, maxFiles);
+    const meta = buildScanMeta(resolvedRoot, includeGlobs, excludeGlobs, maxFiles, matchedFiles.length, limitedFiles.length);
+    const top = pickTopFindings(fileResults, topFindings);
+    const payload = {
+      meta,
+      humanSummary: humanRepoSummary(meta, aggregate),
+      summary: aggregate.summary,
+      checklist: { passed: aggregate.checklist.filter((c) => c.pass).length, total: aggregate.checklist.length },
+      topFindings: top,
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], structuredContent: payload };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `scanSummary failed: ${e.message}` }], isError: true };
+  }
+});
+
+server.registerTool('scanCurrentWorkspace', {
+  title: 'Scan Current Workspace',
+  description: 'Scan workspace auto-detected from IDE environment. Must match bound folder.',
+  inputSchema: {
+    includeGlobs: z.array(z.string()).default(DEFAULT_INCLUDE),
+    excludeGlobs: z.array(z.string()).default(DEFAULT_EXCLUDE),
+    maxFiles: z.number().int().min(1).max(5000).default(300),
+  },
+}, async ({ includeGlobs = DEFAULT_INCLUDE, excludeGlobs = DEFAULT_EXCLUDE, maxFiles = 300 }) => {
+  try {
+    const detected = detectWorkspacePath();
+    if (isHomePath(detected)) {
+      return {
+        content: [{ type: 'text', text: `Could not safely detect workspace (resolved to home: ${detected}). Use scanRepo with explicit rootPath.` }],
+        isError: true,
+      };
+    }
+    const guard = await guardPath(detected);
+    if (!guard.ok) return guardError(guard);
+    await ensureDirectory(guard.resolvedRoot);
+    const { matchedFiles, limitedFiles, fileResults, aggregate, topRiskFiles } =
+      await gatherRepoScan(guard.resolvedRoot, includeGlobs, excludeGlobs, maxFiles);
+    const meta = buildScanMeta(guard.resolvedRoot, includeGlobs, excludeGlobs, maxFiles, matchedFiles.length, limitedFiles.length);
+    const body = {
+      meta,
+      humanSummary: humanRepoSummary(meta, aggregate),
+      rootPath: guard.resolvedRoot,
+      scannedFiles: limitedFiles.length,
+      matchedFiles: matchedFiles.length,
+      cappedByMaxFiles: matchedFiles.length > maxFiles,
+      summary: aggregate.summary,
+      checklist: aggregate.checklist,
+      topRiskFiles,
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(body, null, 2) }], structuredContent: { ...body, fileResults } };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `scanCurrentWorkspace failed: ${e.message}` }], isError: true };
+  }
+});
+
+server.registerTool('projectChecklist', {
+  title: 'Project Checklist',
+  description: 'Security checklist with evidence. rootPath must be inside bound folder.',
+  inputSchema: {
+    rootPath: z.string().default('.'),
+    includeGlobs: z.array(z.string()).default(DEFAULT_INCLUDE),
+    excludeGlobs: z.array(z.string()).default(DEFAULT_EXCLUDE),
+    maxFiles: z.number().int().min(1).max(5000).default(300),
+  },
+}, async ({ rootPath, includeGlobs = DEFAULT_INCLUDE, excludeGlobs = DEFAULT_EXCLUDE, maxFiles = 300 }) => {
+  try {
+    const guard = await guardPath(rootPath);
+    if (!guard.ok) return guardError(guard);
+    const resolvedRoot = guard.resolvedRoot;
+    await ensureDirectory(resolvedRoot);
+    const { matchedFiles, limitedFiles, fileResults, aggregate } =
+      await gatherRepoScan(resolvedRoot, includeGlobs, excludeGlobs, maxFiles);
+    const gitChecks = await readGitignoreChecks(resolvedRoot);
+    const checklistWithEvidence = aggregate.checklist.map((item) => {
+      if (item.id === 'CL02') return { ...item, pass: gitChecks.hasEnvPattern, evidence: gitChecks };
+      const ruleIds = CHECKLIST.find((c) => c.id === item.id)?.ruleIds || [];
+      const violations = fileResults.flatMap((fr) =>
+        fr.result.findings.filter((f) => ruleIds.includes(f.ruleId))
+          .map((f) => ({ filePath: fr.filePath, ruleId: f.ruleId, ruleName: f.ruleName, severity: f.severity, lineNumber: f.lineNumber })),
+      );
+      return { ...item, pass: violations.length === 0, evidence: violations.slice(0, 30) };
+    });
+    const meta = buildScanMeta(resolvedRoot, includeGlobs, excludeGlobs, maxFiles, matchedFiles.length, limitedFiles.length);
+    const passed = checklistWithEvidence.filter((c) => c.pass).length;
+    const body = {
+      meta,
+      humanSummary: `${humanRepoSummary(meta, aggregate)} Checklist: ${passed}/${checklistWithEvidence.length} pass.`,
+      rootPath: resolvedRoot,
+      scannedFiles: limitedFiles.length,
+      matchedFiles: matchedFiles.length,
+      summary: aggregate.summary,
+      checklist: checklistWithEvidence,
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(body, null, 2) }], structuredContent: body };
+  } catch (e) {
+    return { content: [{ type: 'text', text: `projectChecklist failed: ${e.message}` }], isError: true };
+  }
+});
+
+server.registerTool('buildClaudePrompt', {
+  title: 'Build Claude Prompt',
+  description: 'Build a Vibesecur prompt for deep AI security analysis (no folder lock needed).',
+  inputSchema: {
+    code: z.string().min(1).max(50000),
+    platform: z.string().min(1).max(50).default('cursor'),
+    mode: z.enum(['quick', 'deep', 'supabase', 'ownership']).default('quick'),
+    lang: z.enum(['js', 'ts', 'py', 'json', 'auto']).default('auto'),
+  },
+}, async ({ code, platform = 'cursor', mode = 'quick', lang = 'auto' }) => {
+  const prompt = buildClaudePrompt(code, platform, mode, lang);
+  return {
+    content: [{ type: 'text', text: prompt }],
+    structuredContent: { platform, mode, lang, codeChars: code.length, engineVersion: mcpPkg.version, prompt },
+  };
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write(
+    `[vibesecur] MCP server v${mcpPkg.version} started. ` +
+    `BoundRoot: ${BOUND_ROOT || 'unconfigured'}. ` +
+    `Lock: ${INSTALL_TOKEN ? 'set' : 'NOT SET'}.\n`,
+  );
+}
+
+main().catch((e) => {
+  process.stderr.write(`[vibesecur] Fatal: ${e.message}\n`);
+  process.exit(1);
+});