codehere 0.8.0 → 1.0.2

package/dist/infrastructure/security/file-collection.js

@@ -1,118 +0,0 @@
-/**
- * Canonical file-collection rules for the trust scanner.
- *
- * Historic bug: IGNORE_DIRS and the test-file filter lived in three places
- * (trust-command, mcp-helpers, report-command) and drifted. The v0.3.0-alpha
- * shipreadiness fix patched two of them; report-command kept the old rules
- * and produced different finding counts than `trust` for the same directory.
- *
- * Single source of truth now — every scanner entry point imports from here.
- */
-import { readdirSync, statSync } from 'fs';
-import { join, extname } from 'path';
-export const CODE_EXTENSIONS = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.mjs',
-    '.cjs',
-    '.py',
-    '.rb',
-    '.go',
-    '.java',
-    '.cs',
-    '.php',
-    '.sh',
-    '.bash',
-    '.zsh',
-    '.sql',
-    '.html',
-    '.vue',
-    '.svelte',
-]);
-export const IGNORE_DIRS = new Set([
-    // JS/TS
-    'node_modules',
-    'dist',
-    'build',
-    '.next',
-    '.nuxt',
-    '.svelte-kit',
-    '.turbo',
-    '.parcel-cache',
-    // Python
-    'venv',
-    '__pycache__',
-    '.pytest_cache',
-    '.ruff_cache',
-    '.mypy_cache',
-    '.tox',
-    '__pypackages__',
-    // Rust / Go / PHP / Java / .NET
-    'target',
-    'vendor',
-    '.gradle',
-    'obj',
-    // VCS / tooling / coverage / codehere
-    '.git',
-    '.hg',
-    '.svn',
-    'coverage',
-    '.cache',
-    '.codehere',
-    '.codehere-cache',
-    // Cloned reference repos used for dogfooding / comparison — not the user's code.
-    // Codehere convention; mirrors how `.git` is hidden tooling-data, not source.
-    '.oss-repos',
-    // Test fixtures / mocks (intentionally-vulnerable code used as scanner inputs)
-    'fixtures',
-    'test-fixtures',
-    '__fixtures__',
-    '__mocks__',
-]);
-// Test files contain deliberate vulnerability patterns as scanner inputs —
-// SQL injection strings, hardcoded "credentials" etc. — that inflate the
-// finding count without being real production risks. Skip by default.
-export const TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/;
-export function shouldIgnoreDir(name) {
-    if (IGNORE_DIRS.has(name))
-        return true;
-    // Python virtualenv variants — .venv, .venv311, .venv-py3, venv3.11, env-py3
-    if (name.startsWith('.venv') || name.startsWith('venv'))
-        return true;
-    return false;
-}
-export function shouldIgnoreFile(name) {
-    return TEST_FILE_RE.test(name);
-}
-export function isCodeFile(name) {
-    return CODE_EXTENSIONS.has(extname(name)) && !shouldIgnoreFile(name);
-}
-/**
- * Walk a directory and return paths of code files worth scanning.
- * If `target` is a single file, it is returned as-is (explicit targets
- * are never excluded — user pointed at it on purpose).
- */
-export function collectCodeFiles(target) {
-    const stat = statSync(target);
-    if (stat.isFile())
-        return [target];
-    const files = [];
-    function walk(dir) {
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            if (shouldIgnoreDir(entry.name))
-                continue;
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(full);
-            }
-            else if (isCodeFile(entry.name)) {
-                files.push(full);
-            }
-        }
-    }
-    walk(target);
-    return files;
-}
-//# sourceMappingURL=file-collection.js.map

package/dist/infrastructure/security/input-validator.js

@@ -1,152 +0,0 @@
-/**
- * Infrastructure: Input Validator
- * Enterprise-grade input validation and sanitization
- *
- * Clean Architecture: Infrastructure Layer
- * Security: Prevents injection attacks, validates user input
- */
-/**
- * Validate file path to prevent directory traversal
- */
-export function validateFilePath(filepath) {
-    const errors = [];
-    // Check for directory traversal attempts
-    if (filepath.includes('..') || filepath.includes('~')) {
-        errors.push('Directory traversal detected in file path');
-    }
-    // Check for absolute paths (should be relative)
-    if (filepath.startsWith('/') || /^[A-Z]:\\/.test(filepath)) {
-        errors.push('Absolute paths not allowed');
-    }
-    // Check for null bytes
-    if (filepath.includes('\0')) {
-        errors.push('Null bytes not allowed in file path');
-    }
-    // Check for dangerous characters
-    const dangerousChars = /[<>:"|?*\x00-\x1f]/;
-    if (dangerousChars.test(filepath)) {
-        errors.push('Invalid characters in file path');
-    }
-    // Sanitize path
-    let sanitized = filepath
-        .replace(/\.\./g, '') // Remove ..
-        .replace(/~/g, '') // Remove ~
-        .replace(/\0/g, '') // Remove null bytes
-        .replace(/[<>:"|?*\x00-\x1f]/g, '_'); // Replace dangerous chars
-    // Normalize path separators
-    sanitized = sanitized.replace(/\\/g, '/');
-    return {
-        valid: errors.length === 0,
-        errors,
-        sanitized: errors.length > 0 ? sanitized : undefined,
-    };
-}
-/**
- * Validate query string to prevent injection
- */
-export function validateQuery(query) {
-    const errors = [];
-    // Check for null bytes
-    if (query.includes('\0')) {
-        errors.push('Null bytes not allowed in query');
-    }
-    // Check for command injection patterns
-    const commandInjectionPatterns = [
-        /[;&|`$(){}[\]]/, // Shell metacharacters
-        /<script/i, // XSS attempts
-        /javascript:/i, // JavaScript protocol
-        /on\w+\s*=/i, // Event handlers
-    ];
-    for (const pattern of commandInjectionPatterns) {
-        if (pattern.test(query)) {
-            errors.push('Potentially dangerous characters detected in query');
-            break;
-        }
-    }
-    // Sanitize query
-    let sanitized = query
-        .replace(/\0/g, '') // Remove null bytes
-        .replace(/[;&|`$(){}[\]]/g, '') // Remove shell metacharacters
-        .replace(/<script/gi, '&lt;script') // Escape script tags
-        .replace(/javascript:/gi, '') // Remove javascript protocol
-        .replace(/on\w+\s*=/gi, ''); // Remove event handlers
-    // Trim and limit length
-    sanitized = sanitized.trim();
-    const MAX_QUERY_LENGTH = 10000; // Reasonable limit
-    if (sanitized.length > MAX_QUERY_LENGTH) {
-        errors.push(`Query exceeds maximum length of ${MAX_QUERY_LENGTH} characters`);
-        sanitized = sanitized.substring(0, MAX_QUERY_LENGTH);
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        sanitized: errors.length > 0 ? sanitized : undefined,
-    };
-}
-/**
- * Validate API key format
- */
-export function validateAPIKey(apiKey) {
-    const errors = [];
-    if (!apiKey || apiKey.trim().length === 0) {
-        errors.push('API key is required');
-    }
-    // Check minimum length
-    if (apiKey.length < 10) {
-        errors.push('API key is too short');
-    }
-    // Check for null bytes
-    if (apiKey.includes('\0')) {
-        errors.push('Null bytes not allowed in API key');
-    }
-    // Check for whitespace (API keys shouldn't have spaces)
-    if (apiKey !== apiKey.trim()) {
-        errors.push('API key should not have leading or trailing whitespace');
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        sanitized: errors.length > 0 ? apiKey.trim() : undefined,
-    };
-}
-/**
- * Validate file content before processing
- */
-export function validateFileContent(content, maxSize = 10 * 1024 * 1024) {
-    const errors = [];
-    // Check size
-    const sizeInBytes = new Blob([content]).size;
-    if (sizeInBytes > maxSize) {
-        errors.push(`File content exceeds maximum size of ${maxSize} bytes`);
-    }
-    // Check for null bytes (shouldn't be in text files)
-    if (content.includes('\0')) {
-        errors.push('Null bytes detected in file content');
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}
-/**
- * Sanitize user input for logging (prevent sensitive data leakage)
- */
-export function sanitizeForLogging(input) {
-    // Remove potential secrets (API keys, tokens, etc.)
-    let sanitized = input
-        // Remove API keys (Cohere format: alphanumeric, 40+ chars)
-        .replace(/[A-Za-z0-9]{40,}/g, '[REDACTED]')
-        // Remove email addresses
-        .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL_REDACTED]')
-        // Remove potential tokens
-        .replace(/token[=:]\s*[A-Za-z0-9_-]+/gi, 'token=[REDACTED]')
-        .replace(/password[=:]\s*[^\s]+/gi, 'password=[REDACTED]')
-        .replace(/secret[=:]\s*[^\s]+/gi, 'secret=[REDACTED]');
-    // Limit length for logging
-    const MAX_LOG_LENGTH = 1000;
-    if (sanitized.length > MAX_LOG_LENGTH) {
-        sanitized = sanitized.substring(0, MAX_LOG_LENGTH) + '...[TRUNCATED]';
-    }
-    return sanitized;
-}
-//# sourceMappingURL=input-validator.js.map

package/dist/infrastructure/security/permissions-config.js

@@ -1,234 +0,0 @@
-/**
- * Per-cwd permissions config — P18 slice 1 primitive.
- *
- * Reads `.codehere/permissions.yaml` from a project's cwd and lets the
- * trust-scorer SKIP findings whose matched text fits an allow pattern.
- *
- * Use case: codehere blocks `rm -rf node_modules` because the pattern
- * matches `rm -rf /`. The user knows it's safe in THIS cwd. They run
- * `codehere permission allow "rm -rf node_modules"` (slice 2 CLI) and
- * future blocks for that exact pattern in this cwd are skipped.
- *
- * Schema (.codehere/permissions.yaml):
- *
- *   allow:
- *     - pattern: "rm -rf node_modules"
- *       reason: "OK to nuke deps in this repo"
- *       addedAt: 2026-05-08T20:00:00Z
- *     - pattern: "ANTHROPIC_API_KEY"
- *       reason: "Doc explains env vars; not actually leaking"
- *
- * Allow patterns are STRINGS not regex — exact substring match against
- * the audit-finding `matched` field. Keeps the schema simple +
- * non-technical-user friendly. Regex support is a v0.7 follow-up.
- *
- * Per claim_user_persona HIGH: the YAML is human-readable; non-
- * technical users can edit it directly. Per overconfidence-guard:
- * we DON'T claim the allow-list is "secure" — it's user CONSENT,
- * not codehere certification.
- */
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-const EMPTY = { allow: [], deny: [] };
-/**
- * Load .codehere/permissions.yaml from a cwd. Returns empty config if
- * the file doesn't exist or fails to parse. Defensive: never throws —
- * caller treats absence as "no overrides", which is the safest default
- * (the scanner blocks normally).
- */
-export function loadPermissions(cwd) {
-    if (!cwd || typeof cwd !== 'string')
-        return EMPTY;
-    const file = join(cwd, '.codehere', 'permissions.yaml');
-    if (!existsSync(file))
-        return EMPTY;
-    let raw;
-    try {
-        raw = readFileSync(file, 'utf-8');
-    }
-    catch {
-        return EMPTY;
-    }
-    return parsePermissionsYaml(raw);
-}
-/**
- * Tiny YAML subset parser — only handles the shape this file uses
- * (top-level allow/deny lists of {pattern, reason, addedAt} objects).
- * No external dep; the codehere repo already avoids the `yaml` package
- * for read paths to keep cold-start fast. Format errors yield empty
- * config (same posture as missing file).
- */
-export function parsePermissionsYaml(raw) {
-    const cfg = { allow: [], deny: [] };
-    let bucket = null;
-    let pending = null;
-    for (const line of raw.split('\n')) {
-        const stripped = line.replace(/#.*$/, '').trimEnd();
-        if (!stripped.trim())
-            continue;
-        // Top-level key: "allow:" or "deny:"
-        const top = stripped.match(/^(allow|deny)\s*:\s*$/);
-        if (top) {
-            // Flush any pending entry into the previous bucket
-            if (pending && bucket && pending.pattern)
-                cfg[bucket].push(pending);
-            pending = null;
-            bucket = top[1];
-            continue;
-        }
-        if (!bucket)
-            continue;
-        // List entry start: "  - pattern: ..."
-        const listStart = stripped.match(/^\s*-\s+pattern\s*:\s*(.+)$/);
-        if (listStart) {
-            if (pending && pending.pattern)
-                cfg[bucket].push(pending);
-            pending = { pattern: unquote(listStart[1]) };
-            continue;
-        }
-        // Continuation field on a pending entry
-        const cont = stripped.match(/^\s+(reason|addedAt)\s*:\s*(.+)$/);
-        if (cont && pending) {
-            const key = cont[1];
-            pending[key] = unquote(cont[2]);
-        }
-    }
-    if (pending && bucket && pending.pattern)
-        cfg[bucket].push(pending);
-    return cfg;
-}
-function unquote(s) {
-    const t = s.trim();
-    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
-        return t.slice(1, -1);
-    }
-    return t;
-}
-/**
- * Check whether a finding's matched text is allow-listed in this cwd.
- * Substring match — exact-text patterns are simpler for non-technical
- * users than regex. Returns the matching entry (for audit-trail
- * provenance) or null if no match.
- */
-export function isAllowed(matchedText, cwd) {
-    const cfg = loadPermissions(cwd);
-    for (const entry of cfg.allow) {
-        if (entry.pattern && matchedText.includes(entry.pattern))
-            return entry;
-    }
-    return null;
-}
-/**
- * Filter a findings list against the allow-list for a cwd. Returns
- * the findings that survived (i.e., were NOT allow-listed). Used by
- * the trust-scorer / pre-prompt-scan to drop findings that the user
- * has explicitly approved.
- *
- * Side-effect-free: the allow-listed findings are dropped from the
- * caller's perspective. The audit log writer can still record the
- * full finding list IF the caller wants (then mark which were
- * allow-listed). This function is the simple "what should we still
- * block on" filter.
- */
-export function filterAllowed(findings, cwd) {
-    if (findings.length === 0)
-        return { surviving: [], allowed: [] };
-    const cfg = loadPermissions(cwd);
-    if (cfg.allow.length === 0)
-        return { surviving: findings, allowed: [] };
-    const surviving = [];
-    const allowed = [];
-    for (const f of findings) {
-        const hit = cfg.allow.find((e) => e.pattern && f.matched.includes(e.pattern));
-        if (hit)
-            allowed.push({ finding: f, entry: hit });
-        else
-            surviving.push(f);
-    }
-    return { surviving, allowed };
-}
-// ── Write surface (P18 slice 3) ─────────────────────────────────────────────
-// Shared by the CLI (`codehere permission allow ...`) and the HTTP write
-// endpoint (POST /api/permissions). Single source of truth for the
-// idempotent-add semantics + the YAML serializer.
-import { mkdirSync, writeFileSync } from 'fs';
-/**
- * Idempotent add — if the pattern already exists in the bucket, returns
- * status='already_present' with the existing entry. Otherwise appends +
- * writes the file. Writes via Write tool semantics (overwrites the
- * whole YAML each time; entries are O(N) so re-serialization is cheap).
- */
-export function addPermissionEntry(input) {
-    const bucket = input.bucket ?? 'allow';
-    const cfg = loadPermissions(input.cwd);
-    const list = cfg[bucket];
-    const existing = list.find((e) => e.pattern === input.pattern);
-    if (existing) {
-        return {
-            status: 'already_present',
-            bucket,
-            entry: existing,
-            filePath: join(input.cwd, '.codehere', 'permissions.yaml'),
-        };
-    }
-    const entry = {
-        pattern: input.pattern,
-        ...(input.reason ? { reason: input.reason } : {}),
-        addedAt: new Date().toISOString(),
-    };
-    cfg[bucket].push(entry);
-    const filePath = writePermissionsConfig(input.cwd, cfg);
-    return { status: 'added', bucket, entry, filePath };
-}
-/**
- * Idempotent remove — drops every entry whose pattern matches across
- * BOTH buckets. Returns count of removed entries.
- */
-export function removePermissionEntry(cwd, pattern) {
-    const cfg = loadPermissions(cwd);
-    const before = cfg.allow.length + cfg.deny.length;
-    cfg.allow = cfg.allow.filter((e) => e.pattern !== pattern);
-    cfg.deny = cfg.deny.filter((e) => e.pattern !== pattern);
-    const after = cfg.allow.length + cfg.deny.length;
-    const removed = before - after;
-    if (removed > 0)
-        writePermissionsConfig(cwd, cfg);
-    return { removed, filePath: join(cwd, '.codehere', 'permissions.yaml') };
-}
-function writePermissionsConfig(cwd, cfg) {
-    const dir = join(cwd, '.codehere');
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const filePath = join(dir, 'permissions.yaml');
-    writeFileSync(filePath, serializePermissionsYaml(cfg), 'utf-8');
-    return filePath;
-}
-export function serializePermissionsYaml(cfg) {
-    const out = [];
-    out.push('# codehere permissions — per-folder allow/deny list');
-    out.push('# See: codehere permission --help');
-    out.push('');
-    for (const bucket of ['allow', 'deny']) {
-        out.push(`${bucket}:`);
-        if (cfg[bucket].length === 0) {
-            out.push('  []');
-        }
-        else {
-            for (const e of cfg[bucket]) {
-                out.push(`  - pattern: ${quoteYaml(e.pattern)}`);
-                if (e.reason)
-                    out.push(`    reason: ${quoteYaml(e.reason)}`);
-                if (e.addedAt)
-                    out.push(`    addedAt: ${quoteYaml(e.addedAt)}`);
-            }
-        }
-        out.push('');
-    }
-    return out.join('\n');
-}
-function quoteYaml(s) {
-    if (s.includes('"') && !s.includes("'"))
-        return `'${s}'`;
-    return `"${s.replace(/"/g, '\\"')}"`;
-}
-//# sourceMappingURL=permissions-config.js.map