@safetnsr/vet 0.2.0 → 0.3.0

package/dist/checks/receipt.js

@@ -0,0 +1,306 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { createInterface } from 'node:readline';
+// ── Session file discovery ───────────────────────────────────────────────────
+function walkDir(dir) {
+    const results = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                results.push(...walkDir(full));
+            else
+                results.push(full);
+        }
+    }
+    catch { /* skip */ }
+    return results;
+}
+export function findSessionFiles(baseDir) {
+    const dir = baseDir || path.join(process.env['HOME'] || '~', '.claude', 'projects');
+    if (!fs.existsSync(dir))
+        return [];
+    return walkDir(dir).filter(f => f.endsWith('.jsonl')).sort();
+}
+export function findLatestSession(baseDir) {
+    const files = findSessionFiles(baseDir);
+    if (files.length === 0)
+        return null;
+    let latest = files[0];
+    let latestMtime = fs.statSync(latest).mtimeMs;
+    for (let i = 1; i < files.length; i++) {
+        const mtime = fs.statSync(files[i]).mtimeMs;
+        if (mtime > latestMtime) {
+            latest = files[i];
+            latestMtime = mtime;
+        }
+    }
+    return latest;
+}
+// ── JSONL parsing ────────────────────────────────────────────────────────────
+export async function parseSessionFile(filePath) {
+    const toolUses = [];
+    const entries = [];
+    const rl = createInterface({ input: fs.createReadStream(filePath, { encoding: 'utf-8' }), crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const entry = JSON.parse(trimmed);
+            entries.push(entry);
+            for (const content of [entry.content, entry.message?.content]) {
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block && typeof block === 'object' && block.type === 'tool_use') {
+                            toolUses.push(block);
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* skip malformed */ }
+    }
+    return { toolUses, entries };
+}
+// ── Action grouper ───────────────────────────────────────────────────────────
+function getFilePath(input) {
+    const p = (input['file_path'] || input['path'] || input['filePath'] || input['filename'] || '');
+    return p || null;
+}
+function extractPackages(cmd, packages) {
+    const npmM = cmd.match(/npm\s+(?:install|i|add)\s+([^\s&|;]+(?:\s+[^\s&|;-][^\s&|;]*)*)/);
+    if (npmM)
+        npmM[1].split(/\s+/).filter(p => !p.startsWith('-')).forEach(p => packages.add(p));
+    const yarnM = cmd.match(/yarn\s+add\s+([^\s&|;]+(?:\s+[^\s&|;-][^\s&|;]*)*)/);
+    if (yarnM)
+        yarnM[1].split(/\s+/).filter(p => !p.startsWith('-')).forEach(p => packages.add(p));
+    const pipM = cmd.match(/pip3?\s+install\s+([^\s&|;]+(?:\s+[^\s&|;-][^\s&|;]*)*)/);
+    if (pipM)
+        pipM[1].split(/\s+/).filter(p => !p.startsWith('-')).forEach(p => packages.add(p));
+}
+function extractUrls(cmd, urls) {
+    const matches = cmd.match(/https?:\/\/[^\s"'`<>|&;]+/g);
+    if (matches)
+        matches.forEach(u => urls.add(u));
+}
+function extractFileOps(cmd, deleted, created) {
+    const rmM = cmd.match(/(?:rm|trash)\s+(?:-[rf]*\s+)*([^\s&|;]+)/);
+    if (rmM && /^(?:rm|trash)\b/.test(cmd))
+        deleted.add(rmM[1]);
+    const touchM = cmd.match(/(?:touch|mkdir)\s+(?:-[p]*\s+)*([^\s&|;]+)/);
+    if (touchM)
+        created.add(touchM[1]);
+}
+function calculateDuration(start, end) {
+    if (!start || !end)
+        return null;
+    try {
+        const diff = new Date(end).getTime() - new Date(start).getTime();
+        return isNaN(diff) ? null : Math.round(diff / 1000);
+    }
+    catch {
+        return null;
+    }
+}
+export function groupActions(toolUses, entries, sessionPath) {
+    const filesModified = new Set();
+    const filesDeleted = new Set();
+    const filesCreated = new Set();
+    const commandsRun = [];
+    const urlsFetched = new Set();
+    const packagesInstalled = new Set();
+    const timestamps = entries.map(e => e.timestamp).filter((t) => typeof t === 'string').sort();
+    for (const tool of toolUses) {
+        const input = tool.input || {};
+        switch (tool.name) {
+            case 'Write':
+            case 'write':
+            case 'write_file':
+            case 'create_file': {
+                const fp = getFilePath(input);
+                if (fp)
+                    filesCreated.add(fp);
+                break;
+            }
+            case 'Edit':
+            case 'edit':
+            case 'edit_file':
+            case 'str_replace_editor': {
+                const fp = getFilePath(input);
+                if (fp)
+                    filesModified.add(fp);
+                break;
+            }
+            case 'Read':
+            case 'read':
+            case 'read_file': break;
+            case 'exec':
+            case 'execute':
+            case 'bash':
+            case 'terminal':
+            case 'run_command': {
+                const cmd = (input['command'] || input['cmd'] || '');
+                if (cmd) {
+                    commandsRun.push(cmd);
+                    extractPackages(cmd, packagesInstalled);
+                    extractUrls(cmd, urlsFetched);
+                    extractFileOps(cmd, filesDeleted, filesCreated);
+                }
+                break;
+            }
+            case 'web_fetch':
+            case 'fetch':
+            case 'http_request':
+            case 'web_search': {
+                const url = (input['url'] || input['query'] || '');
+                if (url)
+                    urlsFetched.add(url);
+                break;
+            }
+            case 'browser': {
+                const url = (input['targetUrl'] || input['url'] || '');
+                if (url)
+                    urlsFetched.add(url);
+                break;
+            }
+        }
+    }
+    for (const f of filesCreated)
+        filesModified.delete(f);
+    return {
+        session_id: path.basename(sessionPath, '.jsonl'),
+        start_time: timestamps[0] || null,
+        end_time: timestamps[timestamps.length - 1] || null,
+        duration_seconds: calculateDuration(timestamps[0], timestamps[timestamps.length - 1]),
+        files_modified: [...filesModified].sort(),
+        files_deleted: [...filesDeleted].sort(),
+        files_created: [...filesCreated].sort(),
+        commands_run: commandsRun,
+        urls_fetched: [...urlsFetched].sort(),
+        packages_installed: [...packagesInstalled].sort(),
+    };
+}
+// ── SHA256 + rendering ───────────────────────────────────────────────────────
+export function computeSha256(content) {
+    return crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
+}
+export function renderReceiptText(actions) {
+    const WIDTH = 46;
+    const BORDER = '═'.repeat(WIDTH);
+    const pad = (s) => (s.length >= WIDTH - 2 ? s.slice(0, WIDTH - 2) : s + ' '.repeat(WIDTH - 2 - s.length));
+    const line = (s) => `║ ${pad(s)} ║`;
+    const fmt = (d) => d ? new Date(d).toISOString().replace('T', ' ').replace(/\.\d+Z$/, ' UTC') : 'unknown';
+    const dur = (s) => s === null ? 'unknown' : s < 60 ? `${s}s` : `${Math.floor(s / 60)}m ${s % 60}s`;
+    const lines = [];
+    lines.push(`╔${BORDER}╗`);
+    const title = 'AGENT SESSION RECEIPT';
+    const leftPad = Math.floor((WIDTH - 2 - title.length) / 2);
+    const rightPad = WIDTH - 2 - title.length - leftPad;
+    lines.push(`║ ${' '.repeat(leftPad)}${title}${' '.repeat(rightPad)} ║`);
+    lines.push(`╠${BORDER}╣`);
+    lines.push(line(`Session:  ${actions.session_id.slice(0, 30)}`));
+    lines.push(line(`Date:     ${fmt(actions.start_time)}`));
+    lines.push(line(`Duration: ${dur(actions.duration_seconds)}`));
+    lines.push(`╠${BORDER}╣`);
+    const section = (title, items) => {
+        lines.push(line(`${title} (${items.length})`));
+        if (items.length === 0)
+            lines.push(line('  (none)'));
+        else
+            for (const item of items)
+                lines.push(line(`  ${item.slice(0, WIDTH - 6)}`));
+        lines.push(line(''));
+    };
+    section('FILES CREATED', actions.files_created);
+    section('FILES MODIFIED', actions.files_modified);
+    section('FILES DELETED', actions.files_deleted);
+    section('COMMANDS RUN', actions.commands_run);
+    section('URLS FETCHED', actions.urls_fetched);
+    section('PACKAGES INSTALLED', actions.packages_installed);
+    const body = lines.join('\n');
+    const sha256 = computeSha256(body);
+    lines.push(`╠${BORDER}╣`);
+    lines.push(line(`SHA256: ${sha256.slice(0, 36)}`));
+    lines.push(`╚${BORDER}╝`);
+    return lines.join('\n');
+}
+export function renderReceiptJson(actions) {
+    const body = JSON.stringify(actions, null, 2);
+    return { actions, sha256: computeSha256(body), generated_at: new Date().toISOString() };
+}
+// ── CheckResult adapter ──────────────────────────────────────────────────────
+export async function checkReceipt(cwd) {
+    const sessionFile = findLatestSession();
+    const issues = [];
+    if (!sessionFile) {
+        return {
+            name: 'receipt',
+            score: 10,
+            maxScore: 10,
+            issues: [{ severity: 'info', message: 'no claude session files found (~/.claude/projects/)', fixable: false }],
+            summary: 'no session logs found',
+        };
+    }
+    let toolUses = [];
+    let entries = [];
+    try {
+        const parsed = await parseSessionFile(sessionFile);
+        toolUses = parsed.toolUses;
+        entries = parsed.entries;
+    }
+    catch {
+        return {
+            name: 'receipt',
+            score: 10,
+            maxScore: 10,
+            issues: [{ severity: 'warning', message: 'could not parse session file', fixable: false }],
+            summary: 'session parse error',
+        };
+    }
+    const actions = groupActions(toolUses, entries, sessionFile);
+    // Audit observations
+    if (actions.commands_run.length > 20) {
+        issues.push({ severity: 'info', message: `${actions.commands_run.length} commands run in last session — high activity`, fixable: false });
+    }
+    if (actions.files_deleted.length > 0) {
+        issues.push({ severity: 'info', message: `${actions.files_deleted.length} file(s) deleted: ${actions.files_deleted.slice(0, 3).join(', ')}`, fixable: false });
+    }
+    if (actions.packages_installed.length > 0) {
+        issues.push({ severity: 'info', message: `packages installed: ${actions.packages_installed.join(', ')}`, fixable: false });
+    }
+    if (actions.urls_fetched.length > 5) {
+        issues.push({ severity: 'info', message: `${actions.urls_fetched.length} external URLs fetched`, fixable: false });
+    }
+    const totalActions = actions.files_created.length +
+        actions.files_modified.length +
+        actions.files_deleted.length +
+        actions.commands_run.length;
+    const sessionId = path.basename(sessionFile, '.jsonl').slice(0, 20);
+    return {
+        name: 'receipt',
+        score: 10, // Receipt is informational — always full score
+        maxScore: 10,
+        issues,
+        summary: `session ${sessionId}: ${totalActions} actions, ${actions.files_created.length} created, ${actions.files_modified.length} modified`,
+    };
+}
+// ── Standalone subcommand output ─────────────────────────────────────────────
+export async function runReceiptCommand(format = 'ascii') {
+    const sessionFile = findLatestSession();
+    if (!sessionFile) {
+        console.error('no claude session files found in ~/.claude/projects/');
+        process.exit(1);
+    }
+    const { toolUses, entries } = await parseSessionFile(sessionFile);
+    const actions = groupActions(toolUses, entries, sessionFile);
+    if (format === 'json') {
+        const receipt = renderReceiptJson(actions);
+        console.log(JSON.stringify(receipt, null, 2));
+    }
+    else {
+        console.log(renderReceiptText(actions));
+    }
+}

package/dist/checks/scan.d.ts

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

package/dist/checks/scan.js

@@ -0,0 +1,225 @@
+import { join, relative } from 'node:path';
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+const CRITICAL_PATTERNS = [
+    {
+        id: 'base64-url',
+        severity: 'critical',
+        description: 'Base64-encoded URL in config — potential exfiltration endpoint',
+        regex: /(?:aHR0c|data:text\/html;base64)/i,
+    },
+    {
+        id: 'curl-wget',
+        severity: 'critical',
+        description: 'Network download command in agent config — potential remote payload fetch',
+        regex: /(?:curl|wget|fetch)\s+(?:https?:\/\/|[-])/i,
+    },
+    {
+        id: 'shell-injection',
+        severity: 'critical',
+        description: 'Shell injection pattern — command substitution or eval/exec call',
+        regex: /\$\(|`[^`]+`|\beval\b|\bexec\b/,
+    },
+    {
+        id: 'powershell-download',
+        severity: 'critical',
+        description: 'PowerShell download cradle — remote code execution pattern',
+        regex: /powershell.*downloadstring|iex.*webclient/i,
+    },
+];
+const HIGH_PATTERNS = [
+    {
+        id: 'prompt-injection',
+        severity: 'high',
+        description: 'Prompt injection — instructs agent to ignore previous instructions',
+        regex: /ignore\s+(?:all\s+)?previous\s+instructions?/i,
+    },
+    {
+        id: 'system-prompt-override',
+        severity: 'high',
+        description: 'Attempts to override or replace the system prompt',
+        regex: /system\s*prompt\s*(?:override|replace|ignore)/i,
+    },
+    {
+        id: 'forget-prior',
+        severity: 'high',
+        description: 'Instructs agent to forget prior/previous context',
+        regex: /forget\s+(?:all\s+)?(?:prior|previous|earlier)/i,
+    },
+    {
+        id: 'env-var-exfiltration',
+        severity: 'high',
+        description: 'Env var referenced in URL context — potential key exfiltration',
+        regex: /https?:\/\/[^\s"']*\$(?:API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY)/i,
+    },
+    {
+        id: 'permission-escalation',
+        severity: 'high',
+        description: 'Attempts to escalate permissions — sudo, chmod 777, chown root',
+        regex: /sudo|chmod\s+777|chown\s+root/i,
+    },
+    {
+        id: 'hidden-file-write',
+        severity: 'high',
+        description: 'Redirects output to hidden dotfiles or system directories',
+        regex: />\s*~\/\.|>\s*\/etc\//i,
+    },
+];
+const INFO_PATTERNS = [
+    {
+        id: 'external-url',
+        severity: 'info',
+        description: 'External URL in config — often legitimate but worth reviewing',
+        regex: /https?:\/\/[^\s"']+/,
+    },
+    {
+        id: 'sensitive-path',
+        severity: 'info',
+        description: 'Reference to sensitive path (.ssh, .aws, .env, .gnupg)',
+        regex: /\.ssh|\.gnupg|\.aws|\.env/,
+    },
+];
+const ALL_SCAN_PATTERNS = [...CRITICAL_PATTERNS, ...HIGH_PATTERNS, ...INFO_PATTERNS];
+// ── Config file targets ──────────────────────────────────────────────────────
+const CONFIG_TARGETS = [
+    '.claude', 'CLAUDE.md', 'AGENTS.md',
+    '.cursorrules', '.cursor',
+    '.github',
+    '.aider.conf.yml',
+    '.continue',
+    '.mcp',
+    '.roomodes', '.roo',
+];
+// ── File helpers ─────────────────────────────────────────────────────────────
+function isTextFile(filePath) {
+    try {
+        const buf = readFileSync(filePath);
+        const sampleSize = Math.min(512, buf.length);
+        for (let i = 0; i < sampleSize; i++) {
+            if (buf[i] === 0)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function collectDirFiles(dir) {
+    const files = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isFile()) {
+                files.push(full);
+            }
+            else if (entry.isDirectory()) {
+                files.push(...collectDirFiles(full));
+            }
+        }
+    }
+    catch { /* skip */ }
+    return files;
+}
+function collectConfigFiles(cwd) {
+    const files = [];
+    for (const target of CONFIG_TARGETS) {
+        const full = join(cwd, target);
+        if (!existsSync(full))
+            continue;
+        try {
+            const s = statSync(full);
+            if (s.isFile()) {
+                files.push(full);
+            }
+            else if (s.isDirectory()) {
+                files.push(...collectDirFiles(full));
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Copilot instructions
+    const copilot = join(cwd, '.github', 'copilot-instructions.md');
+    if (existsSync(copilot) && !files.includes(copilot)) {
+        files.push(copilot);
+    }
+    return [...new Set(files)];
+}
+function scanContent(content, relPath) {
+    const findings = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of ALL_SCAN_PATTERNS) {
+            if (pattern.regex.test(line)) {
+                pattern.regex.lastIndex = 0;
+                findings.push({
+                    file: relPath,
+                    line: i + 1,
+                    severity: pattern.severity,
+                    description: pattern.description,
+                });
+            }
+            if (pattern.regex.global)
+                pattern.regex.lastIndex = 0;
+        }
+        // Special: base64 that decodes to URL
+        const b64Matches = line.match(/[A-Za-z0-9+/]{20,}={0,2}/g);
+        if (b64Matches) {
+            for (const m of b64Matches) {
+                try {
+                    const decoded = Buffer.from(m, 'base64').toString('utf-8');
+                    if (/https?:\/\//i.test(decoded) && !/[^\x00-\x7F]/.test(decoded)) {
+                        findings.push({
+                            file: relPath,
+                            line: i + 1,
+                            severity: 'critical',
+                            description: 'Base64 string decodes to HTTP URL — likely encoded exfiltration endpoint',
+                        });
+                        break;
+                    }
+                }
+                catch { /* skip */ }
+            }
+        }
+    }
+    return findings;
+}
+// ── CheckResult adapter ──────────────────────────────────────────────────────
+export function checkScan(cwd) {
+    const configFiles = collectConfigFiles(cwd);
+    const findings = [];
+    let filesScanned = 0;
+    for (const filePath of configFiles) {
+        if (!isTextFile(filePath))
+            continue;
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const relPath = relative(cwd, filePath);
+            filesScanned++;
+            findings.push(...scanContent(content, relPath));
+        }
+        catch { /* skip */ }
+    }
+    const issues = findings.map(f => ({
+        severity: f.severity === 'critical' ? 'error' : f.severity === 'high' ? 'warning' : 'info',
+        message: f.description,
+        file: f.file,
+        line: f.line,
+        fixable: false,
+    }));
+    const criticals = findings.filter(f => f.severity === 'critical').length;
+    const highs = findings.filter(f => f.severity === 'high').length;
+    const score = Math.max(0, Math.min(10, 10 - criticals * 4 - highs * 1.5));
+    return {
+        name: 'scan',
+        score: Math.round(score * 10) / 10,
+        maxScore: 10,
+        issues,
+        summary: filesScanned === 0
+            ? 'no agent config files found'
+            : findings.length === 0
+                ? `${filesScanned} config file${filesScanned !== 1 ? 's' : ''} scanned, clean`
+                : `${findings.length} finding${findings.length !== 1 ? 's' : ''} in ${filesScanned} config file${filesScanned !== 1 ? 's' : ''}`,
+    };
+}

package/dist/checks/secrets.d.ts

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