opencode-skills-collection 4.0.74 → 4.0.75

package/bundled-skills/electron-drive-skill/scripts/drive.mjs

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+/**
+ * Start an Electron app under Playwright and operate it from the command line,
+ * one command per call. Written for coding agents, usable by anyone.
+ *
+ * Run it from anywhere inside the project; see SKILL.md and README.md.
+ */
+import { spawn, spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync } from 'node:fs'
+import http from 'node:http'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import {
+  daemonLogPath,
+  driveRoot,
+  isAlive,
+  loadConfig,
+  parseArgs,
+  profileDir,
+  PROJECT_ROOT,
+  readState,
+  startOptions,
+  statePath
+} from './lib.mjs'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+
+const USAGE = `drive <command>
+
+  start [--dev] [--build] [--profile <name>] [--fresh]
+        Launch the app on a scratch profile. Default: the last build
+        ('build' in drive.config.json runs first with --build). --dev: the
+        dev launch, against a renderer dev server you started yourself.
+        --fresh wipes the profile first (first-run state).
+  status                           whether the app is up, its profile and window
+  snapshot                         accessibility tree of the window
+  screenshot [--out <png>] [--selector <css>]
+  click <target>                   Playwright selector: 'text=Settings', 'role=button[name="Save"]', css
+  fill <target> <text>
+  select <target> <value|label>    a <select>, by option value or visible label
+  press <key>                      e.g. Enter, Escape, Control+K
+  wait <target> [--timeout <ms>]
+  eval <js | ->                    in the renderer; an expression, or a body with 'return'
+  main <js | ->                    in the main process; 'electron' and 'process' are in scope
+                                   '-' reads the code from stdin
+  logs [--lines <n>]               recent console output, plus 'logFile' from the config
+  stop                             quit the app and the daemon
+`
+
+const fail = (message) => {
+  console.error(message)
+  process.exit(1)
+}
+
+const send = (command, args = {}) => {
+  const state = readState()
+  if (!state || !isAlive(state.pid)) {
+    if (state) rmSync(statePath(), { force: true })
+    return fail("Nothing is running. Start it with 'drive start'.")
+  }
+
+  const body = JSON.stringify({ token: state.token, command, args })
+  return new Promise((resolve, reject) => {
+    const request = http.request(
+      { host: '127.0.0.1', port: state.port, method: 'POST', headers: { 'content-type': 'application/json' } },
+      (response) => {
+        let data = ''
+        response.on('data', (chunk) => {
+          data += chunk
+        })
+        response.on('end', () => {
+          try {
+            const parsed = JSON.parse(data)
+            if (parsed.ok) resolve(parsed.result)
+            else reject(new Error(parsed.error))
+          } catch (e) {
+            reject(e)
+          }
+        })
+      }
+    )
+    request.on('error', reject)
+    request.end(body)
+  })
+}
+
+const print = (result) => {
+  if (typeof result === 'string') console.log(result)
+  else console.log(JSON.stringify(result, null, 2))
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+
+const urlUp = (url) =>
+  new Promise((resolve) => {
+    const request = http.get(url, { timeout: 1000 }, (response) => {
+      response.resume()
+      resolve(true)
+    })
+    request.on('error', () => resolve(false))
+    request.on('timeout', () => {
+      request.destroy()
+      resolve(false)
+    })
+  })
+
+/** The file Electron will run for `args[0]`: the file itself, or a package's `main`. */
+const entryFile = (target) => {
+  const resolved = path.resolve(PROJECT_ROOT, target)
+  if (!existsSync(resolved) || !statSync(resolved).isDirectory()) return resolved
+  const pkg = JSON.parse(readFileSync(path.join(resolved, 'package.json'), 'utf8'))
+  return path.join(resolved, pkg.main ?? 'index.js')
+}
+
+const start = async (flags) => {
+  const options = startOptions(flags)
+  const config = loadConfig()
+  const existing = readState()
+  if (existing && isAlive(existing.pid)) {
+    fail(`Already driving the app (profile '${existing.profile}', ${existing.mode}). Run 'drive stop' first.`)
+  }
+  if (existing) rmSync(statePath(), { force: true })
+
+  if (options.mode === 'dev') {
+    if (options.build) fail("--build applies to the built app only. With --dev, the dev server rebuilds the renderer.")
+    if (config.dev.url && !(await urlUp(config.dev.url))) {
+      fail(`The renderer dev server is not up at ${config.dev.url}. Start it first, without letting it launch its own Electron.`)
+    }
+  } else {
+    if (options.build) {
+      if (!config.build) fail("--build needs a 'build' command in drive.config.json.")
+      console.log(`Building (${config.build})...`)
+      const built = spawnSync(config.build, { cwd: PROJECT_ROOT, stdio: 'inherit', shell: true })
+      if (built.status !== 0) fail(`'${config.build}' failed.`)
+    }
+    const entry = entryFile(config.args[0] ?? '.')
+    if (!existsSync(entry)) fail(`No built app: ${entry} does not exist. Run 'drive start --build'.`)
+    const ageMinutes = Math.round((Date.now() - statSync(entry).mtimeMs) / 60000)
+    console.log(`Using the build from ${ageMinutes} minute(s) ago. Pass --build to rebuild.`)
+  }
+
+  const dataDir = profileDir(options.profile)
+  if (options.fresh) rmSync(dataDir, { recursive: true, force: true })
+  mkdirSync(dataDir, { recursive: true })
+  mkdirSync(driveRoot(), { recursive: true })
+
+  const logFd = openSync(daemonLogPath(), 'w')
+  const daemon = spawn(
+    process.execPath,
+    [path.join(here, 'daemon.mjs'), options.mode, options.profile, dataDir],
+    {
+      cwd: PROJECT_ROOT,
+      detached: true,
+      stdio: ['ignore', logFd, logFd],
+      env: { ...process.env, DRIVE_PROJECT_ROOT: PROJECT_ROOT }
+    }
+  )
+  daemon.unref()
+
+  console.log(`Starting (${options.mode}, profile '${options.profile}')...`)
+  const deadline = Date.now() + 120_000
+  while (Date.now() < deadline) {
+    if (readState()) break
+    if (!isAlive(daemon.pid)) {
+      console.error(readFileSync(daemonLogPath(), 'utf8'))
+      fail('The driver failed to start the app (log above).')
+    }
+    await sleep(500)
+  }
+  if (!readState()) fail(`Timed out waiting for the app. See ${daemonLogPath()}.`)
+  print(await send('status'))
+}
+
+/** The code argument, or stdin when it is '-'. */
+const codeFrom = (positional) =>
+  positional.length === 1 && positional[0] === '-' ? readFileSync(0, 'utf8') : positional.join(' ')
+
+const run = async () => {
+  const { command, positional, flags } = parseArgs(process.argv.slice(2))
+  const need = (count, what) => {
+    if (positional.length < count) fail(`Usage: drive ${command} ${what}`)
+  }
+
+  switch (command) {
+    case 'start':
+      return start(flags)
+    case 'status': {
+      const state = readState()
+      if (!state || !isAlive(state.pid)) return print('Not running.')
+      return print(await send('status'))
+    }
+    case 'stop': {
+      const state = readState()
+      if (!state || !isAlive(state.pid)) {
+        rmSync(statePath(), { force: true })
+        if (state?.electronPid && isAlive(state.electronPid)) {
+          process.kill(state.electronPid, 'SIGKILL')
+          return print('The daemon was gone but the app was not; killed it.')
+        }
+        return print('Not running.')
+      }
+      return print(await send('stop'))
+    }
+    case 'snapshot':
+      return print(await send('snapshot'))
+    case 'screenshot':
+      return print(
+        await send('screenshot', {
+          out: typeof flags.out === 'string' ? path.resolve(flags.out) : undefined,
+          selector: typeof flags.selector === 'string' ? flags.selector : undefined
+        })
+      )
+    case 'click':
+      need(1, '<target>')
+      return print(await send('click', { target: positional[0] }))
+    case 'fill':
+      need(2, '<target> <text>')
+      return print(await send('fill', { target: positional[0], text: positional.slice(1).join(' ') }))
+    case 'select':
+      need(2, '<target> <value|label>')
+      return print(await send('select', { target: positional[0], value: positional.slice(1).join(' ') }))
+    case 'press':
+      need(1, '<key>')
+      return print(await send('press', { key: positional[0] }))
+    case 'wait':
+      need(1, '<target>')
+      return print(
+        await send('wait', {
+          target: positional[0],
+          timeout: typeof flags.timeout === 'string' ? Number(flags.timeout) : undefined
+        })
+      )
+    case 'eval':
+      need(1, '<js>')
+      return print(await send('eval', { code: codeFrom(positional) }))
+    case 'main':
+      need(1, '<js>')
+      return print(await send('main', { code: codeFrom(positional) }))
+    case 'logs':
+      return print(await send('logs', { lines: typeof flags.lines === 'string' ? Number(flags.lines) : undefined }))
+    case 'help':
+    case '--help':
+      return print(USAGE)
+    default:
+      return fail(`Unknown command '${command}'.\n\n${USAGE}`)
+  }
+}
+
+run().catch((e) => fail(e.message))

package/bundled-skills/electron-drive-skill/scripts/lib.mjs

@@ -0,0 +1,165 @@
+/**
+ * The pure half of the driver: project discovery, config, argument parsing,
+ * paths and the state file. No Playwright and no Electron here, so it can be
+ * tested without launching anything (`node --test scripts/`).
+ */
+import { createHash } from 'node:crypto'
+import { existsSync, readFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+/** The nearest directory at or above `from` with a package.json. */
+export const findProjectRoot = (from = process.cwd()) => {
+  let dir = path.resolve(from)
+  for (;;) {
+    if (existsSync(path.join(dir, 'package.json'))) return dir
+    const parent = path.dirname(dir)
+    if (parent === dir) throw new Error(`No package.json at or above ${from}. Run the driver from inside your Electron project.`)
+    dir = parent
+  }
+}
+
+export const PROJECT_ROOT = process.env.DRIVE_PROJECT_ROOT
+  ? path.resolve(process.env.DRIVE_PROJECT_ROOT)
+  : findProjectRoot()
+
+/**
+ * `drive.config.json` at the project root, over the defaults. Every field is
+ * optional; with no file at all, `start` runs `electron .` on the last build.
+ */
+export const loadConfig = (root = PROJECT_ROOT) => {
+  const file = path.join(root, 'drive.config.json')
+  let config = {}
+  if (existsSync(file)) {
+    try {
+      config = JSON.parse(readFileSync(file, 'utf8'))
+    } catch (e) {
+      throw new Error(`${file} is not valid JSON: ${e.message}`)
+    }
+  }
+  return {
+    build: config.build ?? null,
+    args: config.args ?? ['.'],
+    env: config.env ?? {},
+    logFile: config.logFile ?? null,
+    dev: {
+      args: config.dev?.args ?? config.args ?? ['.'],
+      env: config.dev?.env ?? {},
+      url: config.dev?.url ?? null
+    }
+  }
+}
+
+/**
+ * Everything the driver owns lives under here, never in the real profile. One
+ * directory per project, so two apps never share a scratch profile.
+ */
+export const driveRoot = (root = PROJECT_ROOT) => {
+  if (process.env.DRIVE_ROOT) return process.env.DRIVE_ROOT
+  const hash = createHash('sha256').update(root).digest('hex').slice(0, 8)
+  return path.join(tmpdir(), 'electron-drive', `${path.basename(root)}-${hash}`)
+}
+
+export const statePath = () => path.join(driveRoot(), 'daemon.json')
+export const daemonLogPath = () => path.join(driveRoot(), 'daemon.log')
+export const screenshotDir = () => path.join(driveRoot(), 'screenshots')
+
+/**
+ * A profile name becomes a directory name, so it is restricted to something
+ * that cannot climb out of `profiles/`.
+ */
+export const profileDir = (profile) => {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(profile)) {
+    throw new Error(`Invalid profile name '${profile}': letters, digits, '-' and '_' only.`)
+  }
+  return path.join(driveRoot(), 'profiles', profile)
+}
+
+export const readState = () => {
+  const file = statePath()
+  if (!existsSync(file)) return null
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+export const isAlive = (pid) => {
+  if (!pid) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e) {
+    return e?.code === 'EPERM'
+  }
+}
+
+const BOOLEAN_FLAGS = new Set(['dev', 'build', 'fresh'])
+
+/**
+ * `drive <command> [positional...] [--flag [value]]`.
+ *
+ * Flags known to be boolean take no value, so `start --dev --fresh` is two
+ * flags rather than `dev = '--fresh'`. Everything after a bare `--` is
+ * positional, for JavaScript that itself starts with dashes.
+ */
+export const parseArgs = (argv) => {
+  const [command = 'help', ...rest] = argv
+  const positional = []
+  const flags = {}
+
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i]
+    if (arg === '--') {
+      positional.push(...rest.slice(i + 1))
+      break
+    }
+    if (arg.startsWith('--')) {
+      const name = arg.slice(2)
+      const next = rest[i + 1]
+      if (BOOLEAN_FLAGS.has(name) || next === undefined || next.startsWith('--')) {
+        flags[name] = true
+      } else {
+        flags[name] = next
+        i += 1
+      }
+    } else {
+      positional.push(arg)
+    }
+  }
+
+  return { command, positional, flags }
+}
+
+export const startOptions = (flags) => ({
+  mode: flags.dev ? 'dev' : 'built',
+  build: flags.build === true,
+  profile: typeof flags.profile === 'string' ? flags.profile : 'default',
+  fresh: flags.fresh === true
+})
+
+/**
+ * The child's environment: the caller's, minus the variables that break a
+ * launch, plus the config's, where `{profile}` becomes the scratch profile
+ * directory.
+ *
+ * `ELECTRON_RUN_AS_NODE=1` makes Electron start as plain Node, where `app` is
+ * undefined and nothing works, and some shells set it.
+ */
+export const childEnv = (base, dataDir, mode, extra) => {
+  const env = { ...base }
+  delete env.ELECTRON_RUN_AS_NODE
+  if (mode === 'dev') env.NODE_ENV = 'development'
+  else delete env.NODE_ENV
+  for (const [key, value] of Object.entries(extra)) {
+    env[key] = String(value).replaceAll('{profile}', dataDir)
+  }
+  return env
+}
+
+/**
+ * JavaScript from the command line, made into an async function body: a bare
+ * expression is returned, anything with its own `return` is used as written.
+ */
+export const asFunctionBody = (code) => (/\breturn\b/.test(code) ? code : `return (${code})`)

package/bundled-skills/electron-drive-skill/scripts/lib.test.mjs

@@ -0,0 +1,56 @@
+// node --test scripts/
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { test } from 'node:test'
+
+const project = mkdtempSync(path.join(tmpdir(), 'drive-test-'))
+writeFileSync(path.join(project, 'package.json'), '{}')
+process.env.DRIVE_PROJECT_ROOT = project
+delete process.env.DRIVE_ROOT
+const lib = await import('./lib.mjs')
+
+test('parses commands, valued and boolean flags, and --', () => {
+  assert.deepEqual(lib.parseArgs(['fill', 'role=textbox', 'hello', 'world']), {
+    command: 'fill',
+    positional: ['role=textbox', 'hello', 'world'],
+    flags: {}
+  })
+  assert.deepEqual(lib.parseArgs(['start', '--dev', '--profile', 'x', '--fresh']).flags, {
+    dev: true,
+    profile: 'x',
+    fresh: true
+  })
+  assert.deepEqual(lib.parseArgs(['eval', '--', '--x', '1']).positional, ['--x', '1'])
+  assert.equal(lib.parseArgs([]).command, 'help')
+})
+
+test('keeps profiles inside the driver root', () => {
+  assert.ok(lib.profileDir('default').startsWith(lib.driveRoot()))
+  for (const bad of ['../../Library', 'a/b', '']) assert.throws(() => lib.profileDir(bad), /Invalid profile/)
+})
+
+test('child env drops ELECTRON_RUN_AS_NODE and fills {profile}', () => {
+  const env = lib.childEnv({ ELECTRON_RUN_AS_NODE: '1', NODE_ENV: 'test', KEEP: 'me' }, '/scratch', 'built', {
+    APP_DATA: '{profile}/data'
+  })
+  assert.deepEqual(env, { KEEP: 'me', APP_DATA: '/scratch/data' })
+  assert.equal(lib.childEnv({}, '/s', 'dev', {}).NODE_ENV, 'development')
+})
+
+test('config defaults to electron . with no file', () => {
+  assert.deepEqual(lib.loadConfig(project).args, ['.'])
+  assert.deepEqual(lib.loadConfig(project).dev.args, ['.'])
+})
+
+test('a malformed config names the file', () => {
+  const broken = mkdtempSync(path.join(tmpdir(), 'drive-test-'))
+  writeFileSync(path.join(broken, 'drive.config.json'), '{ "args": [".",] }')
+  assert.throws(() => lib.loadConfig(broken), /drive\.config\.json is not valid JSON/)
+})
+
+test('wraps bare expressions, keeps bodies with return', () => {
+  assert.equal(lib.asFunctionBody('1 + 1'), 'return (1 + 1)')
+  assert.equal(lib.asFunctionBody('return 2'), 'return 2')
+})

package/bundled-skills/mcp-dependency-drift-audit/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: mcp-dependency-drift-audit
+description: "Statically audit MCP configs for mutable npm/npx package references before approval or CI, without executing discovered MCP servers."
+category: security
+risk: safe
+source: "https://github.com/tomelias10/mcp-drift-check"
+source_repo: tomelias10/mcp-drift-check
+source_type: community
+date_added: "2026-09-25"
+author: tomelias10
+tags: [mcp, ai-security, supply-chain, devsecops, sarif]
+tools: [claude, cursor, gemini, codex, windsurf]
+license: MIT
+license_source: "https://github.com/tomelias10/mcp-drift-check/blob/v0/LICENSE"
+---
+
+# MCP Dependency Drift Audit
+
+## Overview
+
+Audit Model Context Protocol configuration files for npm/npx package references that can resolve to different code after the configuration was reviewed. The workflow is deliberately static: it reads config text, classifies version selectors, and recommends reproducibility fixes without starting discovered MCP servers.
+
+Dependency mutability is a review-boundary signal, not proof that a package is malicious, vulnerable, or compromised.
+
+## When to Use This Skill
+
+- Before approving `.mcp.json`, Cursor, VS Code, GitHub Copilot, Claude, or Windsurf MCP configuration.
+- When adding an MCP configuration gate to pull requests or CI.
+- During an AI-agent security review where npm/npx-backed MCP servers are configured.
+- When checking whether a previously reviewed MCP config can silently resolve to newer package code.
+
+## How It Works
+
+### Step 1: Locate and read MCP configs without executing them
+
+Inspect known project paths such as `.mcp.json`, `.github/mcp.json`, `.cursor/mcp.json`, `.vscode/mcp.json`, and `.windsurf/mcp.json`, plus any MCP config explicitly supplied by the user.
+
+Read them as text/JSON only. Never run a discovered `command` or `args` value as part of this audit. Stay inside the requested workspace by default; only include user-level/global MCP configuration if the user explicitly asks for machine-wide scope.
+
+### Step 2: Use MCP Drift Check when already available
+
+If `mcp-drift-check` is already installed, use the workspace-scoped mode from the intended repo root:
+
+```bash
+mcp-drift-check scan-workspace --markdown
+```
+
+For CI evidence:
+
+```bash
+mcp-drift-check scan-workspace --sarif mcp-drift.sarif --markdown
+```
+
+If the scanner is not installed, explain that the following command fetches the open-source scanner from GitHub and get user approval before running it:
+
+```bash
+uvx --from git+https://github.com/tomelias10/mcp-drift-check mcp-drift-check scan-workspace --markdown
+```
+
+If the user declines network access or installation, continue with the manual rules below.
+
+### Step 3: Apply the manual static rules
+
+For npm/npx-style package selectors:
+
+| Selector | Classification | Reason |
+| --- | --- | --- |
+| `package@1.2.3` | SAFE | Exact package version is reproducible. |
+| bare `package` or `@scope/package` | HIGH | A later resolution can select different package code. |
+| `package@latest` | HIGH | The selector is explicitly mutable. |
+| `package@^1.2.0`, `~1.2.0`, `>=1.2.0`, wildcard | MEDIUM | Resolution can change within the allowed range. |
+| local path, script, binary, unknown executable | REVIEW | npm version-drift rules do not establish update behavior. |
+
+Treat `-y` / `--yes` as context only. It suppresses interactive confirmation but is not a vulnerability by itself.
+
+### Step 4: Recommend remediation without inventing versions
+
+For mutable npm/npx references, recommend pinning to an exact version that the team has actually reviewed and then updating that pin deliberately.
+
+Do not guess the version to pin. If registry lookup is needed, explain that it requires network access and ask before querying it.
+
+Pinning improves reproducibility. It does not establish package provenance, vulnerability status, authorization safety, prompt-injection resistance, or runtime isolation.
+
+### Step 5: Produce a bounded report
+
+Return:
+
+| Config | MCP server | Package/reference | Classification | Why | Recommended next step |
+| --- | --- | --- | --- | --- | --- |
+
+Then state:
+
+- No MCP servers were executed during the audit.
+- Mutable dependency references are review/reproducibility signals, not breach claims.
+- A clean dependency-drift result is not a complete MCP security assessment.
+
+## Examples
+
+### Example 1: Audit before approval
+
+**User:** `Audit this repo's MCP config before we approve it. Do not run any MCP servers.`
+
+**Expected shape:**
+
+```text
+.mcp.json | browser | @example/browser-mcp@latest | HIGH
+Reason: @latest can resolve to different package code later.
+Next step: pin the exact version your team reviews and update it deliberately.
+
+No MCP servers were executed.
+```
+
+### Example 2: Add a CI gate
+
+For GitHub Actions:
+
+```yaml
+- uses: actions/checkout@v4
+- uses: tomelias10/mcp-drift-check@v0
+```
+
+MCP Drift Check can also emit SARIF 2.1.0 for GitHub Code Scanning. The action defaults to workspace-only discovery; machine-wide user-level scanning remains an explicit `scan-all` choice.
+
+## Best Practices
+
+- ✅ Read config text only during discovery and classification.
+- ✅ Keep the default scope to the requested workspace/repository.
+- ✅ Separate reproducibility findings from vulnerability or compromise claims.
+- ✅ Pin only a version the team has actually reviewed.
+- ✅ Keep sensitive config values out of reports and public issues.
+- ❌ Do not execute server commands found in a config to "verify" a static finding.
+- ❌ Do not treat a clean result as a general MCP security guarantee.
+
+## Limitations
+
+- This workflow only covers dependency mutability/review drift for package-backed MCP configuration.
+- It does not assess prompt injection, tool poisoning, OAuth/authorization, server implementation flaws, malware, provenance, or runtime sandboxing.
+- Local executables and non-npm launch paths require separate review.
+- A static config can be reproducible and still unsafe for other reasons.
+
+## Security & Safety Notes
+
+- The default workflow is read-only, local, and workspace-scoped.
+- Never execute discovered MCP server commands during this audit.
+- Never include credentials, tokens, private headers, or secret values in the output.
+- The optional `uvx` path makes a network fetch from the declared GitHub source; obtain user approval before running it.
+- If deeper active testing is requested, stop and establish explicit authorization and scope before any intrusive action.
+
+## Common Pitfalls
+
+- **Problem:** Calling an unpinned dependency a vulnerability.
+  **Solution:** Describe it as a reproducibility/review-drift signal unless separate evidence establishes security impact.
+- **Problem:** Pinning to today's registry version without knowing what was reviewed.
+  **Solution:** Ask for the reviewed version or, with approval, reconstruct relevant package history; do not guess.
+- **Problem:** Treating `-y` as the core finding.
+  **Solution:** Report it only as context; the version selector determines the dependency-drift classification.
+- **Problem:** Scanning user-level MCP configs when the user only asked about one repo.
+  **Solution:** Use `scan-workspace` by default; use `scan-all` only when machine-wide scope is explicit.
+
+## Related Skills
+
+- `@mcp-server-security` - Broader MCP server hardening, authentication, authorization, transport, and runtime controls.
+- `@supply-chain-security` - Broader software supply-chain assessment beyond MCP configuration.
+- `@sast-scanning` - Static application-security analysis for source code rather than MCP launch configuration.
+
+## Additional Resources
+
+- [MCP Drift Check stable v0](https://github.com/tomelias10/mcp-drift-check/tree/v0) - MIT zero-execution scanner, GitHub Action, workspace-scoped mode, and SARIF output.
+- [Public MCP dependency drift examples](https://site-creator-vinext-starter.surfaceproof.workers.dev/research/mcp-dependency-drift) - Commit-specific public configuration examples and methodology limitations.