feat(llm-security): add /security ide-scan — VS Code / JetBrains extension prescan (v6.3.0)

New standalone scanner (prefix IDE) discovers installed VS Code extensions
across forks (Cursor, Windsurf, VSCodium, code-server, Insiders, Remote-SSH)
and runs 7 IDE-specific threat checks: blocklist match (CRITICAL),
theme-with-code, sideload (unsigned .vsix), dangerous uninstall hook (HIGH),
wildcard activation, extension-pack expansion, typosquat (MEDIUM).

Per-extension reuse of UNI/ENT/NET/TNT/MEM/SCR scanners with bounded
concurrency. Offline-first; --online opt-in. JetBrains discovery stubbed
for v1.1. 22 new tests (1296 total, was 1274).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

plugins/llm-security/scanners/lib/ide-extension-discovery.mjs

@@ -0,0 +1,271 @@
+// ide-extension-discovery.mjs — OS-aware discovery of installed VS Code / JetBrains extensions.
+// Zero dependencies (Node.js builtins only).
+//
+// VS Code + forks (Cursor, Windsurf, VSCodium, code-server, Insiders, Remote-SSH):
+//   Parses extensions.json (per-dir manifest) + falls back to dir-name regex.
+// JetBrains: stub (v1.1).
+
+import { readFile, readdir, stat, lstat, access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync } from 'node:fs';
+
+// ---------------------------------------------------------------------------
+// OS path resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Return all candidate VS Code extension root directories for current OS.
+ * @returns {string[]}
+ */
+export function getVSCodeExtensionRoots() {
+  const home = homedir();
+  const roots = [
+    join(home, '.vscode', 'extensions'),
+    join(home, '.vscode-insiders', 'extensions'),
+    join(home, '.cursor', 'extensions'),
+    join(home, '.windsurf', 'extensions'),
+    join(home, '.vscode-oss', 'extensions'),       // VSCodium
+    join(home, '.vscode-server', 'extensions'),    // Remote-SSH
+  ];
+  if (process.platform === 'linux') {
+    roots.push(join(home, '.local', 'share', 'code-server', 'extensions'));
+  }
+  return roots;
+}
+
+/**
+ * Return the JetBrains base directory (contains per-IDE-per-version subdirectories).
+ * Actual plugins live under <base>/<IDE><Edition><Version>/plugins/. v1.1 walks these.
+ * @returns {string|null}
+ */
+export function getJetBrainsBaseDir() {
+  const home = homedir();
+  let base;
+  if (process.platform === 'darwin') {
+    base = join(home, 'Library', 'Application Support', 'JetBrains');
+  } else if (process.platform === 'win32') {
+    base = join(process.env.APPDATA || join(home, 'AppData', 'Roaming'), 'JetBrains');
+  } else {
+    base = join(home, '.local', 'share', 'JetBrains');
+  }
+  return existsSync(base) ? base : null;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+// Known VS Code target-platform suffixes per
+// https://code.visualstudio.com/api/working-with-extensions/publishing-extension#platformspecific-extensions
+const PLATFORM_SUFFIXES = [
+  'win32-x64', 'win32-ia32', 'win32-arm64',
+  'linux-x64', 'linux-arm64', 'linux-armhf',
+  'darwin-x64', 'darwin-arm64',
+  'alpine-x64', 'alpine-arm64',
+  'web',
+];
+
+/**
+ * Parse directory name of form "publisher.name-version[-platform]".
+ * Strategy: strip a trailing known-platform suffix first, then match identifier + version.
+ * Returns { publisher, name, version, targetPlatform } or null.
+ * @param {string} dirName
+ */
+export function parseDirName(dirName) {
+  let trimmed = dirName;
+  let targetPlatform = null;
+  for (const plat of PLATFORM_SUFFIXES) {
+    const suffix = '-' + plat;
+    if (trimmed.toLowerCase().endsWith(suffix)) {
+      targetPlatform = plat;
+      trimmed = trimmed.slice(0, -suffix.length);
+      break;
+    }
+  }
+  const m = trimmed.match(/^(.+?)-(\d+\.\d+\.\d+(?:-[a-z0-9.]+)?)$/i);
+  if (!m) return null;
+  const idPart = m[1];
+  const version = m[2];
+  const dotIdx = idPart.indexOf('.');
+  if (dotIdx === -1) return null;
+  return {
+    publisher: idPart.slice(0, dotIdx),
+    name: idPart.slice(dotIdx + 1),
+    version,
+    targetPlatform,
+  };
+}
+
+async function readJson(filePath) {
+  try {
+    const raw = await readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+async function pathExists(p) {
+  try { await access(p); return true; } catch { return false; }
+}
+
+async function isSymlink(p) {
+  try {
+    const s = await lstat(p);
+    return s.isSymbolicLink();
+  } catch { return false; }
+}
+
+// ---------------------------------------------------------------------------
+// VS Code discovery
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {object} ExtensionRecord
+ * @property {string} id
+ * @property {string} publisher
+ * @property {string} name
+ * @property {string} version
+ * @property {string} location
+ * @property {'vscode'|'jetbrains'} type
+ * @property {'gallery'|'vsix'|null} source
+ * @property {boolean} isBuiltin
+ * @property {number|null} installedTimestamp
+ * @property {string|null} targetPlatform
+ * @property {string|null} publisherDisplayName
+ * @property {boolean} signed
+ * @property {string} rootDir
+ */
+
+/**
+ * Discover VS Code extensions across all roots.
+ * @param {object} [options]
+ * @param {string[]} [options.rootsOverride] - Test injection: use these roots only.
+ * @param {boolean} [options.includeBuiltin=false]
+ * @param {boolean} [options.followSymlinks=false]
+ * @returns {Promise<{ extensions: ExtensionRecord[], warnings: string[], rootsScanned: string[] }>}
+ */
+export async function discoverVSCodeExtensions(options = {}) {
+  const warnings = [];
+  const extensions = [];
+  const rootsScanned = [];
+
+  let roots;
+  if (options.rootsOverride) {
+    roots = options.rootsOverride;
+  } else if (process.env.LLM_SECURITY_IDE_ROOTS) {
+    roots = process.env.LLM_SECURITY_IDE_ROOTS.split(':').filter(Boolean);
+  } else {
+    roots = getVSCodeExtensionRoots();
+  }
+
+  for (const root of roots) {
+    if (!await pathExists(root)) continue;
+    rootsScanned.push(root);
+
+    // Load per-root extensions.json (machine index) to get metadata.source, isBuiltin etc.
+    const indexPath = join(root, 'extensions.json');
+    const index = await readJson(indexPath);
+    const metaByRelLoc = new Map();
+    if (Array.isArray(index)) {
+      for (const entry of index) {
+        if (entry && entry.relativeLocation) {
+          metaByRelLoc.set(entry.relativeLocation, entry);
+        }
+      }
+    } else if (index !== null) {
+      warnings.push(`malformed extensions.json in ${root}`);
+    }
+
+    let entries;
+    try {
+      entries = await readdir(root, { withFileTypes: true });
+    } catch (err) {
+      warnings.push(`failed to read ${root}: ${err.message}`);
+      continue;
+    }
+
+    for (const entry of entries) {
+      // Skip dotfiles, extensions.json, .obsolete
+      if (entry.name.startsWith('.')) continue;
+      if (entry.name === 'extensions.json') continue;
+
+      // Check symlink handling
+      if (entry.isSymbolicLink()) {
+        if (!options.followSymlinks) continue;
+      } else if (!entry.isDirectory()) {
+        continue;
+      }
+
+      const extDir = join(root, entry.name);
+      const parsed = parseDirName(entry.name);
+
+      // Read package.json to get authoritative publisher + name
+      const pkgPath = join(extDir, 'package.json');
+      const pkg = await readJson(pkgPath);
+      let publisher = pkg?.publisher;
+      let name = pkg?.name;
+      let version = pkg?.version;
+
+      if (!publisher || !name) {
+        if (!parsed) {
+          warnings.push(`could not identify extension in ${extDir}`);
+          continue;
+        }
+        publisher = publisher || parsed.publisher;
+        name = name || parsed.name;
+        version = version || parsed.version;
+      }
+
+      if (!publisher || !name || !version) {
+        warnings.push(`incomplete identity for ${extDir}`);
+        continue;
+      }
+
+      const id = `${publisher}.${name}`.toLowerCase();
+      const indexEntry = metaByRelLoc.get(entry.name);
+      const meta = indexEntry?.metadata || {};
+      const isBuiltin = meta.isBuiltin === true;
+
+      if (isBuiltin && !options.includeBuiltin) continue;
+
+      const signed = await pathExists(join(extDir, '.signature.p7s'));
+
+      extensions.push({
+        id,
+        publisher: publisher.toLowerCase(),
+        name: name.toLowerCase(),
+        version,
+        location: extDir,
+        type: 'vscode',
+        source: meta.source || null,
+        isBuiltin,
+        installedTimestamp: typeof meta.installedTimestamp === 'number' ? meta.installedTimestamp : null,
+        targetPlatform: meta.targetPlatform || parsed?.targetPlatform || null,
+        publisherDisplayName: meta.publisherDisplayName || null,
+        signed,
+        rootDir: root,
+      });
+    }
+  }
+
+  return { extensions, warnings, rootsScanned };
+}
+
+// ---------------------------------------------------------------------------
+// JetBrains discovery — stub (v1.1)
+// ---------------------------------------------------------------------------
+
+/**
+ * Discover JetBrains plugins. Stub returns empty for v6.3.0.
+ * @param {object} [options]
+ * @returns {Promise<{ extensions: ExtensionRecord[], warnings: string[], rootsScanned: string[] }>}
+ */
+export async function discoverJetBrainsExtensions(options = {}) {
+  return {
+    extensions: [],
+    warnings: ['IntelliJ plugin discovery deferred to v1.1 (see knowledge/ide-extension-threat-patterns.md)'],
+    rootsScanned: [],
+  };
+}