@safetnsr/vet 1.2.0 → 1.4.0

package/dist/checks/permissions.d.ts

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

package/dist/checks/permissions.js

@@ -0,0 +1,248 @@
+import { join, resolve, isAbsolute } from 'node:path';
+import { homedir } from 'node:os';
+import { readFile, fileExists } from '../util.js';
+// ── Sensitive directories that trigger DANGER if MCP server writes there ──
+const SENSITIVE_DIRS = [
+    '~/.ssh',
+    '~/.aws',
+    '/etc',
+    '/var/www',
+];
+function expandHome(p) {
+    if (p.startsWith('~/'))
+        return join(homedir(), p.slice(2));
+    if (p === '~')
+        return homedir();
+    return p;
+}
+function isSensitiveDir(p) {
+    const expanded = expandHome(p);
+    return SENSITIVE_DIRS.some(d => {
+        const expandedSensitive = expandHome(d);
+        return expanded === expandedSensitive || expanded.startsWith(expandedSensitive + '/');
+    });
+}
+function isOutsideCwd(p, cwd) {
+    const expanded = expandHome(p);
+    const abs = isAbsolute(expanded) ? expanded : resolve(cwd, expanded);
+    const resolvedCwd = resolve(cwd);
+    return !abs.startsWith(resolvedCwd + '/') && abs !== resolvedCwd;
+}
+/** Score helper */
+function applyPenalty(score, severity) {
+    const penalties = { error: 30, warning: 15, info: 5 };
+    return Math.max(0, score - penalties[severity]);
+}
+// ── A. Scan .claude/settings.json ─────────────────────────────────────────
+function checkSettingsJson(cwd, issues) {
+    const settingsPath = join(cwd, '.claude', 'settings.json');
+    if (!fileExists(settingsPath))
+        return;
+    const raw = readFile(settingsPath);
+    if (!raw)
+        return;
+    let settings;
+    try {
+        settings = JSON.parse(raw);
+    }
+    catch {
+        issues.push({
+            severity: 'warning',
+            message: '.claude/settings.json is not valid JSON — cannot audit permissions',
+            file: '.claude/settings.json',
+            fixable: false,
+        });
+        return;
+    }
+    // allowedTools containing bare "Bash" or "Bash(*)"
+    const allowedTools = settings.allowedTools;
+    if (Array.isArray(allowedTools)) {
+        for (const tool of allowedTools) {
+            if (typeof tool === 'string') {
+                if (tool === 'Bash' || tool === 'Bash(*)') {
+                    issues.push({
+                        severity: 'error',
+                        message: `allowedTools contains "${tool}" without path restrictions — unrestricted shell access`,
+                        file: '.claude/settings.json',
+                        fixable: true,
+                        fixHint: `Replace "${tool}" with specific allowed commands, e.g. "Bash(npm run *)"`,
+                    });
+                }
+            }
+        }
+    }
+    // permissions.allow with wildcards
+    const permissions = settings.permissions;
+    if (permissions && Array.isArray(permissions.allow)) {
+        for (const rule of permissions.allow) {
+            if (typeof rule === 'string' && (rule === 'Bash(*)' || rule === '**' || rule.includes('**'))) {
+                issues.push({
+                    severity: 'error',
+                    message: `permissions.allow contains wildcard "${rule}" — grants broad access`,
+                    file: '.claude/settings.json',
+                    fixable: true,
+                    fixHint: 'Remove wildcard rules and enumerate specific allowed operations',
+                });
+            }
+        }
+    }
+    // defaultMode: "bypassPermissions"
+    if (settings.defaultMode === 'bypassPermissions') {
+        issues.push({
+            severity: 'error',
+            message: 'defaultMode is "bypassPermissions" — skips all permission checks',
+            file: '.claude/settings.json',
+            fixable: true,
+            fixHint: 'Remove defaultMode or set to "default"',
+        });
+    }
+    // No blockedTools or deny list
+    const hasBlockedTools = Array.isArray(settings.blockedTools) && settings.blockedTools.length > 0;
+    const hasDenyList = permissions && Array.isArray(permissions.deny) && permissions.deny.length > 0;
+    if (!hasBlockedTools && !hasDenyList) {
+        issues.push({
+            severity: 'warning',
+            message: 'No blockedTools or deny list defined — all unlisted tools remain available',
+            file: '.claude/settings.json',
+            fixable: true,
+            fixHint: 'Add blockedTools: ["Bash", "Write"] to restrict dangerous operations',
+        });
+    }
+    // ── B. MCP server configs ────────────────────────────────────────────────
+    checkMcpServers(cwd, settings, '.claude/settings.json', issues);
+}
+// ── B. MCP server analysis ─────────────────────────────────────────────────
+function checkMcpServers(cwd, settings, filePath, issues) {
+    const mcpServers = settings.mcpServers;
+    if (!mcpServers || typeof mcpServers !== 'object')
+        return;
+    for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+        if (typeof serverConfig !== 'object' || serverConfig === null)
+            continue;
+        const config = serverConfig;
+        // Check server args for filesystem paths
+        const args = config.args;
+        const isFilesystemServer = (typeof config.command === 'string' && config.command.includes('filesystem')) ||
+            (Array.isArray(args) && args.some((a) => typeof a === 'string' && a.includes('filesystem')));
+        // Detect if server is read-only
+        const isReadOnly = Array.isArray(args) && args.some((a) => typeof a === 'string' && (a === '--read-only' || a === 'readonly' || a === '--readonly'));
+        // Collect root paths from args
+        const rootPaths = [];
+        if (Array.isArray(args)) {
+            for (const arg of args) {
+                if (typeof arg === 'string' && !arg.startsWith('-') && (arg.startsWith('/') || arg.startsWith('~/') || arg.startsWith('.'))) {
+                    rootPaths.push(arg);
+                }
+            }
+        }
+        // Also check explicit root config
+        if (typeof config.root === 'string') {
+            rootPaths.push(config.root);
+        }
+        if (Array.isArray(config.roots)) {
+            for (const r of config.roots) {
+                if (typeof r === 'string')
+                    rootPaths.push(r);
+            }
+        }
+        if (rootPaths.length === 0) {
+            // No path restrictions at all
+            issues.push({
+                severity: 'warning',
+                message: `MCP server "${serverName}" has no explicit path restrictions`,
+                file: filePath,
+                fixable: true,
+                fixHint: `Add root path restriction to "${serverName}" in mcpServers config`,
+            });
+            continue;
+        }
+        for (const rootPath of rootPaths) {
+            // Check sensitive directory access
+            if (isSensitiveDir(rootPath)) {
+                issues.push({
+                    severity: 'error',
+                    message: `MCP server "${serverName}" has access to sensitive directory: ${rootPath}`,
+                    file: filePath,
+                    fixable: true,
+                    fixHint: `Remove sensitive path "${rootPath}" from MCP server config`,
+                });
+                continue;
+            }
+            // Check if root is outside cwd and not read-only
+            if (isOutsideCwd(rootPath, cwd) && !isReadOnly) {
+                issues.push({
+                    severity: 'error',
+                    message: `MCP server "${serverName}" has write access outside project dir: ${rootPath}`,
+                    file: filePath,
+                    fixable: true,
+                    fixHint: `Restrict to project directory or add --read-only flag`,
+                });
+            }
+        }
+    }
+}
+// ── C. CLAUDE.md and AGENTS.md text heuristics ────────────────────────────
+const DANGEROUS_PHRASES = [
+    /full\s+access/i,
+    /unrestricted/i,
+    /\bsudo\b/i,
+    /skip\s+confirmation/i,
+    /no\s+restrictions/i,
+];
+function checkMarkdownFiles(cwd, issues) {
+    for (const filename of ['CLAUDE.md', 'AGENTS.md']) {
+        const filePath = join(cwd, filename);
+        if (!fileExists(filePath))
+            continue;
+        const content = readFile(filePath);
+        if (!content)
+            continue;
+        const lines = content.split('\n');
+        for (const pattern of DANGEROUS_PHRASES) {
+            for (let i = 0; i < lines.length; i++) {
+                if (pattern.test(lines[i])) {
+                    const matchText = lines[i].match(pattern)?.[0] ?? pattern.source;
+                    issues.push({
+                        severity: 'warning',
+                        message: `${filename} contains potentially dangerous instruction: "${matchText.trim()}"`,
+                        file: filename,
+                        line: i + 1,
+                        fixable: false,
+                        fixHint: `Review line ${i + 1} in ${filename} — ensure it doesn't grant unintended permissions`,
+                    });
+                    break; // one issue per pattern per file
+                }
+            }
+        }
+    }
+}
+// ── Main export ────────────────────────────────────────────────────────────
+export function checkPermissions(cwd) {
+    const issues = [];
+    checkSettingsJson(cwd, issues);
+    checkMarkdownFiles(cwd, issues);
+    // Score: start at 100, deduct per issue
+    let score = 100;
+    for (const issue of issues) {
+        score = applyPenalty(score, issue.severity);
+    }
+    const errorCount = issues.filter(i => i.severity === 'error').length;
+    const warnCount = issues.filter(i => i.severity === 'warning').length;
+    let summary;
+    if (issues.length === 0) {
+        summary = 'no dangerous permission grants detected';
+    }
+    else if (errorCount > 0) {
+        summary = `${errorCount} dangerous grant${errorCount !== 1 ? 's' : ''} detected — review before running agent`;
+    }
+    else {
+        summary = `${warnCount} permission warning${warnCount !== 1 ? 's' : ''} — tighten config before agent session`;
+    }
+    return {
+        name: 'permissions',
+        score,
+        maxScore: 100,
+        issues,
+        summary,
+    };
+}

package/dist/checks/tests.d.ts

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

package/dist/checks/tests.js

@@ -0,0 +1,228 @@
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { walkFiles } from '../util.js';
+const TEST_FILE_RE = /\.(test|spec)\.(ts|js|tsx|jsx)$/;
+const TEST_DIR_RE = /(?:^|[/\\])(__tests__|tests?)[/\\]/;
+function isTestFile(relPath) {
+    return TEST_FILE_RE.test(relPath) || TEST_DIR_RE.test(relPath);
+}
+// Pattern 1: Tautological assertions
+function findTautological(lines, file) {
+    const issues = [];
+    // expect(literal).toBe(literal) or .toEqual(literal)
+    const expectLiteral = /expect\(([^)]+)\)\s*\.\s*(?:toBe|toEqual)\(\s*([^)]+)\s*\)/;
+    // assert.strictEqual(x, x)
+    const assertStrictEqual = /assert\.strictEqual\(\s*([^,]+?)\s*,\s*([^)]+?)\s*\)/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const m1 = line.match(expectLiteral);
+        if (m1) {
+            const left = m1[1].trim();
+            const right = m1[2].trim();
+            if (left === right) {
+                issues.push({
+                    severity: 'error',
+                    message: `tautological assertion: expect(${left}).toBe/toEqual(${right})`,
+                    file, line: i + 1, fixable: false,
+                    fixHint: 'assert on actual behavior, not constant values',
+                });
+            }
+        }
+        const m2 = line.match(assertStrictEqual);
+        if (m2) {
+            const left = m2[1].trim();
+            const right = m2[2].trim();
+            if (left === right) {
+                issues.push({
+                    severity: 'error',
+                    message: `tautological assertion: assert.strictEqual(${left}, ${left})`,
+                    file, line: i + 1, fixable: false,
+                    fixHint: 'compare different values — input vs expected output',
+                });
+            }
+        }
+    }
+    return issues;
+}
+// Pattern 2: Empty test bodies
+function findEmptyBodies(content, file) {
+    const issues = [];
+    // Match it/test with arrow or function, empty body
+    const re = /(?:^|\n)([ \t]*(?:it|test)\s*\([^,]+,\s*(?:(?:async\s+)?(?:\(\)\s*=>|\([^)]*\)\s*=>|function\s*\([^)]*\)))\s*\{([\s]*)\}\s*\))/g;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        const body = m[2];
+        // body should be empty or whitespace/comments only
+        const stripped = body.replace(/\/\/[^\n]*/g, '').replace(/\/\*[\s\S]*?\*\//g, '').trim();
+        if (stripped === '') {
+            const line = content.substring(0, m.index).split('\n').length;
+            issues.push({
+                severity: 'error',
+                message: 'empty test body — test does nothing',
+                file, line, fixable: false,
+                fixHint: 'add actual test logic or remove the test',
+            });
+        }
+    }
+    return issues;
+}
+// Pattern 3: Todo / skipped tests
+function findTodoSkipped(lines, file) {
+    const issues = [];
+    const todoRe = /(?:it|test)\.todo\s*\(/;
+    const skippedRe = /(?:^|\s)(?:xit|xtest|xdescribe)\s*\(/;
+    for (let i = 0; i < lines.length; i++) {
+        if (todoRe.test(lines[i])) {
+            issues.push({
+                severity: 'warning',
+                message: 'todo test — placeholder with no implementation',
+                file, line: i + 1, fixable: false,
+                fixHint: 'implement the test or remove the placeholder',
+            });
+        }
+        if (skippedRe.test(lines[i])) {
+            issues.push({
+                severity: 'warning',
+                message: 'skipped test — disabled with x prefix',
+                file, line: i + 1, fixable: false,
+                fixHint: 'fix and re-enable or remove the skipped test',
+            });
+        }
+    }
+    return issues;
+}
+// Pattern 4: Zero-assertion tests
+// We need to find test blocks with code but no assertions
+function findZeroAssertionTests(content, file) {
+    const issues = [];
+    // Find it(...) or test(...) blocks - simplified regex for the opening
+    const testBlockRe = /(?:^|\n)([ \t]*)(?:it|test)\s*\(\s*(?:'[^']*'|"[^"]*"|`[^`]*`)\s*,\s*(?:async\s+)?(?:\(\)\s*=>|\([^)]*\)\s*=>|function\s*\([^)]*\))\s*\{/g;
+    let m;
+    while ((m = testBlockRe.exec(content)) !== null) {
+        const startIdx = m.index + m[0].length;
+        // Find matching closing brace
+        let depth = 1;
+        let i = startIdx;
+        while (i < content.length && depth > 0) {
+            if (content[i] === '{')
+                depth++;
+            else if (content[i] === '}')
+                depth--;
+            i++;
+        }
+        if (depth !== 0)
+            continue;
+        const body = content.substring(startIdx, i - 1);
+        const stripped = body.replace(/\/\/[^\n]*/g, '').replace(/\/\*[\s\S]*?\*\//g, '').trim();
+        if (stripped === '')
+            continue; // empty body handled elsewhere
+        // Check for assertion calls
+        const assertionRe = /(?:expect\s*\(|assert\.|\.should\.|toBe\s*\(|toEqual\s*\(|toMatch\s*\(|toThrow\s*\()/;
+        if (!assertionRe.test(body)) {
+            const line = content.substring(0, m.index).split('\n').length;
+            issues.push({
+                severity: 'warning',
+                message: 'test has code but no assertions',
+                file, line, fixable: false,
+                fixHint: 'add expect() or assert calls to verify behavior',
+            });
+        }
+    }
+    return issues;
+}
+// Pattern 5: Mock-only tests
+function findMockOnlyTests(content, file) {
+    const issues = [];
+    const testBlockRe = /(?:^|\n)([ \t]*)(?:it|test)\s*\(\s*(?:'[^']*'|"[^"]*"|`[^`]*`)\s*,\s*(?:async\s+)?(?:\(\)\s*=>|\([^)]*\)\s*=>|function\s*\([^)]*\))\s*\{/g;
+    let m;
+    while ((m = testBlockRe.exec(content)) !== null) {
+        const startIdx = m.index + m[0].length;
+        let depth = 1;
+        let i = startIdx;
+        while (i < content.length && depth > 0) {
+            if (content[i] === '{')
+                depth++;
+            else if (content[i] === '}')
+                depth--;
+            i++;
+        }
+        if (depth !== 0)
+            continue;
+        const body = content.substring(startIdx, i - 1);
+        // Find all expect lines
+        const expectLines = body.split('\n').filter(l => /expect\s*\(/.test(l));
+        if (expectLines.length === 0)
+            continue;
+        const mockRe = /\.mock|mockFn|jest\.fn|vi\.fn/;
+        const allMock = expectLines.every(l => mockRe.test(l));
+        if (allMock) {
+            const line = content.substring(0, m.index).split('\n').length;
+            issues.push({
+                severity: 'info',
+                message: 'test only asserts on mocks — no real behavior verified',
+                file, line, fixable: false,
+                fixHint: 'add assertions on actual return values or side effects',
+            });
+        }
+    }
+    return issues;
+}
+// Pattern 6: Duplicate describe blocks
+function findDuplicateDescribes(lines, file) {
+    const issues = [];
+    const describeRe = /describe\s*\(\s*(['"`])([^'"`]+)\1/;
+    const seen = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(describeRe);
+        if (m) {
+            const name = m[2];
+            if (seen.has(name)) {
+                issues.push({
+                    severity: 'info',
+                    message: `duplicate describe block: "${name}"`,
+                    file, line: i + 1, fixable: false,
+                    fixHint: 'merge duplicate describe blocks into one',
+                });
+            }
+            else {
+                seen.set(name, i + 1);
+            }
+        }
+    }
+    return issues;
+}
+export function checkTests(cwd, ignore) {
+    const allFiles = walkFiles(cwd, ignore);
+    const testFiles = allFiles.filter(f => isTestFile(f));
+    const issues = [];
+    for (const rel of testFiles) {
+        let content;
+        try {
+            content = readFileSync(join(cwd, rel), 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split('\n');
+        issues.push(...findTautological(lines, rel));
+        issues.push(...findEmptyBodies(content, rel));
+        issues.push(...findTodoSkipped(lines, rel));
+        issues.push(...findZeroAssertionTests(content, rel));
+        issues.push(...findMockOnlyTests(content, rel));
+        issues.push(...findDuplicateDescribes(lines, rel));
+    }
+    let score = 100;
+    for (const issue of issues) {
+        if (issue.severity === 'error')
+            score -= 8;
+        else if (issue.severity === 'warning')
+            score -= 4;
+        else
+            score -= 2;
+    }
+    score = Math.max(0, score);
+    const summary = issues.length > 0
+        ? `${issues.length} test anti-pattern${issues.length !== 1 ? 's' : ''} found across ${testFiles.length} test file${testFiles.length !== 1 ? 's' : ''}`
+        : 'no test anti-patterns found';
+    return { name: 'tests', score, maxScore: 100, issues, summary };
+}

package/dist/cli.js

@@ -16,7 +16,9 @@ import { checkIntegrity } from './checks/integrity.js';
 import { checkReceipt, runReceiptCommand } from './checks/receipt.js';
 import { checkMemory } from './checks/memory.js';
 import { checkVerify } from './checks/verify.js';
+import { checkTests } from './checks/tests.js';
 import { checkMap, renderMapReport } from './checks/map.js';
+import { checkPermissions } from './checks/permissions.js';
 import { score } from './scorer.js';
 import { reportPretty, reportJSON, reportBadge } from './reporter.js';
 const args = process.argv.slice(2);
@@ -48,6 +50,7 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet init               generate configs + hooks
     npx @safetnsr/vet receipt            show last agent session receipt
     npx @safetnsr/vet map [dir]          show agent visibility map
+    npx @safetnsr/vet permissions [dir]  audit Claude Code config for dangerous grants
 
   ${c.dim}categories:${c.reset}
     security   (30%)  scan, secrets, config, model usage
@@ -82,7 +85,7 @@ if (flags.has('--version') || flags.has('-v')) {
     }
     process.exit(0);
 }
-const COMMANDS = ['init', 'receipt', 'map'];
+const COMMANDS = ['init', 'receipt', 'map', 'permissions'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -122,6 +125,30 @@ if (command === 'map') {
     }
     process.exit(0);
 }
+if (command === 'permissions') {
+    const result = checkPermissions(cwd);
+    if (isJSON) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.log(`\n  ${c.bold}vet permissions${c.reset} — ${result.summary}\n`);
+        console.log(`  score: ${result.score}/100\n`);
+        if (result.issues.length === 0) {
+            console.log(`  ${c.green}no issues found${c.reset}\n`);
+        }
+        else {
+            for (const issue of result.issues) {
+                const icon = issue.severity === 'error' ? c.red + '✗' : issue.severity === 'warning' ? c.yellow + '⚠' : c.dim + 'i';
+                const loc = issue.file ? ` ${c.dim}(${issue.file}${issue.line ? `:${issue.line}` : ''})${c.reset}` : '';
+                console.log(`  ${icon}${c.reset} ${issue.message}${loc}`);
+                if (issue.fixHint)
+                    console.log(`    ${c.dim}→ ${issue.fixHint}${c.reset}`);
+            }
+            console.log('');
+        }
+    }
+    process.exit(result.score < 60 ? 1 : 0);
+}
 if (!isGitRepo(cwd)) {
     console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);
@@ -144,7 +171,7 @@ if (isFix) {
 }
 async function runChecks() {
     // Run all checks, grouped into categories
-    // Security: scan, secrets, config, models, owasp
+    // Security: scan, secrets, config, models, owasp, permissions
     const [scanResult, secretsResult, configResult, modelsResult, owaspResult] = await Promise.all([
         Promise.resolve(checkScan(cwd)),
         checkSecrets(cwd),
@@ -152,6 +179,7 @@ async function runChecks() {
         checkModels(cwd, ignore),
         Promise.resolve(checkOwasp(cwd)),
     ]);
+    const permissionsResult = checkPermissions(cwd);
     // Integrity: diff, integrity checks
     const diffResult = checkDiff(cwd, { since });
     const integrityResult = await checkIntegrity(cwd, ignore);
@@ -169,9 +197,11 @@ async function runChecks() {
     const memoryResult = checkMemory(cwd);
     // Verify: agent claim validation
     const verifyResult = checkVerify(cwd, since);
+    // Tests: test theater detection
+    const testsResult = checkTests(cwd, ignore);
     return score(cwd, {
-        security: [scanResult, secretsResult, configResult, modelsResult, owaspResult],
-        integrity: [diffResult, integrityResult, receiptResult, memoryResult, verifyResult],
+        security: [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult],
+        integrity: [diffResult, integrityResult, receiptResult, memoryResult, verifyResult, testsResult],
         debt: [readyResult, historyResult, debtResult],
         deps: [depsResult],
     });

package/package.json

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