@guilz-dev/belay 0.9.2 → 0.9.3

package/dist/core/effect-ir/shell-lower.js

@@ -2,11 +2,12 @@ import { lstatSync, realpathSync } from 'node:fs';
 import path from 'node:path';
 import { inspectGitResourceIdentity } from '../git-resource-identity.js';
 import { canonicalPath, pathWithinRoot } from '../path-utils.js';
-import { isFdDuplication, isRedirectOperator, tokenizeShell } from '../shell-tokenizer.js';
+import { isFdDuplication, isRedirectOperator, lexShell, tokenizeShell, } from '../shell-tokenizer.js';
+import { decodeDockerComposeRun as decodeStructuredDockerComposeRun } from '../verdict/docker-compose-run.js';
 import { decodeEgressEffects } from '../verdict/egress-classify.js';
 import { decodeGitEffects } from '../verdict/git-classifier.js';
 import { resolveLauncherRecipe } from '../verdict/launcher-resolve.js';
-import { extractDockerComposeRunScript, extractRecursiveScript, isCommandInspection, isDynamicRecursiveEvaluation, parseSegment, redactCommand, segmentOpacity, splitStructuralShellSegments, structuralSubstitutionInners, } from '../verdict/parser.js';
+import { decodeRecursiveInvocationTokens, isCommandInspection, parseSegment, redactCommand, segmentOpacity, splitStructuralShellSegments, structuralSubstitutionInners, } from '../verdict/parser.js';
 import { joinEffectOpacity } from './normalize.js';
 import { classifyPackageAcquisitionSpec, innerRecipeFromPeel, peelPackageExecArgv, resolveLocalBin, } from './package-exec.js';
 import { buildShellEffectPlan, } from './shell-build.js';
@@ -127,7 +128,8 @@ function joinNestedOpacity(outer, nested) {
 }
 function lowerSegment(command, context) {
     const commandRedacted = redactCommand(command);
-    const rawTokens = tokenizeShell(command);
+    const lexed = lexShell(command);
+    const rawTokens = lexed.tokens.map((token) => token.value);
     const environment = extractEnvironment(rawTokens, context.env);
     const env = environment.env;
     const parsed = parseSegment(command);
@@ -137,10 +139,18 @@ function lowerSegment(command, context) {
         rawTokens.every((token) => ENV_PREFIX_PATTERN.test(token))
         ? rawTokens
         : parsedTokens).map((token) => expandKnownVariables(token, env));
+    const decoderTokens = alignStructuredTokens(stripStructuredRedirects(lexed.tokens), stripRedirects(parsedTokens));
     const head = path.basename(tokens[0] ?? parsed.head);
     let opacity = segmentOpacity(command);
     const signals = new Set();
     const requirements = [];
+    if (!lexed.complete) {
+        requirements.push(requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
+            'shell.grammar_incomplete',
+        ]));
+        signals.add('shell.grammar_incomplete');
+        opacity = joinEffectOpacity(opacity, 'unparseable');
+    }
     addRedirectEffects(requirements, rawTokens, env, context, commandRedacted);
     addSubstitutionEffects(requirements, command, context, commandRedacted, signals);
     if (environment.malformed) {
@@ -156,7 +166,7 @@ function lowerSegment(command, context) {
         signals.add('shell.xargs_stdin_dynamic');
         opacity = joinEffectOpacity(opacity, 'opaque');
     }
-    if (context.depth >= MAX_LOWER_DEPTH) {
+    if (context.depth > MAX_LOWER_DEPTH) {
         requirements.push(requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
             'shell.lower_depth_exceeded',
         ]));
@@ -191,50 +201,69 @@ function lowerSegment(command, context) {
         }
         return shellSegment(commandRedacted, head, requirements, opacity, signals);
     }
-    const recursiveScript = extractRecursiveScript(tokens);
-    if (recursiveScript && opacity !== 'opaque' && opacity !== 'unparseable') {
-        const dynamicEvaluation = isDynamicRecursiveEvaluation(tokens);
-        requirements.push(processRequirement(head || 'sh', 'spawn', commandRedacted, [
+    const recursive = decodeRecursiveInvocationTokens(decoderTokens);
+    if (recursive.kind === 'static' && opacity !== 'opaque' && opacity !== 'unparseable') {
+        requirements.push(processRequirement(recursive.interpreter, 'spawn', commandRedacted, [
             'shell.recursive_wrapper',
-            ...(dynamicEvaluation ? ['dynamic_shell_evaluation'] : []),
+            'dynamic_shell_evaluation',
         ]));
-        const nested = lowerTopLevelSegments(recursiveScript, {
-            ...context,
-            command: recursiveScript,
-            env,
-            depth: context.depth + 1,
-        });
-        for (const nestedSegment of nested) {
-            requirements.push(...nestedSegment.requirements.map((entry) => withInnerProvenance(entry, recursiveScript, head, commandRedacted)));
-            for (const signal of nestedSegment.signals) {
-                signals.add(signal);
+        if (recursive.script !== '') {
+            const nested = lowerTopLevelSegments(recursive.script, {
+                ...context,
+                command: recursive.script,
+                env,
+                depth: context.depth + 1,
+            });
+            for (const nestedSegment of nested) {
+                requirements.push(...nestedSegment.requirements.map((entry) => withInnerProvenance(entry, recursive.script, head, commandRedacted)));
+                for (const signal of nestedSegment.signals)
+                    signals.add(signal);
             }
         }
         signals.add('shell.recursive_wrapper');
-        if (dynamicEvaluation) {
-            signals.add('dynamic_shell_evaluation');
-        }
+        signals.add('dynamic_shell_evaluation');
         return shellSegment(commandRedacted, head, requirements, 'recursive', signals);
     }
-    const dockerComposeScript = extractDockerComposeRunScript(tokens);
-    if (dockerComposeScript && opacity !== 'opaque' && opacity !== 'unparseable') {
+    if (recursive.kind === 'dynamic' || recursive.kind === 'indeterminate') {
+        const recursiveSignals = [
+            recursive.signal,
+            ...(recursive.kind === 'dynamic' ? ['dynamic_shell_evaluation'] : []),
+        ];
+        requirements.push(processRequirement(recursive.interpreter, 'spawn', commandRedacted, recursiveSignals), requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
+            ...recursiveSignals,
+        ]));
+        for (const signal of recursiveSignals)
+            signals.add(signal);
+        return shellSegment(commandRedacted, head, requirements, joinEffectOpacity(opacity, 'opaque'), signals);
+    }
+    const compose = decodeStructuredDockerComposeRun(decoderTokens);
+    if (compose.kind === 'recursive' && opacity !== 'opaque' && opacity !== 'unparseable') {
         requirements.push(processRequirement(head, 'spawn', commandRedacted, ['process.docker_compose_run']));
-        const nested = lowerTopLevelSegments(dockerComposeScript, {
-            ...context,
-            command: dockerComposeScript,
-            env,
-            depth: context.depth + 1,
-        });
-        for (const nestedSegment of nested) {
-            requirements.push(...nestedSegment.requirements.map((entry) => withInnerProvenance(entry, dockerComposeScript, head, commandRedacted)));
-            for (const signal of nestedSegment.signals) {
-                signals.add(signal);
+        if (compose.script !== '') {
+            const nested = lowerTopLevelSegments(compose.script, {
+                ...context,
+                command: compose.script,
+                env,
+                depth: context.depth + 1,
+            });
+            for (const nestedSegment of nested) {
+                requirements.push(...nestedSegment.requirements.map((entry) => withInnerProvenance(entry, compose.script, head, commandRedacted)));
+                for (const signal of nestedSegment.signals)
+                    signals.add(signal);
+                opacity = joinNestedOpacity(opacity, nestedSegment);
             }
-            opacity = joinNestedOpacity(opacity, nestedSegment);
         }
         signals.add('process.docker_compose_run');
         return shellSegment(commandRedacted, head, requirements, 'recursive', signals);
     }
+    if (compose.kind === 'dynamic' || compose.kind === 'indeterminate') {
+        requirements.push(processRequirement(head, 'spawn', commandRedacted, ['process.docker_compose_run']), requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, commandRedacted, [
+            compose.signal,
+        ]));
+        signals.add('process.docker_compose_run');
+        signals.add(compose.signal);
+        return shellSegment(commandRedacted, head, requirements, joinEffectOpacity(opacity, 'opaque'), signals);
+    }
     const launcher = resolveLauncherRecipe({
         tokens,
         cwd: context.cwd,
@@ -1337,15 +1366,39 @@ function stripRedirects(tokens) {
             stripped.push(token);
             continue;
         }
-        if (token.includes('>') || token.includes('<')) {
-            const inline = token.replace(/^\d*(?:>>?|<<?|<>|>\|)/, '');
-            if (!inline) {
-                index += 1;
-            }
+        index += 1;
+    }
+    return stripped;
+}
+function stripStructuredRedirects(tokens) {
+    const stripped = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (!token)
+            continue;
+        if (isFdDuplication(token.value)) {
+            continue;
         }
+        if (!isRedirectOperator(token.value)) {
+            stripped.push(token);
+            continue;
+        }
+        index += 1;
     }
     return stripped;
 }
+function alignStructuredTokens(tokens, values) {
+    if (values.length === 0)
+        return [];
+    for (let start = tokens.length - values.length; start >= 0; start -= 1) {
+        const candidate = tokens.slice(start);
+        if (candidate.length === values.length &&
+            candidate.every((token, index) => token.value === values[index])) {
+            return candidate;
+        }
+    }
+    return [];
+}
 function shellSegment(commandRedacted, segmentHead, requirements, opacity, signals) {
     const normalizedRequirements = requirements.flatMap((entry) => {
         const dynamicSignal = dynamicResourceSignal(entry.resource);

package/dist/core/replay-scrub.d.ts

@@ -1,5 +1,6 @@
 import type { GatedActionKind } from './gate-contract.js';
 import type { ScrubOptions } from './types.js';
+export declare function redactToolInvocationId(value: unknown, rawToolUseId?: string): unknown;
 /** Subagent fingerprint input — must match classify-subagent `fingerprintSource`. */
 export declare function subagentFingerprintSource(payload: Record<string, unknown>, scrubOptions: ScrubOptions): unknown;
 /**

package/dist/core/replay-scrub.js

@@ -1,4 +1,22 @@
 import { scrubValue } from './scrub.js';
+export function redactToolInvocationId(value, rawToolUseId) {
+    if (typeof value === 'string') {
+        return rawToolUseId ? value.replaceAll(rawToolUseId, '<tool-use-id>') : value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactToolInvocationId(item, rawToolUseId));
+    }
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (key !== 'tool_use_id') {
+                result[key] = redactToolInvocationId(child, rawToolUseId);
+            }
+        }
+        return result;
+    }
+    return value;
+}
 /** Subagent fingerprint input — must match classify-subagent `fingerprintSource`. */
 export function subagentFingerprintSource(payload, scrubOptions) {
     const toolInput = payload.tool_input;
@@ -30,14 +48,15 @@ export function fingerprintReplayPayload(kind, payload, scrubOptions) {
     if (!payload) {
         return undefined;
     }
+    const replayPayload = redactToolInvocationId(payload, typeof payload.tool_use_id === 'string' ? payload.tool_use_id : undefined);
     if (kind === 'tool') {
-        const toolInput = payload.tool_input;
+        const toolInput = replayPayload.tool_input;
         if (toolInput && typeof toolInput === 'object') {
             return scrubValue(toolInput, scrubOptions);
         }
     }
     if (kind === 'subagent') {
-        return subagentFingerprintSource(payload, scrubOptions);
+        return subagentFingerprintSource(replayPayload, scrubOptions);
     }
-    return scrubValue(payload, scrubOptions);
+    return scrubValue(replayPayload, scrubOptions);
 }

package/dist/core/shell-tokenizer.d.ts

@@ -1,5 +1,33 @@
 export declare function isRedirectOperator(token: string): boolean;
 export declare function isFdDuplication(token: string): boolean;
+export type ShellQuoteMode = 'unquoted' | 'single' | 'double';
+export interface ShellWordPart {
+    value: string;
+    raw: string;
+    start: number;
+    end: number;
+    quote: ShellQuoteMode;
+    hasExpansion: boolean;
+}
+export type ShellToken = {
+    kind: 'word';
+    value: string;
+    raw: string;
+    start: number;
+    end: number;
+    parts: ShellWordPart[];
+} | {
+    kind: 'operator';
+    value: string;
+    raw: string;
+    start: number;
+    end: number;
+};
+export interface ShellLexResult {
+    tokens: ShellToken[];
+    complete: boolean;
+}
+export declare function lexShell(input: string): ShellLexResult;
 export declare function tokenizeShell(input: string): string[];
 export declare function normalizeShellCommand(command: string, repoRoot: string, normalizeToken: (t: string, r: string) => string): string;
 export declare function splitTopLevelSegments(tokens: string[]): string[][];

package/dist/core/shell-tokenizer.js

@@ -67,61 +67,143 @@ export function isRedirectOperator(token) {
 export function isFdDuplication(token) {
     return FD_DUPLICATION_PATTERN.test(token);
 }
-export function tokenizeShell(input) {
+export function lexShell(input) {
     const tokens = [];
-    let buffer = '';
+    let value = '';
+    let wordStart = null;
+    let parts = [];
     let quote = null;
-    let escaping = false;
-    const flush = () => {
-        if (buffer.length > 0) {
-            tokens.push(buffer);
-            buffer = '';
+    let quoteStart = -1;
+    let quoteHadContent = false;
+    let complete = true;
+    const startWord = (index) => {
+        wordStart ??= index;
+    };
+    const append = (decoded, start, end, mode, hasExpansion) => {
+        startWord(start);
+        value += decoded;
+        const previous = parts.at(-1);
+        if (previous &&
+            previous.quote === mode &&
+            previous.hasExpansion === hasExpansion &&
+            previous.end === start) {
+            previous.value += decoded;
+            previous.raw += input.slice(start, end);
+            previous.end = end;
+            return;
         }
+        parts.push({
+            value: decoded,
+            raw: input.slice(start, end),
+            start,
+            end,
+            quote: mode,
+            hasExpansion,
+        });
+    };
+    const flushWord = (end) => {
+        if (wordStart === null)
+            return;
+        tokens.push({
+            kind: 'word',
+            value,
+            raw: input.slice(wordStart, end),
+            start: wordStart,
+            end,
+            parts,
+        });
+        value = '';
+        wordStart = null;
+        parts = [];
+    };
+    const pushOperator = (token, start, end) => {
+        tokens.push({ kind: 'operator', value: token, raw: input.slice(start, end), start, end });
     };
     for (let index = 0; index < input.length; index += 1) {
-        const char = input[index];
-        if (escaping) {
-            buffer += char;
-            escaping = false;
-            continue;
-        }
-        if (char === '\\') {
-            escaping = true;
+        const char = input[index] ?? '';
+        if (quote === 'single') {
+            if (char === "'") {
+                if (!quoteHadContent)
+                    append('', quoteStart, index + 1, 'single', false);
+                quote = null;
+            }
+            else {
+                append(char, index, index + 1, 'single', false);
+                quoteHadContent = true;
+            }
             continue;
         }
-        if (quote) {
-            if (char === quote) {
+        if (quote === 'double') {
+            if (char === '"') {
+                if (!quoteHadContent)
+                    append('', quoteStart, index + 1, 'double', false);
                 quote = null;
+                continue;
             }
-            else {
-                buffer += char;
+            if (char === '\\') {
+                const next = input[index + 1];
+                if (next === undefined) {
+                    append('\\', index, index + 1, 'double', false);
+                    complete = false;
+                    continue;
+                }
+                if (next === '$' || next === '`' || next === '"' || next === '\\' || next === '\n') {
+                    append(next === '\n' ? '' : next, index, index + 2, 'double', false);
+                    quoteHadContent = true;
+                    index += 1;
+                    continue;
+                }
+                append('\\', index, index + 1, 'double', false);
+                quoteHadContent = true;
+                continue;
             }
+            append(char, index, index + 1, 'double', char === '$' || char === '`');
+            quoteHadContent = true;
             continue;
         }
-        if (char === '"' || char === "'") {
-            quote = char;
+        if (char === "'" || char === '"') {
+            startWord(index);
+            quote = char === "'" ? 'single' : 'double';
+            quoteStart = index;
+            quoteHadContent = false;
+            continue;
+        }
+        if (char === '\\') {
+            const next = input[index + 1];
+            if (next === undefined) {
+                append('\\', index, index + 1, 'unquoted', false);
+                complete = false;
+                continue;
+            }
+            append(next, index, index + 2, 'unquoted', false);
+            index += 1;
             continue;
         }
         const operator = readShellOperator(input, index);
         if (operator) {
-            flush();
-            tokens.push(operator.token);
+            flushWord(index);
+            pushOperator(operator.token, index, index + operator.length);
             index += operator.length - 1;
             continue;
         }
         if (char === '\n' || char === '\r') {
-            flush();
-            tokens.push(';');
+            flushWord(index);
+            pushOperator(';', index, index + 1);
             continue;
         }
         if (/\s/.test(char)) {
-            flush();
+            flushWord(index);
             continue;
         }
-        buffer += char;
+        append(char, index, index + 1, 'unquoted', char === '$' || char === '`');
     }
-    flush();
-    return tokens;
+    if (quote !== null)
+        complete = false;
+    flushWord(input.length);
+    return { tokens, complete };
+}
+export function tokenizeShell(input) {
+    return lexShell(input).tokens.map((token) => token.value);
 }
 export function normalizeShellCommand(command, repoRoot, normalizeToken) {
     const tokens = tokenizeShell(command);

package/dist/core/verdict/docker-compose-run.d.ts

@@ -0,0 +1,18 @@
+import type { ShellToken } from '../shell-tokenizer.js';
+export type DockerComposeRunInvocation = {
+    kind: 'recursive';
+    service: string;
+    interpreter: string;
+    script: string;
+} | {
+    kind: 'dynamic';
+    service: string;
+    signal: string;
+} | {
+    kind: 'none';
+} | {
+    kind: 'indeterminate';
+    signal: 'shell.compose_argv_indeterminate';
+};
+export declare function decodeDockerComposeRun(tokens: readonly ShellToken[]): DockerComposeRunInvocation;
+export declare function decodeDockerComposeRunValues(values: readonly string[]): DockerComposeRunInvocation;

package/dist/core/verdict/docker-compose-run.js

@@ -0,0 +1,136 @@
+import path from 'node:path';
+import { decodeRecursiveInvocation, shellTokensFromValues } from './recursive-invocation.js';
+const COMPOSE_GLOBAL_OPTIONS = new Map([
+    ['--all-resources', 0],
+    ['--ansi', 1],
+    ['--compatibility', 0],
+    ['--dry-run', 0],
+    ['--env-file', 1],
+    ['-f', 1],
+    ['--file', 1],
+    ['--parallel', 1],
+    ['--profile', 1],
+    ['--progress', 1],
+    ['--project-directory', 1],
+    ['-p', 1],
+    ['--project-name', 1],
+]);
+const COMPOSE_RUN_OPTIONS = new Map([
+    ['--build', 0],
+    ['--cap-add', 1],
+    ['--cap-drop', 1],
+    ['-d', 0],
+    ['--detach', 0],
+    ['--entrypoint', 1],
+    ['-e', 1],
+    ['--env', 1],
+    ['--env-from-file', 1],
+    ['-i', 0],
+    ['--interactive', 0],
+    ['-l', 1],
+    ['--label', 1],
+    ['--name', 1],
+    ['--no-deps', 0],
+    ['-T', 0],
+    ['--no-tty', 0],
+    ['-p', 1],
+    ['--publish', 1],
+    ['--pull', 1],
+    ['-q', 0],
+    ['--quiet', 0],
+    ['--quiet-build', 0],
+    ['--quiet-pull', 0],
+    ['--remove-orphans', 0],
+    ['--rm', 0],
+    ['-P', 0],
+    ['--service-ports', 0],
+    ['--use-aliases', 0],
+    ['-u', 1],
+    ['--user', 1],
+    ['-v', 1],
+    ['--volume', 1],
+    ['-w', 1],
+    ['--workdir', 1],
+]);
+function parseOptions(words, start, options) {
+    let index = start;
+    while (index < words.length) {
+        const value = words[index]?.value ?? '';
+        if (value === '--')
+            return { kind: 'ok', index: index + 1 };
+        if (!value.startsWith('-') || value === '-')
+            return { kind: 'ok', index };
+        const equalsIndex = value.indexOf('=');
+        const name = equalsIndex === -1 ? value : value.slice(0, equalsIndex);
+        const arity = options.get(name);
+        if (arity === undefined)
+            return { kind: 'indeterminate' };
+        if (equalsIndex !== -1) {
+            if (!value.startsWith('--') || arity !== 1 || equalsIndex === value.length - 1) {
+                return { kind: 'indeterminate' };
+            }
+            index += 1;
+            continue;
+        }
+        if (arity === 1) {
+            if (!words[index + 1])
+                return { kind: 'indeterminate' };
+            index += 2;
+            continue;
+        }
+        index += 1;
+    }
+    return { kind: 'ok', index };
+}
+export function decodeDockerComposeRun(tokens) {
+    if (tokens.some((token) => token.kind === 'operator'))
+        return { kind: 'none' };
+    const words = tokens.filter((token) => token.kind === 'word');
+    const head = path.basename(words[0]?.value ?? '');
+    let index;
+    if (head === 'docker-compose') {
+        index = 1;
+    }
+    else if (head === 'docker' && words[1]?.value === 'compose') {
+        index = 2;
+    }
+    else {
+        return { kind: 'none' };
+    }
+    const globalOptions = parseOptions(words, index, COMPOSE_GLOBAL_OPTIONS);
+    if (globalOptions.kind === 'indeterminate') {
+        return { kind: 'indeterminate', signal: 'shell.compose_argv_indeterminate' };
+    }
+    index = globalOptions.index;
+    if (words[index]?.value !== 'run')
+        return { kind: 'none' };
+    const runOptions = parseOptions(words, index + 1, COMPOSE_RUN_OPTIONS);
+    if (runOptions.kind === 'indeterminate') {
+        return { kind: 'indeterminate', signal: 'shell.compose_argv_indeterminate' };
+    }
+    index = runOptions.index;
+    const service = words[index]?.value;
+    if (!service)
+        return { kind: 'indeterminate', signal: 'shell.compose_argv_indeterminate' };
+    const command = words.slice(index + 1);
+    if (command.length === 0)
+        return { kind: 'none' };
+    const recursive = decodeRecursiveInvocation(command);
+    if (recursive.kind === 'static') {
+        return {
+            kind: 'recursive',
+            service,
+            interpreter: recursive.interpreter,
+            script: recursive.script,
+        };
+    }
+    if (recursive.kind === 'dynamic')
+        return { kind: 'dynamic', service, signal: recursive.signal };
+    if (recursive.kind === 'indeterminate') {
+        return { kind: 'indeterminate', signal: 'shell.compose_argv_indeterminate' };
+    }
+    return { kind: 'none' };
+}
+export function decodeDockerComposeRunValues(values) {
+    return decodeDockerComposeRun(shellTokensFromValues(values, { detectExpansion: false }));
+}