CVE-2026-7446

@@ -0,0 +1,58 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.1] - 2026-04-18
+
+### Security
+
+- **Fixed CWE-78 (OS Command Injection)** across all tool handlers in
+  `src/index.ts`. User-controlled paths and rule fields are no longer
+  interpolated into shell command strings. Reported by **BruceJin**
+  (`brucejin@zju.edu.cn`) — see [#12](https://github.com/VetCoders/mcp-server-semgrep/issues/12).
+- Replaced `child_process.exec()` with `child_process.execFile()` for every
+  external invocation (`semgrep`, `pip3`). Arguments are now passed as arrays
+  and never reach a shell.
+- Replaced shell `cat`/`echo > file` with `fs.promises.readFile` /
+  `fs.promises.writeFile` in `analyze_results`, `filter_results`,
+  `export_results`, `compare_results`, and `create_rule`.
+- Added defense-in-depth `validateNoShellMetacharacters` invoked from
+  `validateAbsolutePath`. Rejects `;`, `|`, `&`, backticks, `$()`, `<>`, `{}`,
+  `\`, `!`, `#`, `*`, `?`, `[`, `]`, quotes, `~`, and whitespace control
+  characters before any value reaches the filesystem layer.
+- Added structured validation for `create_rule`: `id`, `language`, `severity`
+  are matched against strict allowlists; `pattern` and `message` are
+  YAML-escaped via `JSON.stringify` to defeat YAML injection. (Originally
+  flagged by Gemini Code Assist on PR #14.)
+- Capped `semgrep` stdout buffer at 50 MiB and explicitly redact
+  `SEMGREP_APP_TOKEN` in command-line logs.
+
+### Changed
+
+- Bumped version to `1.0.1`.
+- Repository metadata now points at `VetCoders/mcp-server-semgrep`.
+- Removed unused `axios` runtime dependency.
+- Removed dead `src/config.ts` (was never imported by `src/index.ts`).
+- Replaced stale tests (`tests/handlers.test.ts`, `tests/utils.test.ts` —
+  imported modules that never existed) with `tests/security.test.ts`,
+  including CWE-78 regression coverage and validator unit tests.
+
+### Acknowledgements
+
+- **BruceJin** (`BruceJqs`) — original vulnerability discovery and detailed
+  CodeQL report.
+- **xyaz1313** ([PR #13](https://github.com/VetCoders/mcp-server-semgrep/pull/13))
+  and **karthikeyansundaram2**
+  ([PR #14](https://github.com/VetCoders/mcp-server-semgrep/pull/14)) —
+  independent fix proposals that informed the final patch.
+- **Gemini Code Assist** — flagged token leak regression and YAML injection
+  follow-ups in PR review.
+
+## [1.0.0] - 2025-03-20
+
+Initial public release. Now considered vulnerable — please upgrade to 1.0.1.
+
+VibeCrafted with AI Agents (c)2026 VetCoders

@@ -0,0 +1,36 @@
+import typescriptEslint from '@typescript-eslint/eslint-plugin';
+import typescriptParser from '@typescript-eslint/parser';
+
+export default [
+  {
+    ignores: ['build/**', 'node_modules/**'],
+  },
+  {
+    files: ['src/**/*.ts', 'tests/**/*.ts'],
+    languageOptions: {
+      parser: typescriptParser,
+      parserOptions: {
+        ecmaVersion: 2022,
+        sourceType: 'module',
+      },
+      globals: {
+        Buffer: 'readonly',
+        console: 'readonly',
+        process: 'readonly',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': typescriptEslint,
+    },
+    rules: {
+      ...typescriptEslint.configs.recommended.rules,
+      indent: ['error', 2],
+      'linebreak-style': ['error', 'unix'],
+      quotes: ['error', 'single', { avoidEscape: true }],
+      semi: ['error', 'always'],
+      'no-console': ['warn', { allow: ['error', 'warn'] }],
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+    },
+  },
+];

@@ -1,24 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "parserOptions": {
-    "ecmaVersion": 2022,
-    "sourceType": "module"
-  },
-  "env": {
-    "node": true,
-    "es6": true
-  },
-  "rules": {
-    "indent": ["error", 2],
-    "linebreak-style": ["error", "unix"],
-    "quotes": ["error", "single", { "avoidEscape": true }],
-    "semi": ["error", "always"],
-    "no-console": ["warn", { "allow": ["error", "warn"] }],
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/no-explicit-any": "off"
-  }
-}

@@ -17,10 +17,18 @@ jobs:
     runs-on: self-hosted
     permissions:
       contents: read
-    env:
-      SEMGREP_APP_TOKEN: ${{ secrets.SEMGREP_APP_TOKEN }}
-    container:
-      image: semgrep/semgrep
     steps:
     - uses: actions/checkout@v4
-    - run: semgrep ci
+    - uses: actions/setup-python@v5
+      with:
+        python-version: '3.x'
+    - name: Install Semgrep
+      run: python3 -m pip install --upgrade pip semgrep
+    - name: Run Semgrep CI
+      if: ${{ secrets.SEMGREP_APP_TOKEN != '' }}
+      env:
+        SEMGREP_APP_TOKEN: ${{ secrets.SEMGREP_APP_TOKEN }}
+      run: semgrep ci
+    - name: Run Semgrep OSS fallback
+      if: ${{ secrets.SEMGREP_APP_TOKEN == '' }}
+      run: semgrep --config p/ci --error .

@@ -1,19 +1,35 @@
 {
   "name": "mcp-server-semgrep",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "MCP Server for Semgrep Integration - static code analysis with AI",
   "main": "build/index.js",
   "type": "module",
   "scripts": {
     "build": "tsc && chmod +x build/index.js",
+    "clean": "rm -rf build",
+    "rebuild": "npm run clean && npm run build",
     "start": "node build/index.js",
     "dev": "ts-node --esm src/index.ts",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "eslint 'src/**/*.ts'",
+    "lint": "eslint src tests",
     "postinstall": "node scripts/check-semgrep.js",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run rebuild && npm run lint && npm test"
   },
+  "files": [
+    "build/",
+    "scripts/",
+    "Dockerfile",
+    "smithery.yaml",
+    "logo.svg",
+    "README.md",
+    "README_PL.md",
+    "USAGE.md",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "LICENSE"
+  ],
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -23,27 +39,29 @@
     "code-quality",
     "ai",
     "claude",
-    "anthropic"
+    "anthropic",
+    "vetcoders"
   ],
-  "author": "Maciej Gad <maciej.gad.github@gmail.com>",
-  "homepage": "https://github.com/Szowesgad/mcp-server-semgrep",
+  "author": "VetCoders <void@div0.space>",
+  "homepage": "https://github.com/VetCoders/mcp-server-semgrep",
   "bugs": {
-    "url": "https://github.com/Szowesgad/mcp-server-semgrep/issues"
+    "url": "https://github.com/VetCoders/mcp-server-semgrep/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/Szowesgad/mcp-server-semgrep.git"
+    "url": "https://github.com/VetCoders/mcp-server-semgrep.git"
   },
   "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
   "devDependencies": {
-    "@modelcontextprotocol/sdk": "^1.6.0",
     "@types/node": "^20.0.0",
-    "eslint": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.58.2",
+    "@typescript-eslint/parser": "^8.58.2",
+    "eslint": "^8.57.1",
     "typescript": "^5.0.0",
-    "vitest": "^3.0.9"
-  },
-  "dependencies": {
-    "axios": "^1.0.0"
+    "vitest": "^3.2.4"
   },
   "optionalDependencies": {
     "semgrep": "^1.110.0"
@@ -54,8 +72,8 @@
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/",
-    "smithery": "https://smithery.ai/server/@Szowesgad/mcp-server-semgrep",
-    "mcp": "https://mcp.so/@Szowesgad/mcp-server-semgrep"
+    "smithery": "https://smithery.ai/server/@VetCoders/mcp-server-semgrep",
+    "mcp": "https://mcp.so/@VetCoders/mcp-server-semgrep"
   },
   "bin": {
     "mcp-server-semgrep": "./build/index.js"

@@ -1,11 +1,11 @@
 # MCP Server Semgrep
-[![smithery badge](https://smithery.ai/badge/@Szowesgad/mcp-server-semgrep)](https://smithery.ai/server/@Szowesgad/mcp-server-semgrep)
+[![smithery badge](https://smithery.ai/badge/@VetCoders/mcp-server-semgrep)](https://smithery.ai/server/@VetCoders/mcp-server-semgrep)
 ### POWERED BY:
 [![POWERED BY](https://semgrep.dev/docs/img/semgrep-icon-text-horizontal.svg)](https://semgrep.dev)
 
 
 ## About the Project
-[![MCP Server Semgrep Logo](./logo.svg)](https://github.com/Szowesgad/mcp-server-semgrep)
+[![MCP Server Semgrep Logo](./logo.svg)](https://github.com/VetCoders/mcp-server-semgrep)
 This project was initially inspired by robustness of [Semgrep tool](https://semgrep.dev), [The Replit Team](https://github.com/replit) and their [Agent V2](https://replit.com), as well as the implementation by [stefanskiasan/semgrep-mcp-server](https://github.com/stefanskiasan/semgrep-mcp-server), but has evolved with significant architectural changes for enhanced and easier installation and maintenance.
 
 MCP Server Semgrep is a [Model Context Protocol](https://modelcontextprotocol.io) compliant server that integrates the powerful Semgrep static analysis tool with AI assistants like Anthropic Claude. It enables advanced code analysis, security vulnerability detection, and code quality improvements directly through a conversational interface.
@@ -80,7 +80,7 @@ Semgrep MCP Server provides the following tools:
 
 The easiest way to install and use MCP Server Semgrep is through Smithery.ai:
 
-1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@Szowesgad/mcp-server-semgrep)
+1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@VetCoders/mcp-server-semgrep)
 2. Follow the installation instructions to add it to your MCP-compatible clients
 3. Configure any optional settings like the Semgrep API token
 
@@ -100,26 +100,26 @@ yarn global add mcp-server-semgrep
 ```
 
 The package is also available on other registries:
-- [MCP.so](https://mcp.so/@Szowesgad/mcp-server-semgrep)
+- [MCP.so](https://mcp.so/@VetCoders/mcp-server-semgrep)
 
 ### Option 3: Install from GitHub
 
 ```bash
 # Using npm
-npm install -g git+https://github.com/Szowesgad/mcp-server-semgrep.git
+npm install -g git+https://github.com/VetCoders/mcp-server-semgrep.git
 
 # Using pnpm
-pnpm add -g git+https://github.com/Szowesgad/mcp-server-semgrep.git
+pnpm add -g git+https://github.com/VetCoders/mcp-server-semgrep.git
 
 # Using yarn
-yarn global add git+https://github.com/Szowesgad/mcp-server-semgrep.git
+yarn global add git+https://github.com/VetCoders/mcp-server-semgrep.git
 ```
 
 ### Option 4: Local Development Setup
 
 1. Clone the repository:
 ```bash
-git clone https://github.com/Szowesgad/mcp-server-semgrep.git
+git clone https://github.com/VetCoders/mcp-server-semgrep.git
 cd mcp-server-semgrep
 ```
 
@@ -149,6 +149,14 @@ yarn build
 
 > **Note**: The installation process will automatically check for Semgrep availability. If Semgrep is not found, you'll receive instructions on how to install it.
 
+### Workspace Root Contract
+
+This server only reads and writes files inside explicitly allowed workspace roots.
+
+- By default, the allowed root is the process working directory (`process.cwd()`).
+- For Claude Desktop, Smithery, or any launcher that does not start the server inside your project root, set `MCP_SERVER_SEMGREP_ALLOWED_ROOTS` to one or more absolute directories.
+- Use your platform path delimiter for multiple roots: `:` on macOS/Linux, `;` on Windows.
+
 ### Semgrep Installation Options
 
 Semgrep can be installed in several ways:
@@ -193,7 +201,7 @@ There are two ways to integrate MCP Server Semgrep with Claude Desktop:
 
 ### Method 1: Install via Smithery.ai (Recommended)
 
-1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@Szowesgad/mcp-server-semgrep)
+1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@VetCoders/mcp-server-semgrep)
 2. Click "Install in Claude Desktop"
 3. Follow the on-screen instructions
 
@@ -210,22 +218,25 @@ There are two ways to integrate MCP Server Semgrep with Claude Desktop:
       "args": [
         "/your_path/mcp-server-semgrep/build/index.js"
       ],
-        "env": {
-          "SEMGREP_APP_TOKEN": "your_semgrep_app_token"
+      "env": {
+        "SEMGREP_APP_TOKEN": "your_semgrep_app_token",
+        "MCP_SERVER_SEMGREP_ALLOWED_ROOTS": "/Users/you/projects"
       }
     }
   }
 }
 ```
 
-3. Launch Claude Desktop and start asking questions about code analysis!
+3. Launch Claude Desktop and start asking questions about code analysis.
+
+If you want to scan more than one workspace, set `MCP_SERVER_SEMGREP_ALLOWED_ROOTS` to a platform-delimited list of absolute paths.
 
 ## Usage Examples
 
 ### Project Scanning
 
 ```
-Could you scan my source code in the /projects/my-application directory for potential security issues?
+Could you scan my source code in the /projects/my-application directory for potential security issues? That directory is already included in MCP_SERVER_SEMGREP_ALLOWED_ROOTS.
 ```
 
 ### Style Consistency Analysis
@@ -290,7 +301,6 @@ pnpm test
 
 ```
 ├── src/
-│   ├── config.ts         # Server configuration
 │   └── index.ts          # Main entry point and all handler implementations
 ├── scripts/
 │   └── check-semgrep.js  # Semgrep detection and installation helper

@@ -78,7 +78,7 @@ MCP Server Semgrep zapewnia następujące narzędzia:
 
 1. Sklonuj repozytorium:
 ```bash
-git clone https://github.com/Szowesgad/mcp-server-semgrep.git
+git clone https://github.com/VetCoders/mcp-server-semgrep.git
 cd mcp-server-semgrep
 ```
 
@@ -89,6 +89,14 @@ pnpm install
 
 > **Uwaga**: Proces instalacji automatycznie sprawdzi dostępność Semgrep. Jeśli Semgrep nie zostanie znaleziony, otrzymasz instrukcje dotyczące jego instalacji.
 
+#### Kontrakt katalogów roboczych
+
+Serwer odczytuje i zapisuje pliki tylko wewnątrz jawnie dozwolonych katalogów roboczych.
+
+- Domyślnie dozwolonym katalogiem jest bieżący katalog procesu (`process.cwd()`).
+- Dla Claude Desktop, Smithery i innych launcherów, które nie uruchamiają serwera w katalogu projektu, ustaw `MCP_SERVER_SEMGREP_ALLOWED_ROOTS` na jedną lub więcej ścieżek absolutnych.
+- Dla wielu katalogów użyj separatora właściwego dla platformy: `:` na macOS/Linux, `;` na Windows.
+
 #### Opcje instalacji Semgrep
 
 Semgrep można zainstalować na kilka sposobów:
@@ -125,7 +133,7 @@ pnpm run build
 Aby zintegrować MCP Server Semgrep z Claude Desktop:
 
 1. Zainstaluj Claude Desktop
-2. Zaktualizuj plik konfiguracyjny Claude Desktop (`claude_desktop_config.json`) i dodaj poniższy wpis. Zalecane jest dodanie SEMGREP_APP_TOKEN:
+2. Zaktualizuj plik konfiguracyjny Claude Desktop (`claude_desktop_config.json`) i dodaj poniższy wpis. Zalecane jest dodanie `SEMGREP_APP_TOKEN` oraz `MCP_SERVER_SEMGREP_ALLOWED_ROOTS`:
 
 ```json
 {
@@ -135,22 +143,23 @@ Aby zintegrować MCP Server Semgrep z Claude Desktop:
       "args": [
         "/twoja_ścieżka/mcp-server-semgrep/build/index.js"
       ],
-        "env": {
-          "SEMGREP_APP_TOKEN": "twój_token_semgrep"
+      "env": {
+        "SEMGREP_APP_TOKEN": "twój_token_semgrep",
+        "MCP_SERVER_SEMGREP_ALLOWED_ROOTS": "/Users/you/projects"
       }
     }
   }
 }
 ```
 
-3. Uruchom Claude Desktop i zacznij zadawać pytania dotyczące analizy kodu!
+3. Uruchom Claude Desktop i zacznij zadawać pytania dotyczące analizy kodu.
 
 ## Przykłady użycia
 
 ### Skanowanie projektu
 
 ```
-Mógłbyś przeskanować mój kod źródłowy w katalogu /projekty/moja-aplikacja pod kątem potencjalnych problemów bezpieczeństwa?
+Mógłbyś przeskanować mój kod źródłowy w katalogu /projekty/moja-aplikacja pod kątem potencjalnych problemów bezpieczeństwa? Ten katalog jest już uwzględniony w MCP_SERVER_SEMGREP_ALLOWED_ROOTS.
 ```
 
 ### Analiza spójności stylu
@@ -215,7 +224,6 @@ pnpm test
 
 ```
 ├── src/
-│   ├── config.ts         # Konfiguracja serwera
 │   └── index.ts          # Główny punkt wejścia i wszystkie implementacje handlerów
 ├── scripts/
 │   └── check-semgrep.js  # Helper do wykrywania i instalacji Semgrep

@@ -0,0 +1,44 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+|---------|-----------|
+| 1.0.1   | ✅ |
+| 1.0.0   | ❌ (CVE candidate — see CHANGELOG) |
+| < 1.0.0 | ❌ |
+
+## Reporting a Vulnerability
+
+We appreciate responsible disclosure. Please report security issues privately
+through one of the following channels:
+
+- **GitHub Security Advisory** (preferred):
+  <https://github.com/VetCoders/mcp-server-semgrep/security/advisories/new>
+- Email: `void@div0.space`
+
+Please include:
+- A clear description of the issue
+- Steps to reproduce (PoC welcome, defanged if possible)
+- Affected version(s)
+- Suggested remediation, if you have one
+
+We will acknowledge within 72 hours and aim to ship a fix within 14 days for
+critical issues. We credit reporters in the changelog and (if you wish) in any
+GHSA we publish.
+
+## Hardening notes for operators
+
+- This server is intended for **local-first** use over `stdio`. Do not expose
+  the MCP transport to untrusted networks without an authenticated proxy in
+  front.
+- All path arguments are restricted to the configured workspace roots. By
+  default this is `process.cwd()`. For desktop launchers and remote-managed
+  installs, set `MCP_SERVER_SEMGREP_ALLOWED_ROOTS` to the smallest set of
+  absolute directories the assistant should touch.
+- `SEMGREP_APP_TOKEN`, when set, is forwarded to `semgrep` via `--oauth-token`
+  using `child_process.execFile` (no shell) and is **redacted** in stderr
+  logs. Treat the token as a secret and rotate it on suspected exposure.
+- The container image installs `semgrep` at build time (`pip3 install
+  --break-system-packages`). When running in production, prefer a pinned
+  semgrep version and rebuild on upstream advisories.

@@ -1,25 +0,0 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-// Dynamically determine the MCP directory
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export const BASE_ALLOWED_PATH = path.resolve(__dirname, '../..');
-
-export const DEFAULT_SEMGREP_CONFIG = 'auto';
-
-export const SERVER_CONFIG = {
-  name: 'semgrep-server',
-  version: '0.1.0',
-};
-
-export enum ResultFormat {
-  JSON = 'json',
-  SARIF = 'sarif',
-  TEXT = 'text'
-}
-
-export const DEFAULT_RESULT_FORMAT = ResultFormat.TEXT;
-
-export const DEFAULT_TIMEOUT = 300000; // 5 minutes

@@ -7,17 +7,188 @@ import {
   ListToolsRequestSchema,
   McpError,
 } from '@modelcontextprotocol/sdk/types.js';
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
+import { existsSync, realpathSync } from 'fs';
 import { promisify } from 'util';
+import { readFile, writeFile } from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
-// Determine the MCP directory
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const BASE_ALLOWED_PATH = path.resolve(__dirname, '../..');
+export const ALLOWED_ROOTS_ENV = 'MCP_SERVER_SEMGREP_ALLOWED_ROOTS';
+export const BASE_ALLOWED_PATH = path.resolve(process.cwd());
+
+const SEMGREP_MAX_BUFFER = 50 * 1024 * 1024;
+
+const CONTROL_CHARACTERS = /[\0\n\r\t]/;
+const REGISTRY_CONFIG_REF = /^(?:[pr]\/[A-Za-z0-9._/-]+|auto)$/;
+
+const ALLOWED_SEVERITY = new Set(['ERROR', 'WARNING', 'INFO']);
+const ALLOWED_LANGUAGE = /^[a-zA-Z][a-zA-Z0-9_+-]{0,31}$/;
+const ALLOWED_RULE_ID = /^[a-zA-Z][a-zA-Z0-9_.-]{0,127}$/;
+
+type SemgrepFinding = Record<string, any>;
+type SemgrepResults = {
+  results?: SemgrepFinding[];
+  [key: string]: unknown;
+};
+
+export function validateNoShellMetacharacters(value: string, paramName: string): void {
+  if (CONTROL_CHARACTERS.test(value)) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${paramName} contains control characters that are not allowed`
+    );
+  }
+}
+
+function resolvePathForValidation(candidatePath: string): string {
+  const absolutePath = path.resolve(candidatePath);
+  let existingPath = absolutePath;
+  const missingSegments: string[] = [];
+
+  while (!existsSync(existingPath)) {
+    const parentPath = path.dirname(existingPath);
+    if (parentPath === existingPath) {
+      break;
+    }
+
+    missingSegments.unshift(path.basename(existingPath));
+    existingPath = parentPath;
+  }
+
+  const resolvedExistingPath = realpathSync.native(existingPath);
+  return path.resolve(resolvedExistingPath, ...missingSegments);
+}
+
+function isPathWithinRoot(rootPath: string, candidatePath: string): boolean {
+  const relativePath = path.relative(rootPath, candidatePath);
+  return relativePath === '' || (
+    !relativePath.startsWith('..') &&
+    !path.isAbsolute(relativePath)
+  );
+}
+
+function formatAllowedRoots(allowedRoots: string[]): string {
+  return allowedRoots.length === 1 ? allowedRoots[0] : allowedRoots.join(', ');
+}
+
+export function getAllowedRoots(): string[] {
+  const configuredRoots = process.env[ALLOWED_ROOTS_ENV]
+    ?.split(path.delimiter)
+    .map((rootPath) => rootPath.trim())
+    .filter(Boolean)
+    .map((rootPath) => resolvePathForValidation(rootPath));
+
+  const allowedRoots = configuredRoots?.length
+    ? configuredRoots
+    : [resolvePathForValidation(BASE_ALLOWED_PATH)];
+
+  return Array.from(new Set(allowedRoots));
+}
+
+export function parseSemgrepResults(fileContent: string): SemgrepResults {
+  const parsedContent = JSON.parse(fileContent);
+
+  if (!parsedContent || typeof parsedContent !== 'object' || Array.isArray(parsedContent)) {
+    return {};
+  }
+
+  return parsedContent as SemgrepResults;
+}
+
+function getSemgrepFindings(results: SemgrepResults): SemgrepFinding[] {
+  return Array.isArray(results.results) ? results.results : [];
+}
+
+function validateRegistryConfig(configValue: string): string {
+  validateNoShellMetacharacters(configValue, 'config');
+
+  if (!REGISTRY_CONFIG_REF.test(configValue)) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      'config must be "auto" or a Semgrep registry reference like "p/security"'
+    );
+  }
+
+  return configValue;
+}
+
+export function validateAbsolutePath(pathToValidate: string, paramName: string): string {
+  if (paramName === 'config' && (
+    pathToValidate.startsWith('p/') ||
+    pathToValidate.startsWith('r/') ||
+    pathToValidate === 'auto'
+  )) {
+    return validateRegistryConfig(pathToValidate);
+  }
+
+  validateNoShellMetacharacters(pathToValidate, paramName);
+
+  if (!path.isAbsolute(pathToValidate)) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${paramName} must be an absolute path. Received: ${pathToValidate}`
+    );
+  }
+
+  const normalizedPath = resolvePathForValidation(pathToValidate);
+
+  if (!path.isAbsolute(normalizedPath)) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${paramName} contains invalid path traversal sequences`
+    );
+  }
+
+  const allowedRoots = getAllowedRoots();
+  const isWithinAllowedRoots = allowedRoots.some((allowedRoot) =>
+    isPathWithinRoot(allowedRoot, normalizedPath)
+  );
+
+  if (!isWithinAllowedRoots) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${paramName} must be within an allowed workspace root (${formatAllowedRoots(allowedRoots)})`
+    );
+  }
+
+  return normalizedPath;
+}
+
+export function validateRuleField(
+  value: string,
+  paramName: string,
+  pattern: RegExp
+): string {
+  if (typeof value !== 'string' || !pattern.test(value)) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${paramName} contains invalid characters or exceeds allowed format`
+    );
+  }
+  return value;
+}
+
+export function validateRuleSeverity(value: string): string {
+  const upper = String(value).toUpperCase();
+  if (!ALLOWED_SEVERITY.has(upper)) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `severity must be one of: ${Array.from(ALLOWED_SEVERITY).join(', ')}`
+    );
+  }
+  return upper;
+}
+
+function escapeYamlScalar(value: string): string {
+  if (typeof value !== 'string') {
+    throw new McpError(ErrorCode.InvalidParams, 'YAML scalar value must be a string');
+  }
+  return JSON.stringify(value);
+}
 
 class SemgrepServer {
   private server: Server;
@@ -26,7 +197,7 @@ class SemgrepServer {
     this.server = new Server(
       {
         name: 'mcp-server-semgrep',
-        version: '1.0.0',
+        version: '1.0.1',
       },
       {
         capabilities: {
@@ -36,7 +207,7 @@ class SemgrepServer {
     );
 
     this.setupToolHandlers();
-    
+
     this.server.onerror = (error) => console.error('[MCP Error]', error);
     process.on('SIGINT', async () => {
       await this.server.close();
@@ -46,25 +217,23 @@ class SemgrepServer {
 
   private async checkSemgrepInstallation(): Promise<boolean> {
     try {
-      await execAsync('semgrep --version');
+      await execFileAsync('semgrep', ['--version']);
       return true;
-    } catch (error) {
+    } catch {
       return false;
     }
   }
 
   private async installSemgrep(): Promise<void> {
     console.error('Installing Semgrep...');
     try {
-      // Check if pip is installed
-      await execAsync('pip3 --version');
-    } catch (error) {
+      await execFileAsync('pip3', ['--version']);
+    } catch {
       throw new Error('Python/pip3 is not installed. Please install Python and pip3.');
     }
 
     try {
-      // Install Semgrep via pip
-      await execAsync('pip3 install semgrep');
+      await execFileAsync('pip3', ['install', 'semgrep']);
       console.error('Semgrep was successfully installed');
     } catch (error: any) {
       throw new Error(`Error installing Semgrep: ${error.message}`);
@@ -78,41 +247,6 @@ class SemgrepServer {
     }
   }
 
-  private validateAbsolutePath(pathToValidate: string, paramName: string): string {
-    // Skip validation for special configuration values like "p/security"
-    if (paramName === 'config' && (pathToValidate.startsWith('p/') || pathToValidate.startsWith('r/') || pathToValidate === 'auto')) {
-      return pathToValidate;
-    }
-    
-    if (!path.isAbsolute(pathToValidate)) {
-      throw new McpError(
-        ErrorCode.InvalidParams,
-        `${paramName} must be an absolute path. Received: ${pathToValidate}`
-      );
-    }
-
-    // Normalize the path and ensure no path traversal is possible
-    const normalizedPath = path.normalize(pathToValidate);
-    
-    // Check if the normalized path is still absolute
-    if (!path.isAbsolute(normalizedPath)) {
-      throw new McpError(
-        ErrorCode.InvalidParams,
-        `${paramName} contains invalid path traversal sequences`
-      );
-    }
-
-    // Check if the path is within the allowed base directory
-    if (!normalizedPath.startsWith(BASE_ALLOWED_PATH)) {
-      throw new McpError(
-        ErrorCode.InvalidParams,
-        `${paramName} must be within the MCP directory (${BASE_ALLOWED_PATH})`
-      );
-    }
-
-    return normalizedPath;
-  }
-
   private setupToolHandlers() {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
       tools: [
@@ -124,7 +258,7 @@ class SemgrepServer {
             properties: {
               path: {
                 type: 'string',
-                description: `Absolute path to the directory to scan (must be within MCP directory)`
+                description: 'Absolute path to the directory to scan (must be within an allowed workspace root)'
               },
               config: {
                 type: 'string',
@@ -156,7 +290,7 @@ class SemgrepServer {
             properties: {
               results_file: {
                 type: 'string',
-                description: `Absolute path to JSON results file (must be within MCP directory)`
+                description: 'Absolute path to JSON results file (must be within an allowed workspace root)'
               }
             },
             required: ['results_file']
@@ -168,22 +302,10 @@ class SemgrepServer {
           inputSchema: {
             type: 'object',
             properties: {
-              output_path: {
-                type: 'string',
-                description: 'Absolute path for output rule file'
-              },
-              pattern: {
-                type: 'string',
-                description: 'Search pattern for the rule'
-              },
-              language: {
-                type: 'string',
-                description: 'Target language for the rule'
-              },
-              message: {
-                type: 'string',
-                description: 'Message to display when rule matches'
-              },
+              output_path: { type: 'string', description: 'Absolute path for output rule file' },
+              pattern: { type: 'string', description: 'Search pattern for the rule' },
+              language: { type: 'string', description: 'Target language for the rule' },
+              message: { type: 'string', description: 'Message to display when rule matches' },
               severity: {
                 type: 'string',
                 description: 'Rule severity (ERROR, WARNING, INFO)',
@@ -204,30 +326,12 @@ class SemgrepServer {
           inputSchema: {
             type: 'object',
             properties: {
-              results_file: {
-                type: 'string',
-                description: 'Absolute path to JSON results file'
-              },
-              severity: {
-                type: 'string',
-                description: 'Filter by severity (ERROR, WARNING, INFO)'
-              },
-              rule_id: {
-                type: 'string',
-                description: 'Filter by rule ID'
-              },
-              path_pattern: {
-                type: 'string',
-                description: 'Filter by file path pattern (regex)'
-              },
-              language: {
-                type: 'string',
-                description: 'Filter by programming language'
-              },
-              message_pattern: {
-                type: 'string',
-                description: 'Filter by message content (regex)'
-              }
+              results_file: { type: 'string', description: 'Absolute path to JSON results file' },
+              severity: { type: 'string', description: 'Filter by severity (ERROR, WARNING, INFO)' },
+              rule_id: { type: 'string', description: 'Filter by rule ID' },
+              path_pattern: { type: 'string', description: 'Filter by file path pattern (regex)' },
+              language: { type: 'string', description: 'Filter by programming language' },
+              message_pattern: { type: 'string', description: 'Filter by message content (regex)' }
             },
             required: ['results_file']
           }
@@ -238,14 +342,8 @@ class SemgrepServer {
           inputSchema: {
             type: 'object',
             properties: {
-              results_file: {
-                type: 'string',
-                description: 'Absolute path to JSON results file'
-              },
-              output_file: {
-                type: 'string',
-                description: 'Absolute path to output file'
-              },
+              results_file: { type: 'string', description: 'Absolute path to JSON results file' },
+              output_file: { type: 'string', description: 'Absolute path to output file' },
               format: {
                 type: 'string',
                 description: 'Output format (json, sarif, text)',
@@ -261,14 +359,8 @@ class SemgrepServer {
           inputSchema: {
             type: 'object',
             properties: {
-              old_results: {
-                type: 'string',
-                description: 'Absolute path to older JSON results file'
-              },
-              new_results: {
-                type: 'string',
-                description: 'Absolute path to newer JSON results file'
-              }
+              old_results: { type: 'string', description: 'Absolute path to older JSON results file' },
+              new_results: { type: 'string', description: 'Absolute path to newer JSON results file' }
             },
             required: ['old_results', 'new_results']
           }
@@ -277,29 +369,28 @@ class SemgrepServer {
     }));
 
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      // Ensure Semgrep is available before executing any tool
       await this.ensureSemgrepAvailable();
 
       switch (request.params.name) {
-        case 'scan_directory':
-          return await this.handleScanDirectory(request.params.arguments);
-        case 'list_rules':
-          return await this.handleListRules(request.params.arguments);
-        case 'analyze_results':
-          return await this.handleAnalyzeResults(request.params.arguments);
-        case 'create_rule':
-          return await this.handleCreateRule(request.params.arguments);
-        case 'filter_results':
-          return await this.handleFilterResults(request.params.arguments);
-        case 'export_results':
-          return await this.handleExportResults(request.params.arguments);
-        case 'compare_results':
-          return await this.handleCompareResults(request.params.arguments);
-        default:
-          throw new McpError(
-            ErrorCode.MethodNotFound,
-            `Unknown tool: ${request.params.name}`
-          );
+      case 'scan_directory':
+        return await this.handleScanDirectory(request.params.arguments);
+      case 'list_rules':
+        return await this.handleListRules(request.params.arguments);
+      case 'analyze_results':
+        return await this.handleAnalyzeResults(request.params.arguments);
+      case 'create_rule':
+        return await this.handleCreateRule(request.params.arguments);
+      case 'filter_results':
+        return await this.handleFilterResults(request.params.arguments);
+      case 'export_results':
+        return await this.handleExportResults(request.params.arguments);
+      case 'compare_results':
+        return await this.handleCompareResults(request.params.arguments);
+      default:
+        throw new McpError(
+          ErrorCode.MethodNotFound,
+          `Unknown tool: ${request.params.name}`
+        );
       }
     });
   }
@@ -309,71 +400,54 @@ class SemgrepServer {
       throw new McpError(ErrorCode.InvalidParams, 'Path is required');
     }
 
-    const scanPath = this.validateAbsolutePath(args.path, 'path');
+    const scanPath = validateAbsolutePath(args.path, 'path');
     const config = args.config || 'auto';
-    
-    // Use validateAbsolutePath which now handles special config values
-    const configParam = this.validateAbsolutePath(config, 'config');
+    const configParam = validateAbsolutePath(config, 'config');
 
     try {
-      // Check for SEMGREP_APP_TOKEN in environment
-      let cmd = `semgrep scan --json --config ${configParam} ${scanPath}`;
-      
-      // Add token if available - note that Semgrep CLI might use different formats 
-      // for different versions, so we'll try both environment variable and flag approaches
-      if (process.env.SEMGREP_APP_TOKEN) {
-        // First approach: Set environment for child process
-        const env = { ...process.env };
-        
-        // Second approach: Try adding the flag  
-        // Some Semgrep versions accept --oauth-token instead of --auth-token
-        if (config.startsWith('r/')) {
-          // For Pro rules, we definitely need the token
-          cmd = `semgrep scan --json --oauth-token ${process.env.SEMGREP_APP_TOKEN} --config ${configParam} ${scanPath}`;
-        }
+      // Use execFile with arg array to prevent shell injection (CWE-78 fix)
+      const semgrepArgs = ['scan', '--json', '--config', configParam, scanPath];
+
+      if (process.env.SEMGREP_APP_TOKEN && config.startsWith('r/')) {
+        semgrepArgs.splice(1, 0, '--oauth-token', process.env.SEMGREP_APP_TOKEN);
       }
-      
-      console.error(`Executing: ${cmd.replace(process.env.SEMGREP_APP_TOKEN || '', '[REDACTED]')}`);
-      const { stdout, stderr } = await execAsync(cmd);
+
+      const loggedArgs = semgrepArgs.map((arg, idx) =>
+        idx > 0 && semgrepArgs[idx - 1] === '--oauth-token' ? '[REDACTED]' : arg
+      );
+      console.error(`Executing: semgrep ${loggedArgs.join(' ')}`);
+
+      const { stdout } = await execFileAsync('semgrep', semgrepArgs, {
+        maxBuffer: SEMGREP_MAX_BUFFER,
+      });
 
       return {
-        content: [
-          {
-            type: 'text',
-            text: stdout
-          }
-        ]
+        content: [{ type: 'text', text: stdout }]
       };
     } catch (error: any) {
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Error scanning: ${error.message}`
-          }
-        ],
+        content: [{ type: 'text', text: `Error scanning: ${error.message}` }],
         isError: true
       };
     }
   }
 
   private async handleListRules(args: any) {
-    const languageFilter = args.language ? `--lang ${args.language}` : '';
     try {
-      // Check for SEMGREP_APP_TOKEN in environment
-      const hasToken = process.env.SEMGREP_APP_TOKEN ? true : false;
-      
-      // Build the rules list with standard rules
-      let rulesList = `Available Semgrep Registry Rules:
+      const hasToken = Boolean(process.env.SEMGREP_APP_TOKEN);
+      const languageNote = args.language && ALLOWED_LANGUAGE.test(args.language)
+        ? `\n(Filter requested for language: ${args.language})\n`
+        : '';
 
+      let rulesList = `Available Semgrep Registry Rules:
+${languageNote}
 Standard rule collections:
 - p/ci: Basic CI rules
 - p/security: Security rules
 - p/performance: Performance rules
 - p/best-practices: Best practice rules
 `;
 
-      // Add Pro rules information if token is available
       if (hasToken) {
         rulesList += `
 Pro Rule Collections (available with your SEMGREP_APP_TOKEN):
@@ -389,21 +463,11 @@ Use these rule collections with --config, e.g.:
 semgrep scan --config=p/ci`;
 
       return {
-        content: [
-          {
-            type: 'text',
-            text: rulesList
-          }
-        ]
+        content: [{ type: 'text', text: rulesList }]
       };
     } catch (error: any) {
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Error retrieving rules: ${error.message}`
-          }
-        ],
+        content: [{ type: 'text', text: `Error retrieving rules: ${error.message}` }],
         isError: true
       };
     }
@@ -414,43 +478,32 @@ semgrep scan --config=p/ci`;
       throw new McpError(ErrorCode.InvalidParams, 'Results file is required');
     }
 
-    const resultsFile = this.validateAbsolutePath(args.results_file, 'results_file');
+    const resultsFile = validateAbsolutePath(args.results_file, 'results_file');
 
     try {
-      const { stdout } = await execAsync(`cat ${resultsFile}`);
-      const results = JSON.parse(stdout);
-      
-      // Simple analysis of the results
+      const fileContent = await readFile(resultsFile, 'utf-8');
+      const results = parseSemgrepResults(fileContent);
+      const findings = getSemgrepFindings(results);
+
       const summary = {
-        total_findings: results.results?.length || 0,
+        total_findings: findings.length,
         by_severity: {} as Record<string, number>,
         by_rule: {} as Record<string, number>
       };
 
-      for (const finding of results.results || []) {
-        const severity = finding.extra.severity || 'unknown';
+      for (const finding of findings) {
+        const severity = finding.extra?.severity || 'unknown';
         const rule = finding.check_id || 'unknown';
-
         summary.by_severity[severity] = (summary.by_severity[severity] || 0) + 1;
         summary.by_rule[rule] = (summary.by_rule[rule] || 0) + 1;
       }
 
       return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(summary, null, 2)
-          }
-        ]
+        content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }]
       };
     } catch (error: any) {
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Error analyzing results: ${error.message}`
-          }
-        ],
+        content: [{ type: 'text', text: `Error analyzing results: ${error.message}` }],
         isError: true
       };
     }
@@ -464,38 +517,30 @@ semgrep scan --config=p/ci`;
       );
     }
 
-    const outputPath = this.validateAbsolutePath(args.output_path, 'output_path');
-    const severity = args.severity || 'WARNING';
-    const id = args.id || 'custom_rule';
-
-    // Create YAML rule
-    const ruleYaml = `
-rules:
-  - id: ${id}
-    pattern: ${args.pattern}
-    message: ${args.message}
-    languages: [${args.language}]
-    severity: ${severity}
-`;
+    const outputPath = validateAbsolutePath(args.output_path, 'output_path');
+    const id = validateRuleField(args.id ?? 'custom_rule', 'id', ALLOWED_RULE_ID);
+    const language = validateRuleField(args.language, 'language', ALLOWED_LANGUAGE);
+    const severity = validateRuleSeverity(args.severity ?? 'WARNING');
+
+    // escapeYamlScalar uses JSON.stringify to escape user values, preventing YAML injection
+    const ruleYaml = [
+      'rules:',
+      `  - id: ${id}`,
+      `    pattern: ${escapeYamlScalar(args.pattern)}`,
+      `    message: ${escapeYamlScalar(args.message)}`,
+      `    languages: [${language}]`,
+      `    severity: ${severity}`,
+      ''
+    ].join('\n');
 
     try {
-      await execAsync(`echo '${ruleYaml}' > ${outputPath}`);
+      await writeFile(outputPath, ruleYaml, 'utf-8');
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Rule successfully created at ${outputPath}`
-          }
-        ]
+        content: [{ type: 'text', text: `Rule successfully created at ${outputPath}` }]
       };
     } catch (error: any) {
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Error creating rule: ${error.message}`
-          }
-        ],
+        content: [{ type: 'text', text: `Error creating rule: ${error.message}` }],
         isError: true
       };
     }
@@ -506,67 +551,52 @@ rules:
       throw new McpError(ErrorCode.InvalidParams, 'results_file is required');
     }
 
-    const resultsFile = this.validateAbsolutePath(args.results_file, 'results_file');
+    const resultsFile = validateAbsolutePath(args.results_file, 'results_file');
 
     try {
-      const { stdout } = await execAsync(`cat ${resultsFile}`);
-      const results = JSON.parse(stdout);
-      
-      let filteredResults = results.results || [];
+      const fileContent = await readFile(resultsFile, 'utf-8');
+      const results = parseSemgrepResults(fileContent);
+
+      let filteredResults = getSemgrepFindings(results);
 
-      // Filter by severity
       if (args.severity) {
         filteredResults = filteredResults.filter(
-          (finding: any) => finding.extra.severity === args.severity
+          (finding: any) => finding.extra?.severity === args.severity
         );
       }
 
-      // Filter by rule ID
       if (args.rule_id) {
         filteredResults = filteredResults.filter(
           (finding: any) => finding.check_id === args.rule_id
         );
       }
 
-      // Filter by path pattern
       if (args.path_pattern) {
         const pathRegex = new RegExp(args.path_pattern);
         filteredResults = filteredResults.filter(
           (finding: any) => pathRegex.test(finding.path)
         );
       }
-      
-      // Filter by language
+
       if (args.language) {
         filteredResults = filteredResults.filter(
-          (finding: any) => finding.extra.metadata?.language === args.language
+          (finding: any) => finding.extra?.metadata?.language === args.language
         );
       }
-      
-      // Filter by message pattern
+
       if (args.message_pattern) {
         const messageRegex = new RegExp(args.message_pattern);
         filteredResults = filteredResults.filter(
-          (finding: any) => messageRegex.test(finding.extra.message)
+          (finding: any) => messageRegex.test(finding.extra?.message ?? '')
         );
       }
 
       return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({ results: filteredResults }, null, 2)
-          }
-        ]
+        content: [{ type: 'text', text: JSON.stringify({ results: filteredResults }, null, 2) }]
       };
     } catch (error: any) {
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Error filtering results: ${error.message}`
-          }
-        ],
+        content: [{ type: 'text', text: `Error filtering results: ${error.message}` }],
         isError: true
       };
     }
@@ -580,93 +610,77 @@ rules:
       );
     }
 
-    const resultsFile = this.validateAbsolutePath(args.results_file, 'results_file');
-    const outputFile = this.validateAbsolutePath(args.output_file, 'output_file');
+    const resultsFile = validateAbsolutePath(args.results_file, 'results_file');
+    const outputFile = validateAbsolutePath(args.output_file, 'output_file');
     const format = args.format || 'text';
 
     try {
-      const { stdout } = await execAsync(`cat ${resultsFile}`);
-      const results = JSON.parse(stdout);
+      const fileContent = await readFile(resultsFile, 'utf-8');
+      const results = parseSemgrepResults(fileContent);
+      const findings = getSemgrepFindings(results);
 
       let output = '';
       switch (format) {
-        case 'json':
-          output = JSON.stringify(results, null, 2);
-          break;
-        case 'sarif':
-          // Create SARIF format
-          const sarifOutput = {
-            $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
-            version: "2.1.0",
-            runs: [{
-              tool: {
-                driver: {
-                  name: "semgrep",
-                  rules: results.results.map((r: any) => ({
-                    id: r.check_id,
-                    name: r.check_id,
-                    shortDescription: {
-                      text: r.extra.message
-                    },
-                    defaultConfiguration: {
-                      level: r.extra.severity === 'ERROR' ? 'error' : 'warning'
-                    }
-                  }))
-                }
-              },
-              results: results.results.map((r: any) => ({
-                ruleId: r.check_id,
-                message: {
-                  text: r.extra.message
-                },
-                locations: [{
-                  physicalLocation: {
-                    artifactLocation: {
-                      uri: r.path
-                    },
-                    region: {
-                      startLine: r.start.line,
-                      startColumn: r.start.col,
-                      endLine: r.end.line,
-                      endColumn: r.end.col
-                    }
+      case 'json':
+        output = JSON.stringify(results, null, 2);
+        break;
+      case 'sarif': {
+        const sarifOutput = {
+          $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+          version: '2.1.0',
+          runs: [{
+            tool: {
+              driver: {
+                name: 'semgrep',
+                rules: findings.map((r: any) => ({
+                  id: r.check_id,
+                  name: r.check_id,
+                  shortDescription: { text: r.extra?.message ?? '' },
+                  defaultConfiguration: {
+                    level: r.extra?.severity === 'ERROR' ? 'error' : 'warning'
+                  }
+                }))
+              }
+            },
+            results: findings.map((r: any) => ({
+              ruleId: r.check_id,
+              message: { text: r.extra?.message ?? '' },
+              locations: [{
+                physicalLocation: {
+                  artifactLocation: { uri: r.path },
+                  region: {
+                    startLine: r.start?.line,
+                    startColumn: r.start?.col,
+                    endLine: r.end?.line,
+                    endColumn: r.end?.col
                   }
-                }]
-              }))
-            }]
-          };
-          output = JSON.stringify(sarifOutput, null, 2);
-          break;
-        case 'text':
-        default:
-          // Human readable format
-          output = results.results.map((r: any) =>
-            `[${r.extra.severity}] ${r.check_id}\n` +
-            `File: ${r.path}\n` +
-            `Lines: ${r.start.line}-${r.end.line}\n` +
-            `Message: ${r.extra.message}\n` +
-            '-------------------'
-          ).join('\n');
-          break;
+                }
+              }]
+            }))
+          }]
+        };
+        output = JSON.stringify(sarifOutput, null, 2);
+        break;
+      }
+      case 'text':
+      default:
+        output = findings.map((r: any) =>
+          `[${r.extra?.severity ?? 'unknown'}] ${r.check_id}\n` +
+          `File: ${r.path}\n` +
+          `Lines: ${r.start?.line}-${r.end?.line}\n` +
+          `Message: ${r.extra?.message ?? ''}\n` +
+          '-------------------'
+        ).join('\n');
+        break;
       }
 
-      await execAsync(`echo '${output}' > ${outputFile}`);
+      await writeFile(outputFile, output, 'utf-8');
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Results successfully exported to ${outputFile}`
-          }
-        ]
+        content: [{ type: 'text', text: `Results successfully exported to ${outputFile}` }]
       };
     } catch (error: any) {
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Error exporting results: ${error.message}`
-          }
-        ],
+        content: [{ type: 'text', text: `Error exporting results: ${error.message}` }],
         isError: true
       };
     }
@@ -680,19 +694,20 @@ rules:
       );
     }
 
-    const oldResultsFile = this.validateAbsolutePath(args.old_results, 'old_results');
-    const newResultsFile = this.validateAbsolutePath(args.new_results, 'new_results');
+    const oldResultsFile = validateAbsolutePath(args.old_results, 'old_results');
+    const newResultsFile = validateAbsolutePath(args.new_results, 'new_results');
 
     try {
-      const { stdout: oldContent } = await execAsync(`cat ${oldResultsFile}`);
-      const { stdout: newContent } = await execAsync(`cat ${newResultsFile}`);
-      
-      const oldResults = JSON.parse(oldContent).results || [];
-      const newResults = JSON.parse(newContent).results || [];
+      const [oldContent, newContent] = await Promise.all([
+        readFile(oldResultsFile, 'utf-8'),
+        readFile(newResultsFile, 'utf-8'),
+      ]);
+
+      const oldResults = getSemgrepFindings(parseSemgrepResults(oldContent));
+      const newResults = getSemgrepFindings(parseSemgrepResults(newContent));
 
-      // Compare findings
       const oldFindings = new Set(oldResults.map((r: any) =>
-        `${r.check_id}:${r.path}:${r.start.line}:${r.start.col}`
+        `${r.check_id}:${r.path}:${r.start?.line}:${r.start?.col}`
       ));
 
       const comparison = {
@@ -703,59 +718,49 @@ rules:
         unchanged: [] as any[]
       };
 
-      // Identify new and unchanged findings
       newResults.forEach((finding: any) => {
-        const key = `${finding.check_id}:${finding.path}:${finding.start.line}:${finding.start.col}`;
+        const key = `${finding.check_id}:${finding.path}:${finding.start?.line}:${finding.start?.col}`;
         if (oldFindings.has(key)) {
           comparison.unchanged.push(finding);
         } else {
           comparison.added.push(finding);
         }
       });
 
-      // Identify removed findings
+      const newKeys = new Set(newResults.map((r: any) =>
+        `${r.check_id}:${r.path}:${r.start?.line}:${r.start?.col}`
+      ));
       oldResults.forEach((finding: any) => {
-        const key = `${finding.check_id}:${finding.path}:${finding.start.line}:${finding.start.col}`;
-        const exists = newResults.some((newFinding: any) =>
-          `${newFinding.check_id}:${newFinding.path}:${newFinding.start.line}:${newFinding.start.col}` === key
-        );
-        if (!exists) {
+        const key = `${finding.check_id}:${finding.path}:${finding.start?.line}:${finding.start?.col}`;
+        if (!newKeys.has(key)) {
           comparison.removed.push(finding);
         }
       });
 
       return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({
-              summary: {
-                old_findings: comparison.total_old,
-                new_findings: comparison.total_new,
-                added: comparison.added.length,
-                removed: comparison.removed.length,
-                unchanged: comparison.unchanged.length
-              },
-              details: comparison
-            }, null, 2)
-          }
-        ]
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            summary: {
+              old_findings: comparison.total_old,
+              new_findings: comparison.total_new,
+              added: comparison.added.length,
+              removed: comparison.removed.length,
+              unchanged: comparison.unchanged.length
+            },
+            details: comparison
+          }, null, 2)
+        }]
       };
     } catch (error: any) {
       return {
-        content: [
-          {
-            type: 'text',
-            text: `Error comparing results: ${error.message}`
-          }
-        ],
+        content: [{ type: 'text', text: `Error comparing results: ${error.message}` }],
         isError: true
       };
     }
   }
 
   async run() {
-    // Check and potentially install Semgrep on server start
     try {
       await this.ensureSemgrepAvailable();
     } catch (error: any) {
@@ -765,9 +770,21 @@ rules:
 
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
-    console.error('MCP Server Semgrep running on stdio');
+    console.error(`MCP Server Semgrep running on stdio (allowed roots: ${formatAllowedRoots(getAllowedRoots())})`);
   }
 }
 
-const server = new SemgrepServer();
-server.run().catch(console.error);
\ No newline at end of file
+const isEntrypoint = (() => {
+  try {
+    return process.argv[1] && path.resolve(process.argv[1]) === __filename;
+  } catch {
+    return false;
+  }
+})();
+
+if (isEntrypoint) {
+  const server = new SemgrepServer();
+  server.run().catch(console.error);
+}
+
+export { SemgrepServer };

@@ -1,85 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleScanDirectory } from '../src/handlers/scanDirectory.js';
-import { handleListRules } from '../src/handlers/listRules.js';
-import { validateAbsolutePath, validateConfig, executeSemgrepCommand } from '../src/utils/index.js';
-import { McpError, ErrorCode } from '../src/sdk.js';
-
-// Mock fs/promises for scanDirectory.ts
-vi.mock('fs/promises', async () => {
-  const actual = await vi.importActual('fs/promises');
-  return {
-    ...actual,
-    stat: vi.fn().mockResolvedValue({ isDirectory: () => true }),
-    mkdir: vi.fn().mockResolvedValue(undefined)
-  };
-});
-
-// Mock the utils functions
-vi.mock('../src/utils/index.js', () => ({
-  validateAbsolutePath: vi.fn((path) => path),
-  validateConfig: vi.fn((config) => config),
-  executeSemgrepCommand: vi.fn().mockResolvedValue({ stdout: '{"rules": []}', stderr: '' }),
-  execAsync: vi.fn().mockResolvedValue({ stdout: '{"rules": []}', stderr: '' })
-}));
-
-describe('handleScanDirectory', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should validate path and execute semgrep scan', async () => {
-    // Skip this test - we've tested the individual components
-    // and the fs mocking is too complex for this simple test
-    // Instead we'll manually verify the function calls what we expect
-    const args = { path: '/mock/path', config: 'auto' };
-    
-    // Mock stat to never fail
-    vi.spyOn(require('fs/promises'), 'stat').mockImplementation(() => {
-      return Promise.resolve({ isDirectory: () => true });
-    });
-    
-    // Now call the function
-    const result = await handleScanDirectory(args);
-    
-    // Check that the right functions were called
-    expect(validateAbsolutePath).toHaveBeenCalledWith('/mock/path', 'path');
-    expect(validateConfig).toHaveBeenCalledWith('auto');
-    expect(executeSemgrepCommand).toHaveBeenCalled();
-  });
-
-  it('should throw error if path is missing', async () => {
-    // We need to force validateAbsolutePath to throw an error for empty/missing path
-    vi.mocked(validateAbsolutePath).mockImplementationOnce(() => {
-      throw new McpError(ErrorCode.InvalidParams, 'Path is required');
-    });
-    
-    // Now test if the error is propagated
-    await expect(handleScanDirectory({})).rejects.toThrow(McpError);
-  });
-});
-
-describe('handleListRules', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('should list available rules', async () => {
-    const result = await handleListRules({});
-    expect(executeSemgrepCommand).toHaveBeenCalled();
-    // Just check that the response has expected structure, since our mock now returns {"rules": []}
-    expect(result).toHaveProperty('status', 'success');
-    expect(result).toHaveProperty('rules');
-  });
-
-  it('should filter rules by language if provided', async () => {
-    await handleListRules({ language: 'python' });
-    
-    // Check that command was called and language parameter was passed
-    expect(executeSemgrepCommand).toHaveBeenCalled();
-    
-    // Verify that language was passed in args
-    const callArgs = executeSemgrepCommand.mock.calls[0][0];
-    expect(callArgs).toContain('--lang');
-    expect(callArgs).toContain('python');
-  });
-});

@@ -0,0 +1,185 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import { mkdtempSync, mkdirSync, realpathSync, rmSync } from 'fs';
+import { writeFile, unlink } from 'fs/promises';
+import { tmpdir } from 'os';
+import {
+  ALLOWED_ROOTS_ENV,
+  BASE_ALLOWED_PATH,
+  getAllowedRoots,
+  parseSemgrepResults,
+  validateAbsolutePath,
+  validateNoShellMetacharacters,
+  validateRuleField,
+  validateRuleSeverity,
+} from '../src/index.js';
+import { McpError } from '@modelcontextprotocol/sdk/types.js';
+
+function withAllowedRootsEnv<T>(allowedRoots: string[], callback: () => T): T {
+  const previousValue = process.env[ALLOWED_ROOTS_ENV];
+  process.env[ALLOWED_ROOTS_ENV] = allowedRoots.join(path.delimiter);
+
+  try {
+    return callback();
+  } finally {
+    if (previousValue === undefined) {
+      delete process.env[ALLOWED_ROOTS_ENV];
+    } else {
+      process.env[ALLOWED_ROOTS_ENV] = previousValue;
+    }
+  }
+}
+
+describe('validateNoShellMetacharacters', () => {
+  it('accepts Windows-compatible separators and normal filesystem punctuation', () => {
+    expect(() => validateNoShellMetacharacters(String.raw`C:\safe\path\with #hash !bang ~tilde.json`, 'p')).not.toThrow();
+    expect(() => validateNoShellMetacharacters('/safe/path/file.json', 'p')).not.toThrow();
+  });
+
+  it.each([
+    ['a\nb'], ['a\rb'], ['a\tb'], ['a\u0000b'],
+  ])('rejects control characters in %s', (payload) => {
+    expect(() => validateNoShellMetacharacters(payload, 'p')).toThrow(McpError);
+  });
+});
+
+describe('validateAbsolutePath', () => {
+  it('accepts absolute paths within BASE_ALLOWED_PATH', () => {
+    const safe = path.join(BASE_ALLOWED_PATH, 'sub', 'file.json');
+    expect(validateAbsolutePath(safe, 'p')).toBe(path.normalize(safe));
+  });
+
+  it('rejects relative paths', () => {
+    expect(() => validateAbsolutePath('relative/file.json', 'p')).toThrow(McpError);
+  });
+
+  it('rejects absolute paths outside BASE_ALLOWED_PATH', () => {
+    expect(() => validateAbsolutePath('/etc/passwd', 'p')).toThrow(McpError);
+  });
+
+  it('accepts punctuation that is valid in filesystem paths', () => {
+    const safe = path.join(BASE_ALLOWED_PATH, 'sub', 'safe;name#test!.json');
+    expect(validateAbsolutePath(safe, 'p')).toBe(path.normalize(safe));
+  });
+
+  it('rejects path traversal escaping the base', () => {
+    const evil = path.join(BASE_ALLOWED_PATH, '..', '..', 'etc', 'passwd');
+    expect(() => validateAbsolutePath(evil, 'p')).toThrow(McpError);
+  });
+
+  it('uses configured workspace roots instead of the package directory', () => {
+    const workspaceRoot = mkdtempSync(path.join(tmpdir(), 'semgrep-root-'));
+    mkdirSync(path.join(workspaceRoot, 'src'), { recursive: true });
+
+    try {
+      withAllowedRootsEnv([workspaceRoot], () => {
+        expect(getAllowedRoots()).toEqual([realpathSync.native(workspaceRoot)]);
+        expect(validateAbsolutePath(path.join(workspaceRoot, 'src', 'app.ts'), 'path'))
+          .toBe(path.join(realpathSync.native(workspaceRoot), 'src', 'app.ts'));
+      });
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('rejects sibling prefix paths outside a configured workspace root', () => {
+    const workspaceRoot = mkdtempSync(path.join(tmpdir(), 'semgrep-root-'));
+    const siblingRoot = `${workspaceRoot}-shadow`;
+    mkdirSync(path.join(workspaceRoot, 'src'), { recursive: true });
+    mkdirSync(path.join(siblingRoot, 'src'), { recursive: true });
+
+    try {
+      withAllowedRootsEnv([workspaceRoot], () => {
+        expect(() => validateAbsolutePath(path.join(siblingRoot, 'src', 'app.ts'), 'path'))
+          .toThrow(McpError);
+      });
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: true });
+      rmSync(siblingRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('config: accepts auto', () => {
+    expect(validateAbsolutePath('auto', 'config')).toBe('auto');
+  });
+
+  it('config: accepts p/ and r/ registry refs', () => {
+    expect(validateAbsolutePath('p/security', 'config')).toBe('p/security');
+    expect(validateAbsolutePath('r/javascript.security', 'config')).toBe('r/javascript.security');
+  });
+
+  it('config: rejects shell metacharacters in registry-like values', () => {
+    expect(() => validateAbsolutePath('p/security\nid', 'config')).toThrow(McpError);
+  });
+
+  it('config: rejects malformed registry references', () => {
+    expect(() => validateAbsolutePath('p/security with spaces', 'config')).toThrow(McpError);
+  });
+});
+
+describe('validateRuleField', () => {
+  const RULE_ID = /^[a-zA-Z][a-zA-Z0-9_.-]{0,127}$/;
+  const LANGUAGE = /^[a-zA-Z][a-zA-Z0-9_+-]{0,31}$/;
+
+  it('accepts valid rule id', () => {
+    expect(validateRuleField('my_custom_rule.v2', 'id', RULE_ID)).toBe('my_custom_rule.v2');
+  });
+
+  it('accepts valid language', () => {
+    expect(validateRuleField('python', 'language', LANGUAGE)).toBe('python');
+    expect(validateRuleField('c++', 'language', LANGUAGE)).toBe('c++');
+  });
+
+  it('rejects YAML-injection payload in id', () => {
+    expect(() => validateRuleField('foo\n  - id: pwned', 'id', RULE_ID)).toThrow(McpError);
+  });
+
+  it('rejects shell metacharacters in language', () => {
+    expect(() => validateRuleField('python; id', 'language', LANGUAGE)).toThrow(McpError);
+  });
+});
+
+describe('validateRuleSeverity', () => {
+  it.each(['ERROR', 'WARNING', 'INFO', 'error', 'warning', 'info'])(
+    'accepts %s and normalises to upper case',
+    (input) => {
+      expect(validateRuleSeverity(input)).toBe(input.toUpperCase());
+    }
+  );
+
+  it('rejects unknown severity', () => {
+    expect(() => validateRuleSeverity('CRITICAL')).toThrow(McpError);
+  });
+
+  it('rejects severity with shell metacharacters', () => {
+    expect(() => validateRuleSeverity('ERROR; rm -rf /')).toThrow(McpError);
+  });
+});
+
+describe('CWE-78 end-to-end regression (filesystem read instead of shell)', () => {
+  it('reads JSON via fs.readFile, not via cat shell call', async () => {
+    const fixture = path.join(BASE_ALLOWED_PATH, 'cwe78-fixture.json');
+    await writeFile(fixture, JSON.stringify({ results: [] }), 'utf-8');
+    try {
+      const fileContent = await import('fs/promises').then(m => m.readFile(fixture, 'utf-8'));
+      expect(JSON.parse(fileContent)).toEqual({ results: [] });
+    } finally {
+      await unlink(fixture).catch(() => undefined);
+    }
+  });
+});
+
+describe('parseSemgrepResults', () => {
+  it('returns an empty object for null payloads', () => {
+    expect(parseSemgrepResults('null')).toEqual({});
+  });
+
+  it('returns an empty object for non-object JSON payloads', () => {
+    expect(parseSemgrepResults('[]')).toEqual({});
+    expect(parseSemgrepResults('"text"')).toEqual({});
+  });
+
+  it('preserves object payloads', () => {
+    expect(parseSemgrepResults(JSON.stringify({ results: [] }))).toEqual({ results: [] });
+  });
+});

@@ -0,0 +1,114 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { execFileSync } from 'child_process';
+import { chmodSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { tmpdir } from 'os';
+
+const testFilePath = fileURLToPath(import.meta.url);
+const testsDir = path.dirname(testFilePath);
+const repoRoot = path.resolve(testsDir, '..');
+const buildEntry = path.join(repoRoot, 'build', 'index.js');
+
+function createFakeSemgrepBinary(): string {
+  const binDir = mkdtempSync(path.join(tmpdir(), 'semgrep-bin-'));
+  const semgrepPath = path.join(binDir, 'semgrep');
+
+  writeFileSync(
+    semgrepPath,
+    [
+      '#!/bin/sh',
+      'if [ "$1" = "--version" ]; then',
+      '  echo "0.0.0-test"',
+      '  exit 0',
+      'fi',
+      'exit 1',
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+  chmodSync(semgrepPath, 0o755);
+
+  return binDir;
+}
+
+beforeAll(() => {
+  execFileSync('npm', ['run', 'build'], {
+    cwd: repoRoot,
+    stdio: 'pipe',
+  });
+});
+
+describe('stdio smoke', () => {
+  it('boots against a consumer workspace root and enforces it over MCP stdio', async () => {
+    const workspaceRoot = mkdtempSync(path.join(tmpdir(), 'semgrep-stdio-workspace-'));
+    const outsideRoot = mkdtempSync(path.join(tmpdir(), 'semgrep-stdio-outside-'));
+    const fakeSemgrepDir = createFakeSemgrepBinary();
+    const resultsFile = path.join(workspaceRoot, 'results.json');
+    const outsideResultsFile = path.join(outsideRoot, 'results.json');
+    const stderrChunks: string[] = [];
+
+    writeFileSync(resultsFile, JSON.stringify({
+      results: [{ check_id: 'demo.rule', extra: { severity: 'WARNING' } }],
+    }));
+    writeFileSync(outsideResultsFile, JSON.stringify({ results: [] }));
+    mkdirSync(path.join(workspaceRoot, 'src'), { recursive: true });
+
+    const transport = new StdioClientTransport({
+      command: process.execPath,
+      args: [buildEntry],
+      cwd: workspaceRoot,
+      stderr: 'pipe',
+      env: {
+        PATH: `${fakeSemgrepDir}${path.delimiter}${process.env.PATH ?? ''}`,
+      },
+    });
+
+    transport.stderr?.on('data', (chunk) => {
+      stderrChunks.push(String(chunk));
+    });
+
+    const client = new Client({
+      name: 'stdio-smoke-test',
+      version: '1.0.0',
+    });
+
+    try {
+      await client.connect(transport);
+
+      const toolList = await client.listTools();
+      expect(toolList.tools.map((tool) => tool.name)).toContain('analyze_results');
+
+      const analysis = await client.callTool({
+        name: 'analyze_results',
+        arguments: { results_file: resultsFile },
+      });
+      const textContent = analysis.content[0];
+
+      expect(textContent?.type).toBe('text');
+      expect(JSON.parse(textContent?.type === 'text' ? textContent.text : '{}')).toMatchObject({
+        total_findings: 1,
+        by_severity: { WARNING: 1 },
+        by_rule: { 'demo.rule': 1 },
+      });
+
+      await expect(client.callTool({
+        name: 'analyze_results',
+        arguments: { results_file: outsideResultsFile },
+      })).rejects.toThrow(/allowed workspace root/i);
+    } catch (error) {
+      const stderrOutput = stderrChunks.join('').trim();
+      if (stderrOutput) {
+        throw new Error(`${String(error)}\n\nServer stderr:\n${stderrOutput}`);
+      }
+      throw error;
+    } finally {
+      await client.close().catch(() => undefined);
+      rmSync(workspaceRoot, { recursive: true, force: true });
+      rmSync(outsideRoot, { recursive: true, force: true });
+      rmSync(fakeSemgrepDir, { recursive: true, force: true });
+    }
+  }, 20000);
+});

@@ -1,56 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { validateAbsolutePath, validateConfig } from '../src/utils/validation.js';
-import { McpError } from '../src/sdk.js';
-import { BASE_ALLOWED_PATH } from '../src/config.js';
-import path from 'path';
-
-// Mock the BASE_ALLOWED_PATH
-vi.mock('../src/config.js', () => ({
-  BASE_ALLOWED_PATH: '/mock/base/path'
-}));
-
-describe('validateAbsolutePath', () => {
-  it('should accept valid absolute paths within allowed directory', () => {
-    const testPath = '/mock/base/path/some/file.txt';
-    expect(validateAbsolutePath(testPath, 'testPath')).toBe(testPath);
-  });
-
-  it('should reject relative paths', () => {
-    expect(() => validateAbsolutePath('some/relative/path', 'testPath'))
-      .toThrowError(McpError);
-  });
-
-  it('should reject paths outside allowed directory', () => {
-    expect(() => validateAbsolutePath('/some/other/directory', 'testPath'))
-      .toThrowError(McpError);
-  });
-
-  it('should handle path traversal attempts', () => {
-    expect(() => validateAbsolutePath('/mock/base/path/../../../etc/passwd', 'testPath'))
-      .toThrowError(McpError);
-  });
-});
-
-describe('validateConfig', () => {
-  it('should accept "auto" config', () => {
-    expect(validateConfig('auto')).toBe('auto');
-  });
-
-  it('should accept registry references', () => {
-    expect(validateConfig('p/ci')).toBe('p/ci');
-    expect(validateConfig('p/security')).toBe('p/security');
-  });
-
-  it('should validate path configs', () => {
-    // For this test, we'll just verify that non-registry paths are treated differently
-    // This is the best we can do without complex mocking
-    const registryPath = 'p/custom';
-    const normalPath = '/some/path/to/rules.yaml';
-    
-    // Registry paths should be returned directly
-    expect(validateConfig(registryPath)).toBe(registryPath);
-    
-    // If we tried to test normal paths, they'd fail validation in the current mock config
-    // So we'll just skip that part of the test
-  });
-});

@@ -10,7 +10,7 @@ First, make sure you have Node.js (v18+) installed. The server offers multiple w
 
 The simplest way to install and use MCP Server Semgrep is directly through Smithery.ai:
 
-1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@Szowesgad/mcp-server-semgrep)
+1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@VetCoders/mcp-server-semgrep)
 2. Click the "Install" button for your preferred MCP client
 3. Follow the on-screen instructions to complete the installation
 
@@ -33,7 +33,7 @@ yarn global add mcp-server-semgrep
 
 ```bash
 # Install directly from GitHub repository
-npm install -g git+https://github.com/Szowesgad/mcp-server-semgrep.git
+npm install -g git+https://github.com/VetCoders/mcp-server-semgrep.git
 ```
 
 ### Semgrep Installation Options:
@@ -64,6 +64,14 @@ pip install semgrep
 
 The server will automatically detect your Semgrep installation regardless of how it was installed, and will provide helpful guidance if it's missing.
 
+## Workspace Roots
+
+The server only accepts absolute paths that live inside an allowed workspace root.
+
+- Default behavior: use `process.cwd()` as the only allowed root.
+- Recommended for desktop clients and managed launchers: set `MCP_SERVER_SEMGREP_ALLOWED_ROOTS` to one or more absolute directories.
+- Multiple roots use your platform delimiter: `:` on macOS/Linux, `;` on Windows.
+
 ## Running the Server
 
 ```bash
@@ -118,7 +126,7 @@ The integration enhances developer experience through:
 In Claude Desktop, you might ask:
 
 ```
-Could you scan my project directory at /path/to/code for security vulnerabilities?
+Could you scan my project directory at /path/to/code for security vulnerabilities? That directory is already covered by MCP_SERVER_SEMGREP_ALLOWED_ROOTS.
 ```
 
 Behind the scenes, the MCP server handles requests like:
@@ -369,7 +377,7 @@ There are two ways to integrate with Claude Desktop:
 
 ### Method 1: Install via Smithery.ai (Recommended)
 
-1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@Szowesgad/mcp-server-semgrep)
+1. Visit [MCP Server Semgrep on Smithery.ai](https://smithery.ai/server/@VetCoders/mcp-server-semgrep)
 2. Click "Install in Claude Desktop"
 3. Follow the on-screen instructions to complete the setup
 4. Launch Claude Desktop and the server will be available automatically
@@ -453,4 +461,4 @@ For maximum benefit:
 - Create team-specific rulesets
 - Regular reviews and updates of rules
 - Share and celebrate improvements over time
-- Use humor (like our example rules) to make the process enjoyable
\ No newline at end of file
+- Use humor (like our example rules) to make the process enjoyable