@guilz-dev/belay 0.1.0

package/dist/core/v2/overrides.js

@@ -0,0 +1,37 @@
+import { matchesCustomCommand } from '../custom-command-match.js';
+export function matchesCustomPatterns(command, segment, patterns) {
+    if (!patterns || patterns.length === 0) {
+        return false;
+    }
+    const normalized = command.trim();
+    return patterns.some((pattern) => matchesCustomCommand(normalized, segment.key, pattern) ||
+        matchesCustomCommand(segment.normalized, segment.key, pattern));
+}
+export function customAllowMatch(command, segment, context) {
+    return matchesCustomPatterns(command, segment, context.customAllowCommands);
+}
+export function customExternalMatch(command, segment, context) {
+    return matchesCustomPatterns(command, segment, context.customExternalCommands);
+}
+export function allowFromCustomOverride(opacity) {
+    return {
+        permission: 'allow',
+        location: 'repo_local',
+        opacity,
+        effect: 'unknown',
+        confidence: 'deterministic',
+        reason: 'custom_allow',
+        signals: ['custom_allow'],
+    };
+}
+export function askFromCustomExternal(opacity) {
+    return {
+        permission: 'ask',
+        location: 'external',
+        opacity,
+        effect: 'remote_mutation',
+        confidence: 'deterministic',
+        reason: 'custom_external',
+        signals: ['custom_external'],
+    };
+}

package/dist/core/v2/parser.d.ts

@@ -0,0 +1,21 @@
+import type { VerdictOpacity } from './types.js';
+export interface ParsedSegment {
+    tokens: string[];
+    head: string;
+    key: string;
+    normalized: string;
+}
+export declare function normalizeHead(token: string): string;
+export declare function peelTransparentWrappers(tokens: string[]): {
+    tokens: string[];
+    xargsStdinOpaque: boolean;
+};
+export declare function isVariableIndirectHead(head: string): boolean;
+export declare function extractEvalBody(tokens: string[]): string | null;
+export declare function extractRecursiveScript(tokens: string[]): string | null;
+export declare function isBareInterpreter(tokens: string[]): boolean;
+export declare function splitTopLevelSegments(command: string): string[];
+export declare function parseSegment(command: string): ParsedSegment;
+export declare function segmentOpacity(command: string): VerdictOpacity;
+export declare function substitutionInners(command: string): string[];
+export declare function redactCommand(command: string): string;

package/dist/core/v2/parser.js

@@ -0,0 +1,213 @@
+import path from 'node:path';
+import { findCommandSubstitutions } from '../shell-substitution.js';
+import { commandKey, tokenizeShell } from '../shell-tokenizer.js';
+import { detectUnparseableShell } from '../shell-unparseable.js';
+const ENV_PREFIX_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*=(?:'[^']*'|"[^"]*"|\S+)$/;
+const TRANSPARENT_WRAPPERS = new Set([
+    'sudo',
+    'env',
+    'nohup',
+    'time',
+    'nice',
+    'ionice',
+    'stdbuf',
+    'setsid',
+    'xargs',
+]);
+const SHELL_INTERPRETERS = new Set(['bash', 'sh', 'zsh', 'dash', 'fish']);
+const CODE_INTERPRETERS = new Set(['python', 'python3', 'node', 'ruby', 'perl', 'osascript']);
+const SCRIPT_FLAGS = new Set(['-c', '-lc', '-e', '--eval']);
+const INTERPRETER_SCRIPT_EXTENSIONS = new Set([
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.ts',
+    '.py',
+    '.rb',
+    '.pl',
+    '.sh',
+]);
+export function normalizeHead(token) {
+    const base = path.basename(token);
+    if (base && base !== '.' && base !== '..') {
+        return base;
+    }
+    return token;
+}
+export function peelTransparentWrappers(tokens) {
+    let current = [...tokens];
+    let xargsStdinOpaque = false;
+    while (current.length > 0) {
+        while (current.length > 0 && ENV_PREFIX_PATTERN.test(current[0] ?? '')) {
+            current.shift();
+        }
+        if (current.length === 0) {
+            break;
+        }
+        const head = normalizeHead(current[0] ?? '');
+        if (!TRANSPARENT_WRAPPERS.has(head)) {
+            break;
+        }
+        if (head === 'xargs') {
+            let index = 1;
+            while (index < current.length && current[index]?.startsWith('-')) {
+                index += 1;
+            }
+            const rest = current.slice(index);
+            if (rest.length === 0) {
+                xargsStdinOpaque = true;
+                return { tokens: [], xargsStdinOpaque: true };
+            }
+            current = rest;
+            continue;
+        }
+        if (head === 'env') {
+            let index = 1;
+            while (index < current.length) {
+                const token = current[index] ?? '';
+                if (ENV_PREFIX_PATTERN.test(token) || token.startsWith('-')) {
+                    index += 1;
+                    continue;
+                }
+                break;
+            }
+            current = current.slice(index);
+            continue;
+        }
+        current = current.slice(1);
+    }
+    return { tokens: current, xargsStdinOpaque };
+}
+export function isVariableIndirectHead(head) {
+    return head.startsWith('$');
+}
+export function extractEvalBody(tokens) {
+    const head = normalizeHead(tokens[0] ?? '');
+    if (head !== 'eval') {
+        return null;
+    }
+    const body = tokens.slice(1).join(' ').trim();
+    return body || null;
+}
+export function extractRecursiveScript(tokens) {
+    const filtered = tokens.filter((token) => token !== 'sudo');
+    const head = normalizeHead(filtered[0] ?? '');
+    const second = filtered[1] ?? '';
+    if (head === 'eval') {
+        return extractEvalBody(tokens);
+    }
+    if (SHELL_INTERPRETERS.has(head) || CODE_INTERPRETERS.has(head)) {
+        const flagIndex = filtered.findIndex((token) => SCRIPT_FLAGS.has(token));
+        if (flagIndex !== -1) {
+            const body = filtered
+                .slice(flagIndex + 1)
+                .join(' ')
+                .replace(/^['"]|['"]$/g, '')
+                .trim();
+            return body || null;
+        }
+    }
+    if (head === 'bash' && (second === '-lc' || second === '-c')) {
+        const body = filtered
+            .slice(2)
+            .join(' ')
+            .replace(/^['"]|['"]$/g, '')
+            .trim();
+        return body || null;
+    }
+    return null;
+}
+export function isBareInterpreter(tokens) {
+    const { tokens: peeled, xargsStdinOpaque } = peelTransparentWrappers(tokens);
+    if (xargsStdinOpaque) {
+        return true;
+    }
+    if (peeled.length === 0) {
+        return false;
+    }
+    const head = normalizeHead(peeled[0] ?? '');
+    if (!SHELL_INTERPRETERS.has(head) && !CODE_INTERPRETERS.has(head)) {
+        return false;
+    }
+    const hasScriptFlag = peeled.some((token) => SCRIPT_FLAGS.has(token));
+    if (hasScriptFlag) {
+        return false;
+    }
+    const args = peeled.slice(1);
+    if (args.length === 0) {
+        return true;
+    }
+    if (args.every((token) => token.startsWith('-'))) {
+        return false;
+    }
+    const scriptArg = args.find((token) => !token.startsWith('-'));
+    if (scriptArg && INTERPRETER_SCRIPT_EXTENSIONS.has(path.extname(scriptArg))) {
+        return false;
+    }
+    if (scriptArg) {
+        return false;
+    }
+    return true;
+}
+export function splitTopLevelSegments(command) {
+    const tokens = tokenizeShell(command);
+    const segments = [];
+    let current = [];
+    const flush = () => {
+        if (current.length > 0) {
+            segments.push(current.join(' '));
+            current = [];
+        }
+    };
+    for (const token of tokens) {
+        if (token === '&&' || token === '||' || token === ';' || token === '|' || token === '&') {
+            flush();
+            continue;
+        }
+        current.push(token);
+    }
+    flush();
+    return segments.filter((segment) => segment.trim().length > 0);
+}
+export function parseSegment(command) {
+    const tokens = tokenizeShell(command);
+    const { tokens: peeled } = peelTransparentWrappers(tokens);
+    const normalizedTokens = peeled.map((token) => normalizeHead(token));
+    const key = commandKey(peeled.map((token, index) => (index === 0 ? normalizeHead(token) : token)));
+    return {
+        tokens: peeled,
+        head: normalizeHead(peeled[0] ?? ''),
+        key,
+        normalized: normalizedTokens.join(' ').trim(),
+    };
+}
+export function segmentOpacity(command) {
+    if (detectUnparseableShell(command)) {
+        return 'unparseable';
+    }
+    const tokens = tokenizeShell(command);
+    const { xargsStdinOpaque } = peelTransparentWrappers(tokens);
+    if (xargsStdinOpaque) {
+        return 'opaque';
+    }
+    if (isBareInterpreter(tokens)) {
+        return 'opaque';
+    }
+    const segment = parseSegment(command);
+    if (isVariableIndirectHead(segment.head)) {
+        return 'opaque';
+    }
+    if (extractRecursiveScript(tokens)) {
+        return 'recursive';
+    }
+    return 'transparent';
+}
+export function substitutionInners(command) {
+    return findCommandSubstitutions(command);
+}
+export function redactCommand(command) {
+    return command
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [REDACTED]')
+        .replace(/sk-[A-Za-z0-9]{8,}/g, 'sk-[REDACTED]')
+        .trim();
+}

package/dist/core/v2/types.d.ts

@@ -0,0 +1,67 @@
+export type VerdictPermission = 'allow' | 'ask';
+export type VerdictLocation = 'repo_local' | 'repo_outside' | 'external' | 'mixed' | 'unknown';
+export type VerdictOpacity = 'transparent' | 'recursive' | 'opaque' | 'unparseable';
+export type VerdictEffect = 'read_only' | 'local_mutation' | 'remote_mutation' | 'unknown';
+export type VerdictConfidence = 'deterministic' | 'llm' | 'assumed_repo_local' | 'verified_substrate';
+export interface VerdictResult {
+    permission: VerdictPermission;
+    location: VerdictLocation;
+    opacity: VerdictOpacity;
+    effect: VerdictEffect;
+    confidence: VerdictConfidence;
+    reason: string;
+    commandRedacted: string;
+    fingerprint: string;
+    signals: string[];
+    judgeTrace?: JudgeTrace;
+}
+export interface Tier1Verdict {
+    external_change: boolean;
+    destroys_outside_repo: boolean;
+    destroys_history_or_secrets: boolean;
+    reason: string;
+}
+export interface Tier1EvaluateInput {
+    text: string;
+    context: {
+        cwd: string;
+        repoRoot: string;
+    };
+    innerCode?: string;
+}
+export interface Tier1Judge {
+    evaluate(input: Tier1EvaluateInput): Promise<Tier1Verdict>;
+}
+export interface JudgeTrace {
+    provider: 'openai-compatible' | 'ollama' | 'fallback';
+    modelRequested: string;
+    modelResolved: string;
+    latencyMs: number;
+    outboundRedacted?: boolean;
+    fallbackReason?: string;
+}
+export type VerdictMode = 'enforce' | 'audit';
+export interface VerdictContext {
+    cwd: string;
+    repoRoot: string;
+    trustedCwd: boolean;
+    sensitivePaths: string[];
+    protectedArtifactRoots?: string[];
+    customAllowCommands?: string[];
+    customExternalCommands?: string[];
+    judge: Tier1Judge;
+    mode: VerdictMode;
+    unknownLocalEffect: 'allow_flagged' | 'deny';
+    unparseableShell: 'allow_flagged' | 'deny';
+    maxRecursionDepth?: number;
+}
+export interface InternalSegmentVerdict {
+    permission: VerdictPermission;
+    location: VerdictLocation;
+    opacity: VerdictOpacity;
+    effect: VerdictEffect;
+    confidence: VerdictConfidence;
+    reason: string;
+    signals: string[];
+    judgeTrace?: JudgeTrace;
+}

package/dist/core/v2/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/v2/verdict.d.ts

@@ -0,0 +1,2 @@
+import type { VerdictContext, VerdictResult } from './types.js';
+export declare function verdict(command: string, context: VerdictContext): Promise<VerdictResult>;