@safetnsr/vet 1.22.2 → 1.25.0

package/dist/checks/sandbox.d.ts

@@ -0,0 +1,3 @@
+import type { CheckResult } from '../types.js';
+export declare function checkSandbox(cwd: string): Promise<CheckResult>;
+export declare function runSandboxCommand(cwd: string, flags: Set<string>): Promise<void>;

package/dist/checks/sandbox.js

@@ -0,0 +1,280 @@
+import { join } from 'node:path';
+import { statSync, existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { readFile, c } from '../util.js';
+// ── Constants ────────────────────────────────────────────────────────────────
+const SENSITIVE_DIRS = [
+    '~/.ssh',
+    '~/.aws',
+    '~/.gnupg',
+    '~/.config/gcloud',
+    '~/.kube',
+    '~/.docker',
+    '~/.npmrc',
+    '~/.pypirc',
+    '~/.netrc',
+];
+const ENV_PATTERNS = [
+    /KEY/i,
+    /SECRET/i,
+    /TOKEN/i,
+    /PASSWORD/i,
+    /CREDENTIAL/i,
+    /AUTH/i,
+];
+const NETWORK_RESTRICTION_PATTERNS = [
+    /allowedUrls/i,
+    /blockedUrls/i,
+    /networkRestrict/i,
+    /network.*allow/i,
+    /network.*block/i,
+    /allowlist/i,
+    /denylist/i,
+    /block.*network/i,
+];
+// ── Probe 1: Sensitive dirs ───────────────────────────────────────────────────
+function probeSensitiveDirs() {
+    const issues = [];
+    let deduction = 0;
+    const home = homedir();
+    for (const dir of SENSITIVE_DIRS) {
+        const resolved = dir.replace('~', home);
+        try {
+            statSync(resolved);
+            // accessible
+            deduction += 1;
+            issues.push({
+                severity: 'error',
+                message: `Sensitive directory accessible: ${dir}`,
+                fixable: false,
+                fixHint: 'Run agent in a sandboxed environment (Docker, VM, chroot) to restrict fs access',
+            });
+        }
+        catch {
+            // not accessible — good
+        }
+    }
+    return { deduction, issues };
+}
+// ── Probe 2: Env var leaks ────────────────────────────────────────────────────
+function probeEnvVars() {
+    const issues = [];
+    let rawDeduction = 0;
+    for (const key of Object.keys(process.env)) {
+        const matches = ENV_PATTERNS.some(re => re.test(key));
+        if (matches) {
+            rawDeduction += 0.5;
+            issues.push({
+                severity: 'warning',
+                message: `Sensitive env var exposed: ${key}`,
+                fixable: false,
+                fixHint: 'Use a secrets manager or strip sensitive vars before running agent',
+            });
+        }
+    }
+    const deduction = Math.min(rawDeduction, 3);
+    return { deduction, issues };
+}
+// ── Probe 3: Network rules ────────────────────────────────────────────────────
+function probeNetworkRules(cwd) {
+    const issues = [];
+    let deduction = 0;
+    const filesToCheck = ['CLAUDE.md', 'AGENTS.md'];
+    let found = false;
+    for (const filename of filesToCheck) {
+        const content = readFile(join(cwd, filename));
+        if (!content)
+            continue;
+        const hasRestriction = NETWORK_RESTRICTION_PATTERNS.some(re => re.test(content));
+        if (hasRestriction) {
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        deduction = 1;
+        issues.push({
+            severity: 'warning',
+            message: 'No network restriction rules found in CLAUDE.md or AGENTS.md',
+            fixable: false,
+            fixHint: 'Add allowedUrls or blockedUrls rules to CLAUDE.md to limit agent network access',
+        });
+    }
+    return { deduction, issues };
+}
+// ── Probe 4: MCP permissions ──────────────────────────────────────────────────
+function probeMcpPermissions(cwd) {
+    const issues = [];
+    let rawDeduction = 0;
+    const settingsPath = join(cwd, '.claude', 'settings.json');
+    if (!existsSync(settingsPath)) {
+        issues.push({
+            severity: 'info',
+            message: 'No .claude/settings.json found — cannot audit MCP permissions',
+            fixable: false,
+            fixHint: 'Create .claude/settings.json with explicit MCP permission scopes',
+        });
+        return { deduction: 0, issues };
+    }
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        issues.push({
+            severity: 'warning',
+            message: 'Failed to parse .claude/settings.json',
+            file: '.claude/settings.json',
+            fixable: false,
+        });
+        return { deduction: 0, issues };
+    }
+    // Check mcpServers for tools with filesystem:write or no path restrictions
+    const mcpServers = settings.mcpServers || {};
+    for (const [serverName, server] of Object.entries(mcpServers)) {
+        const srv = server;
+        const tools = srv.tools || [];
+        for (const tool of tools) {
+            const permissions = tool.permissions || [];
+            const hasWriteAccess = permissions.includes('filesystem:write');
+            const hasNoPathRestriction = !permissions.some(p => p.startsWith('path:'));
+            if (hasWriteAccess && hasNoPathRestriction) {
+                rawDeduction += 1;
+                issues.push({
+                    severity: 'error',
+                    message: `MCP tool with unrestricted filesystem:write: ${serverName}/${tool.name || 'unknown'}`,
+                    file: '.claude/settings.json',
+                    fixable: false,
+                    fixHint: 'Add path: restrictions to limit filesystem write access',
+                });
+            }
+        }
+        // Also check top-level permissions on the server
+        const serverPermissions = srv.permissions || [];
+        const hasWriteAccess = serverPermissions.includes('filesystem:write');
+        const hasNoPathRestriction = !serverPermissions.some((p) => p.startsWith('path:'));
+        if (hasWriteAccess && hasNoPathRestriction) {
+            rawDeduction += 1;
+            issues.push({
+                severity: 'error',
+                message: `MCP server with unrestricted filesystem:write: ${serverName}`,
+                file: '.claude/settings.json',
+                fixable: false,
+                fixHint: 'Add path: restrictions to limit filesystem write access',
+            });
+        }
+    }
+    const deduction = Math.min(rawDeduction, 2);
+    return { deduction, issues };
+}
+// ── Blast radius score ────────────────────────────────────────────────────────
+function blastRadiusLabel(score) {
+    if (score >= 9)
+        return 'minimal — agent is tightly sandboxed';
+    if (score >= 7)
+        return 'low — some exposure, mostly contained';
+    if (score >= 5)
+        return 'moderate — agent can access sensitive resources';
+    if (score >= 3)
+        return 'high — agent has broad filesystem and secret access';
+    return 'critical — agent is running in a fully open environment';
+}
+// ── Main check ───────────────────────────────────────────────────────────────
+export async function checkSandbox(cwd) {
+    const allIssues = [];
+    const sensitiveDirs = probeSensitiveDirs();
+    const envVars = probeEnvVars();
+    const networkRules = probeNetworkRules(cwd);
+    const mcpPerms = probeMcpPermissions(cwd);
+    allIssues.push(...sensitiveDirs.issues);
+    allIssues.push(...envVars.issues);
+    allIssues.push(...networkRules.issues);
+    allIssues.push(...mcpPerms.issues);
+    const totalDeduction = sensitiveDirs.deduction + envVars.deduction + networkRules.deduction + mcpPerms.deduction;
+    const sandboxScore = Math.max(0, Math.min(10, 10 - totalDeduction));
+    const score = Math.round(sandboxScore * 10);
+    const label = blastRadiusLabel(sandboxScore);
+    const summary = `blast radius score ${sandboxScore.toFixed(1)}/10 — ${label}`;
+    return {
+        name: 'sandbox',
+        score,
+        maxScore: 100,
+        issues: allIssues,
+        summary,
+    };
+}
+// ── Subcommand output ────────────────────────────────────────────────────────
+export async function runSandboxCommand(cwd, flags) {
+    const result = await checkSandbox(cwd);
+    const sandboxScore = result.score / 10;
+    if (flags.has('--json')) {
+        console.log(JSON.stringify({
+            score: sandboxScore,
+            scoreOutOf100: result.score,
+            maxScore: result.maxScore,
+            blastRadius: blastRadiusLabel(sandboxScore),
+            issues: result.issues,
+            summary: result.summary,
+        }, null, 2));
+        return;
+    }
+    console.log(`\n  ${c.bold}vet sandbox${c.reset} — agent runtime blast radius\n`);
+    // Table header
+    const labelW = 30;
+    const statusW = 12;
+    console.log(`  ${c.dim}${'─'.repeat(labelW + statusW + 6)}${c.reset}`);
+    console.log(`  ${pad('Probe', labelW)} ${pad('Status', statusW)}`);
+    console.log(`  ${c.dim}${'─'.repeat(labelW + statusW + 6)}${c.reset}`);
+    // Probe 1: Sensitive dirs
+    const sensitiveDirIssues = result.issues.filter(i => i.message.startsWith('Sensitive directory'));
+    const sensitiveDirStatus = sensitiveDirIssues.length === 0
+        ? `${c.green}PASS${c.reset}`
+        : `${c.red}FAIL (${sensitiveDirIssues.length})${c.reset}`;
+    console.log(`  ${pad('Sensitive dirs', labelW)} ${sensitiveDirStatus}`);
+    for (const issue of sensitiveDirIssues) {
+        console.log(`    ${c.red}✗${c.reset} ${issue.message}`);
+    }
+    // Probe 2: Env var leaks
+    const envIssues = result.issues.filter(i => i.message.startsWith('Sensitive env var'));
+    const envStatus = envIssues.length === 0
+        ? `${c.green}PASS${c.reset}`
+        : `${c.yellow}WARN (${envIssues.length})${c.reset}`;
+    console.log(`  ${pad('Env var exposure', labelW)} ${envStatus}`);
+    for (const issue of envIssues.slice(0, 5)) {
+        console.log(`    ${c.yellow}⚠${c.reset} ${issue.message}`);
+    }
+    if (envIssues.length > 5) {
+        console.log(`    ${c.dim}... and ${envIssues.length - 5} more${c.reset}`);
+    }
+    // Probe 3: Network rules
+    const netIssues = result.issues.filter(i => i.message.includes('network restriction'));
+    const netStatus = netIssues.length === 0
+        ? `${c.green}PASS${c.reset}`
+        : `${c.yellow}WARN${c.reset}`;
+    console.log(`  ${pad('Network restrictions', labelW)} ${netStatus}`);
+    for (const issue of netIssues) {
+        console.log(`    ${c.yellow}⚠${c.reset} ${issue.message}`);
+    }
+    // Probe 4: MCP permissions
+    const mcpIssues = result.issues.filter(i => i.message.includes('MCP'));
+    const mcpInfoIssues = result.issues.filter(i => i.message.includes('.claude/settings.json'));
+    const mcpStatus = mcpIssues.length > 0
+        ? `${c.red}FAIL (${mcpIssues.length})${c.reset}`
+        : mcpInfoIssues.length > 0
+            ? `${c.dim}N/A${c.reset}`
+            : `${c.green}PASS${c.reset}`;
+    console.log(`  ${pad('MCP permissions', labelW)} ${mcpStatus}`);
+    for (const issue of mcpIssues) {
+        console.log(`    ${c.red}✗${c.reset} ${issue.message}`);
+    }
+    console.log(`  ${c.dim}${'─'.repeat(labelW + statusW + 6)}${c.reset}`);
+    // Score
+    const scoreColor = sandboxScore >= 7 ? c.green : sandboxScore >= 4 ? c.yellow : c.red;
+    console.log(`\n  blast radius score  ${scoreColor}${sandboxScore.toFixed(1)}/10${c.reset}`);
+    console.log(`  if compromised      ${blastRadiusLabel(sandboxScore)}\n`);
+}
+// ── String helpers ───────────────────────────────────────────────────────────
+function pad(s, w) {
+    const clean = s.replace(/\x1b\[[0-9;]*m/g, '');
+    return s + ' '.repeat(Math.max(0, w - clean.length));
+}

package/dist/checks/source-security.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult } from '../types.js';
+export declare function checkSourceSecurity(cwd: string): CheckResult;

package/dist/checks/source-security.js

@@ -0,0 +1,153 @@
+import { join, relative } from 'node:path';
+import { readdirSync, statSync } from 'node:fs';
+import { cachedReadFile as cachedRead } from '../file-cache.js';
+const SOURCE_PATTERNS = [
+    {
+        id: 'eval',
+        regex: /\beval\s*\(/,
+        severity: 'error',
+        message: 'eval() usage — arbitrary code execution risk',
+    },
+    {
+        id: 'exec-sync',
+        regex: /\bexecSync\s*\(|\bexecFileSync\s*\(/,
+        severity: 'warning',
+        message: 'execSync/execFileSync — synchronous shell execution, injection risk if user input flows in',
+    },
+    {
+        id: 'child-process-exec',
+        regex: /\brequire\s*\(\s*['"]child_process['"]\s*\)/,
+        severity: 'warning',
+        message: 'child_process require — verify no untrusted input reaches shell commands',
+    },
+    {
+        id: 'function-constructor',
+        regex: /new\s+Function\s*\(/,
+        severity: 'error',
+        message: 'new Function() — dynamic code generation, equivalent to eval()',
+    },
+    {
+        id: 'innerhtml',
+        regex: /\.innerHTML\s*=|dangerouslySetInnerHTML/,
+        severity: 'warning',
+        message: 'innerHTML/dangerouslySetInnerHTML — XSS risk if content is not sanitized',
+    },
+    {
+        id: 'hardcoded-jwt',
+        regex: /['"]eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/,
+        severity: 'error',
+        message: 'hardcoded JWT token detected',
+    },
+    {
+        id: 'hardcoded-private-key',
+        regex: /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----/,
+        severity: 'error',
+        message: 'hardcoded private key detected',
+    },
+    {
+        id: 'disable-tls',
+        regex: /NODE_TLS_REJECT_UNAUTHORIZED\s*=\s*['"]?0|rejectUnauthorized\s*:\s*false/,
+        severity: 'error',
+        message: 'TLS verification disabled — man-in-the-middle risk',
+    },
+    {
+        id: 'sql-concat',
+        regex: /(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE)\s+.*\$\{|(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE)\s+.*\+\s*(?:req\.|params\.|query\.|body\.)/i,
+        severity: 'error',
+        message: 'SQL query string concatenation — SQL injection risk',
+    },
+];
+// ── Source file collection ────────────────────────────────────────────────────
+const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', 'vendor', '__pycache__']);
+const MAX_FILES = 500;
+const MAX_FILE_SIZE = 512 * 1024; // 512KB
+function collectSourceFiles(cwd, maxFiles = MAX_FILES) {
+    const files = [];
+    function walk(dir, depth) {
+        if (depth > 8 || files.length >= maxFiles)
+            return;
+        try {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                if (files.length >= maxFiles)
+                    break;
+                if (entry.isDirectory()) {
+                    if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                        continue;
+                    walk(join(dir, entry.name), depth + 1);
+                }
+                else if (entry.isFile()) {
+                    const ext = entry.name.slice(entry.name.lastIndexOf('.'));
+                    if (SOURCE_EXTENSIONS.has(ext)) {
+                        const full = join(dir, entry.name);
+                        try {
+                            if (statSync(full).size <= MAX_FILE_SIZE) {
+                                files.push(full);
+                            }
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    walk(cwd, 0);
+    return files;
+}
+// ── Main check ───────────────────────────────────────────────────────────────
+export function checkSourceSecurity(cwd) {
+    const files = collectSourceFiles(cwd);
+    const issues = [];
+    for (const filePath of files) {
+        try {
+            const content = cachedRead(filePath);
+            if (!content)
+                continue;
+            const relPath = relative(cwd, filePath);
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Skip comments
+                const trimmed = line.trim();
+                if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+                    continue;
+                // Skip test files for some patterns
+                const isTest = relPath.includes('.test.') || relPath.includes('.spec.') || relPath.includes('__tests__');
+                for (const pattern of SOURCE_PATTERNS) {
+                    // execSync in util files and non-test is fine for CLI tools — only flag in src/
+                    if (pattern.id === 'exec-sync' && !relPath.startsWith('src/'))
+                        continue;
+                    // Skip innerHTML in test files
+                    if (pattern.id === 'innerhtml' && isTest)
+                        continue;
+                    if (pattern.regex.test(line)) {
+                        pattern.regex.lastIndex = 0;
+                        issues.push({
+                            severity: pattern.severity,
+                            message: pattern.message,
+                            file: relPath,
+                            line: i + 1,
+                            fixable: false,
+                        });
+                    }
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    const errors = issues.filter(i => i.severity === 'error').length;
+    const warnings = issues.filter(i => i.severity === 'warning').length;
+    const score = Math.max(0, 100 - errors * 30 - warnings * 10);
+    return {
+        name: 'source-security',
+        score,
+        maxScore: 100,
+        issues,
+        summary: files.length === 0
+            ? 'no source files found'
+            : issues.length === 0
+                ? `${files.length} source files scanned, clean`
+                : `${issues.length} security finding${issues.length !== 1 ? 's' : ''} in source code`,
+    };
+}

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { resolve } from 'node:path';
 import { readFileSync } from 'node:fs';
-import { isGitRepo, readFile, c } from './util.js';
+import { isGitRepo, readFile, c, gitExec } from './util.js';
 import { checkReady } from './checks/ready.js';
 import { checkDiff } from './checks/diff.js';
 import { checkModels } from './checks/models.js';
@@ -30,11 +30,14 @@ import { checkSubsidy, runSubsidyCommand } from './checks/subsidy.js';
 import { checkLoop, runLoopCommand } from './checks/loop.js';
 import { checkBloat, runBloatCommand } from './checks/bloat.js';
 import { checkGuard, runGuardCommand } from './checks/guard.js';
+import { checkSandbox, runSandboxCommand } from './checks/sandbox.js';
 import { checkExplain, runExplainCommand } from './checks/explain.js';
 import { checkContext, runContextCommand } from './checks/context.js';
 import { checkSplit, runSplitCommand } from './checks/split.js';
+import { checkSourceSecurity } from './checks/source-security.js';
 import { checkCompleteness } from './checks/completeness.js';
 import { score } from './scorer.js';
+import { toGrade } from './categories.js';
 import { reportPretty, reportJSON, reportBadge } from './reporter.js';
 import { clearCache } from './file-cache.js';
 const args = process.argv.slice(2);
@@ -90,6 +93,7 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet explain [--since REF] [--verbose] [--json]  risk-tier agent changes
     npx @safetnsr/vet context [dir]    audit agent context files for token cost + stale sections
     npx @safetnsr/vet split [--since HEAD~1] [--apply] [--force] [--json]  split AI mega-commits into atomic commits
+    npx @safetnsr/vet sandbox [dir]     score agent runtime blast radius
 
   ${c.dim}categories:${c.reset}
     security   (30%)  scan, secrets, config, model usage
@@ -105,6 +109,7 @@ if (flags.has('--help') || flags.has('-h')) {
     --hook        pre-commit hook mode (exit 1 if below grade C)
     --badge       print markdown badge string and exit
     --fix         auto-fix configs, models
+    --diff-only   only score files changed in current branch (great for CI)
     --since REF   diff against specific commit/range
     --watch       re-run on file changes
     --json        JSON output
@@ -125,7 +130,7 @@ if (flags.has('--version') || flags.has('-v')) {
     }
     process.exit(0);
 }
-const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy', 'loop', 'bloat', 'guard', 'explain', 'context', 'split'];
+const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy', 'loop', 'bloat', 'guard', 'explain', 'context', 'split', 'sandbox'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -133,6 +138,7 @@ const isHook = flags.has('--hook');
 const isFix = flags.has('--fix');
 const isWatch = flags.has('--watch');
 const isBadge = flags.has('--badge');
+const isDiffOnly = flags.has('--diff-only');
 const isJSON = flags.has('--json') || (!process.stdout.isTTY && !flags.has('--pretty') && !isBadge);
 const since = flagMap.get('since');
 const maxFiles = flagMap.has('max-files') ? (parseInt(flagMap.get('max-files'), 10) || 0) : 0;
@@ -302,6 +308,16 @@ if (command === 'explain') {
     }
     process.exit(0);
 }
+if (command === 'sandbox') {
+    try {
+        await runSandboxCommand(cwd, flags);
+    }
+    catch (e) {
+        console.error(`${c.red}sandbox failed:${c.reset}`, e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+    process.exit(0);
+}
 if (!isGitRepo(cwd)) {
     console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);
@@ -339,6 +355,56 @@ async function withTimeout(name, fn, timeoutMs = 30_000) {
         Promise.resolve(fn()).then((r) => { clearTimeout(timer); res(r); }).catch(() => { clearTimeout(timer); res({ name, score: 100, maxScore: 100, issues: [], summary: 'check failed' }); });
     });
 }
+/** Get files changed vs main/master branch or --since ref */
+function getChangedFiles(cwd, sinceRef) {
+    const base = sinceRef || (() => {
+        const main = gitExec(['merge-base', 'HEAD', 'origin/main'], cwd);
+        if (main)
+            return main;
+        const master = gitExec(['merge-base', 'HEAD', 'origin/master'], cwd);
+        if (master)
+            return master;
+        return 'HEAD~1';
+    })();
+    const output = gitExec(['diff', '--name-only', base, 'HEAD'], cwd);
+    if (!output)
+        return new Set();
+    return new Set(output.split('\n').filter(Boolean));
+}
+/** Filter VetResult to only include issues from changed files, then re-score */
+function filterDiffOnly(result, changedFiles) {
+    if (changedFiles.size === 0)
+        return result;
+    const filtered = {
+        ...result,
+        categories: result.categories.map(cat => {
+            const filteredChecks = cat.checks.map(check => {
+                const filteredIssues = check.issues.filter(issue => !issue.file || changedFiles.has(issue.file));
+                const penalty = filteredIssues.reduce((sum, i) => {
+                    if (i.severity === 'error')
+                        return sum + 25;
+                    if (i.severity === 'warning')
+                        return sum + 10;
+                    return sum + 2;
+                }, 0);
+                const newScore = Math.max(0, 100 - penalty);
+                return { ...check, score: newScore, issues: filteredIssues };
+            });
+            const allIssues = filteredChecks.flatMap(c => c.issues);
+            const checksWithIssues = filteredChecks.filter(c => c.issues.length > 0);
+            const avgScore = checksWithIssues.length > 0
+                ? Math.round(checksWithIssues.reduce((sum, c) => sum + c.score, 0) / checksWithIssues.length)
+                : 100;
+            return { ...cat, checks: filteredChecks, issues: allIssues, score: avgScore };
+        }),
+    };
+    const totalWeight = filtered.categories.reduce((sum, c) => sum + c.weight, 0);
+    filtered.score = Math.round(filtered.categories.reduce((sum, c) => sum + c.score * c.weight, 0) / totalWeight);
+    filtered.grade = toGrade(filtered.score);
+    filtered.totalIssues = filtered.categories.reduce((sum, c) => c.issues.length + sum, 0);
+    filtered.fixableIssues = filtered.categories.reduce((sum, c) => c.issues.filter(i => i.fixable).length + sum, 0);
+    return filtered;
+}
 async function runChecks() {
     const globalStart = Date.now();
     const GLOBAL_TIMEOUT = 120_000;
@@ -353,8 +419,9 @@ async function runChecks() {
             }
         }
         // Run ALL independent checks in parallel
-        const [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, subsidyResult, memoryResult, verifyResult, testsResult, loopResult, completenessResult, bloatResult, guardResult, explainResult, architectureResult, aireadyResult, deepResult, semanticResult, hotspotsResult, clonesResult, contextResult, splitResult,] = await Promise.all([
+        const [scanResult, sourceSecurityResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, subsidyResult, memoryResult, verifyResult, testsResult, loopResult, completenessResult, bloatResult, guardResult, explainResult, architectureResult, aireadyResult, deepResult, semanticResult, hotspotsResult, clonesResult, contextResult, splitResult, sandboxResult,] = await Promise.all([
             withTimeout('scan', () => checkScan(cwd)),
+            withTimeout('source-security', () => checkSourceSecurity(cwd)),
             withTimeout('secrets', () => checkSecrets(cwd)),
             withTimeout('config', () => checkConfig(cwd, ignore)),
             withTimeout('models', () => checkModels(cwd, ignore)),
@@ -383,6 +450,7 @@ async function runChecks() {
             withTimeout('clones', () => checkClones(cwd), 60_000),
             withTimeout('context', () => checkContext(cwd)),
             withTimeout('split', () => checkSplit(cwd)),
+            withTimeout('sandbox', () => checkSandbox(cwd)),
         ]);
         // Git-dependent checks (diff + history) — parallel with each other
         const [diffResult, historyResult] = await Promise.all([
@@ -392,7 +460,7 @@ async function runChecks() {
         // Clear file cache after all checks complete
         clearCache();
         return score(cwd, {
-            security: [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, subsidyResult, guardResult],
+            security: [scanResult, sourceSecurityResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, subsidyResult, guardResult, sandboxResult],
             integrity: [diffResult, integrityResult, receiptResult, compactResult, memoryResult, verifyResult, testsResult, loopResult, completenessResult, explainResult],
             debt: [readyResult, historyResult, debtResult, bloatResult, clonesResult, splitResult],
             deps: [depsResult],
@@ -454,7 +522,11 @@ if (isWatch) {
 else {
     // Normal run
     try {
-        const result = await runChecks();
+        let result = await runChecks();
+        if (isDiffOnly) {
+            const changedFiles = getChangedFiles(cwd, since);
+            result = filterDiffOnly(result, changedFiles);
+        }
         if (isJSON) {
             console.log(reportJSON(result));
         }

package/dist/utils-bad.d.ts

@@ -0,0 +1,6 @@
+export declare function fetchData(url: any): Promise<any>;
+export declare function processItems(items: any): any[];
+export declare const exec: any;
+export declare function runCmd(cmd: string): any;
+export declare function deepClone(obj: any): any;
+export declare function dangerousEval(code: string): any;

package/dist/utils-bad.js

@@ -0,0 +1,39 @@
+// TODO: clean this up eventually
+// HACK: workaround for broken API
+const API_KEY = "sk-proj-abc123secretkey456def789";
+const DB_PASSWORD = "admin123!@#";
+export async function fetchData(url) {
+    // @ts-ignore
+    const res = await fetch(url);
+    const data = await res.json();
+    try {
+        return data;
+    }
+    catch (e) {
+        // swallow error silently
+    }
+}
+export function processItems(items) {
+    var result = [];
+    for (var i = 0; i < items.length; i++) {
+        for (var j = 0; j < items[i].children.length; j++) {
+            for (var k = 0; k < items[i].children[j].values.length; k++) {
+                if (items[i].children[j].values[k] !== null && items[i].children[j].values[k] !== undefined) {
+                    result.push(items[i].children[j].values[k]);
+                }
+            }
+        }
+    }
+    return result;
+}
+export const exec = require('child_process').execSync;
+export function runCmd(cmd) {
+    return exec(cmd).toString();
+}
+// copied from stackoverflow
+export function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+export function dangerousEval(code) {
+    return eval(code);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/vet",
-  "version": "1.22.2",
+  "version": "1.25.0",
   "description": "vet your AI-generated code — one command, one score card, one letter grade",
   "type": "module",
   "bin": {