@guilz-dev/belay 0.9.3 → 0.9.4

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

@@ -0,0 +1,97 @@
+import { isFdDuplication, isRedirectOperator } from '../../shell-tokenizer.js';
+import { addSecretRead, addWriteEffects, requirement } from './requirement.js';
+import { expandKnownVariables, resolvePathOperand } from './tokens.js';
+export function addRedirectEffects(requirements, tokens, env, context, segment) {
+    for (let index = 0; index < tokens.length; index += 1) {
+        const operator = tokens[index] ?? '';
+        if (!isRedirectOperator(operator) || isFdDuplication(operator)) {
+            continue;
+        }
+        const rawTarget = tokens[index + 1];
+        if (!rawTarget) {
+            requirements.push(requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, segment, [
+                'shell.redirect_target_missing',
+            ]));
+            continue;
+        }
+        if (operator.includes('<<')) {
+            requirements.push(requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, segment, [
+                'shell.heredoc_opaque',
+            ]));
+            index += 1;
+            continue;
+        }
+        const target = expandKnownVariables(rawTarget, env);
+        const resolved = resolvePathOperand(target, context.cwd);
+        if (resolved === '/dev/null') {
+            index += 1;
+            continue;
+        }
+        if (operator.includes('<')) {
+            requirements.push(requirement('fs.read', 'fs.read', { kind: 'path', path: resolved }, segment, [
+                'shell.input_redirect',
+            ]));
+            addSecretRead(requirements, resolved, segment);
+        }
+        if (operator.includes('>')) {
+            addWriteEffects(requirements, resolved, segment, ['shell.output_redirect']);
+        }
+        index += 1;
+    }
+}
+export function effectChangingEnvironmentSignals(head, env, changedNames) {
+    if (head === 'curl' &&
+        (env.CURL_HOME ||
+            changedNames.has('CURL_HOME') ||
+            changedNames.has('HOME') ||
+            changedNames.has('XDG_CONFIG_HOME'))) {
+        return ['egress.curl.environment_config_override'];
+    }
+    if (head === 'wget' && (env.WGETRC || changedNames.has('WGETRC') || changedNames.has('HOME'))) {
+        return ['egress.wget.environment_config_override'];
+    }
+    if (head !== 'git') {
+        return [];
+    }
+    const hazardousNames = new Set([
+        'GIT_ASKPASS',
+        'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+        'GIT_CEILING_DIRECTORIES',
+        'GIT_COMMON_DIR',
+        'GIT_CONFIG',
+        'GIT_CONFIG_GLOBAL',
+        'GIT_CONFIG_SYSTEM',
+        'GIT_DIR',
+        'GIT_DISCOVERY_ACROSS_FILESYSTEM',
+        'GIT_EDITOR',
+        'GIT_EXEC_PATH',
+        'GIT_EXTERNAL_DIFF',
+        'GIT_INDEX_FILE',
+        'GIT_NAMESPACE',
+        'GIT_OBJECT_DIRECTORY',
+        'GIT_PAGER',
+        'GIT_PROXY_COMMAND',
+        'GIT_QUARANTINE_PATH',
+        'GIT_SEQUENCE_EDITOR',
+        'GIT_SHALLOW_FILE',
+        'GIT_SSH',
+        'GIT_SSH_COMMAND',
+        'GIT_TEMPLATE_DIR',
+        'GIT_WORK_TREE',
+        'SSH_ASKPASS',
+    ]);
+    const overridden = changedNames.has('HOME') ||
+        changedNames.has('XDG_CONFIG_HOME') ||
+        Object.entries(env).some(([name, value]) => {
+            if (!value) {
+                return false;
+            }
+            if (hazardousNames.has(name) ||
+                /^GIT_CONFIG_(?:KEY|VALUE)_\d+$/.test(name) ||
+                /^GIT_TRACE/.test(name)) {
+                return true;
+            }
+            return name === 'GIT_CONFIG_COUNT' && value !== '0';
+        });
+    return overridden ? ['git.environment_execution_or_config_override'] : [];
+}

package/dist/core/effect-ir/shell-lower/context.d.ts

@@ -0,0 +1,10 @@
+export interface LowerShellEffectPlanParams {
+    command: string;
+    cwd: string;
+    repoRoot: string;
+    inputFingerprint: string;
+    env?: Readonly<Record<string, string | undefined>>;
+}
+export interface LowerContext extends LowerShellEffectPlanParams {
+    depth: number;
+}

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

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

package/dist/core/effect-ir/shell-lower/decode-process.d.ts

@@ -0,0 +1,9 @@
+import type { ShellEffectRequirement } from '../shell-build.js';
+export declare function decodeProcessOrFilesystem(params: {
+    tokens: string[];
+    head: string;
+    env: Readonly<Record<string, string | undefined>>;
+    cwd: string;
+    repoRoot: string;
+    segment: string;
+}): ShellEffectRequirement[];

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

@@ -0,0 +1,201 @@
+import path from 'node:path';
+import { isCommandInspection } from '../../verdict/parser.js';
+import { decodeBelay } from './decoders/belay.js';
+import { bashSyntaxTarget, decodeShellControlBuiltin, validFilesystemTest, validLsof, validPs, } from './decoders/builtins.js';
+import { decodeDockerComposeRun, validDockerInfo } from './decoders/docker.js';
+import { decodeCopyMove, decodeRm, filesystemReadOperands, filesystemWriteOperands, } from './decoders/filesystem.js';
+import { decodePrisma } from './decoders/prisma.js';
+import { decodeBundleExecInner, decodeRuby, decodeRuntimeMetadataProcess } from './decoders/ruby.js';
+import { decodeGo, decodeNode, decodeRsync, decodeSed, decodeTsc } from './decoders/toolchain.js';
+import { addSecretRead, addWriteEffects, processRequirement, requirement, unsupportedProcess, } from './requirement.js';
+import { ENV_PREFIX_PATTERN, isMetadataOnlyArgv, isShellHead, resolvePathOperand, } from './tokens.js';
+export function decodeProcessOrFilesystem(params) {
+    const { tokens, head, env, cwd, repoRoot, segment } = params;
+    const args = tokens.slice(1);
+    if (tokens.length > 0 && tokens.every((token) => ENV_PREFIX_PATTERN.test(token))) {
+        return [];
+    }
+    const shellControl = decodeShellControlBuiltin(head, args);
+    if (shellControl) {
+        return shellControl;
+    }
+    if (isCommandInspection(tokens)) {
+        return [processRequirement(head, 'inspect', segment, ['process.inspect.command_lookup'])];
+    }
+    if (head === 'lsof') {
+        return validLsof(args)
+            ? [processRequirement(head, 'inspect', segment, ['process.inspect.lsof'])]
+            : unsupportedProcess(head, segment, 'process.lsof_grammar_incomplete');
+    }
+    if (head === 'ps') {
+        return validPs(args)
+            ? [processRequirement(head, 'inspect', segment, ['process.inspect.ps'])]
+            : unsupportedProcess(head, segment, 'process.ps_grammar_incomplete');
+    }
+    if (head === 'test' || head === '[') {
+        return validFilesystemTest(head, args)
+            ? [processRequirement(head, 'inspect', segment, ['process.inspect.filesystem_test'])]
+            : unsupportedProcess(head, segment, 'process.filesystem_test_grammar_incomplete');
+    }
+    if (head === 'docker') {
+        if (args[0] === 'info') {
+            return validDockerInfo(args.slice(1))
+                ? [processRequirement(head, 'inspect', segment, ['process.inspect.docker_info'])]
+                : unsupportedProcess(head, segment, 'process.docker_info_grammar_incomplete');
+        }
+        if (args[0] === 'compose' &&
+            ['up', 'down', 'start', 'stop', 'restart', 'create', 'rm'].includes(args[1] ?? '')) {
+            return [processRequirement(head, 'spawn', segment, ['service.local_mutation'])];
+        }
+        if (args[0] === 'push' ||
+            (args[0] === 'build' && args.includes('--push')) ||
+            (args[0] === 'buildx' &&
+                args[1] === 'build' &&
+                (args.includes('--push') ||
+                    args.some((arg) => arg.startsWith('--output=type=registry') || arg.startsWith('-o=type=registry'))))) {
+            return [
+                processRequirement(head, 'spawn', segment, ['tier0_external', 'docker.remote_mutation']),
+                requirement('network.connect', 'network.connect', {
+                    kind: 'network',
+                    host: 'registry',
+                    protocol: 'container-registry',
+                    mode: 'mutate',
+                    payload: 'present',
+                }, segment, ['tier0_external', 'docker.remote_mutation']),
+            ];
+        }
+        if (args[0] === 'run' ||
+            args[0] === 'create' ||
+            args[0] === 'pull' ||
+            args[0] === 'build' ||
+            (args[0] === 'buildx' && args[1] === 'build')) {
+            return [
+                processRequirement(head, 'spawn', segment, ['process.docker_spawn']),
+                requirement('network.acquire', 'network.connect', {
+                    kind: 'network',
+                    host: 'unknown',
+                    protocol: 'container-registry',
+                    mode: 'ambiguous',
+                    payload: 'none',
+                }, segment, ['docker.image_acquisition_possible']),
+            ];
+        }
+        return [processRequirement(head, 'spawn', segment, ['process.docker_spawn'])];
+    }
+    if (isShellHead(head)) {
+        const syntax = bashSyntaxTarget(args);
+        if (syntax) {
+            return [
+                processRequirement(head, 'inspect', segment, ['process.inspect.shell_syntax']),
+                requirement('fs.read', 'fs.read', { kind: 'path', path: path.resolve(cwd, syntax) }, segment, ['shell.syntax_source_read']),
+            ];
+        }
+        return unsupportedProcess(head, segment, 'process.shell_grammar_incomplete');
+    }
+    if (head === 'prisma') {
+        return decodePrisma(args, env, repoRoot, segment);
+    }
+    const runtimeMetadata = decodeRuntimeMetadataProcess(head, args, segment);
+    if (runtimeMetadata) {
+        return runtimeMetadata;
+    }
+    if (head === 'ruby') {
+        return decodeRuby(args, cwd, repoRoot, segment);
+    }
+    if (head === 'rubocop' || head === 'rspec') {
+        const decoded = decodeBundleExecInner(head, args, segment);
+        if (decoded) {
+            return decoded;
+        }
+    }
+    const dockerCompose = decodeDockerComposeRun(head, args, segment);
+    if (dockerCompose) {
+        return dockerCompose;
+    }
+    if ((head === 'npm' || head === 'pnpm') && args.length === 1 && isMetadataOnlyArgv(args)) {
+        return [processRequirement(head, 'inspect', segment, ['process.inspect.package_manager'])];
+    }
+    if (head === 'belay') {
+        return decodeBelay(args, repoRoot, segment);
+    }
+    if (head === 'tsc') {
+        return decodeTsc(args, cwd, segment);
+    }
+    if (head === 'go') {
+        return decodeGo(args, segment);
+    }
+    if (head === 'rsync') {
+        return decodeRsync(args, cwd, segment);
+    }
+    if (head === 'sed') {
+        return decodeSed(args, cwd, segment);
+    }
+    if (head === 'base64' && args.length === 1 && ['-d', '-D', '--decode'].includes(args[0] ?? '')) {
+        return [processRequirement(head, 'inspect', segment, ['process.inspect.base64_stdin'])];
+    }
+    if (head === 'node') {
+        return decodeNode(args, cwd, segment);
+    }
+    if (head === 'vite' || head === 'vite-node') {
+        return [processRequirement(head, 'spawn', segment, ['process.local_dev_spawn'])];
+    }
+    if (((head === 'npm' || head === 'pnpm') && args[0] === 'publish') ||
+        (head === 'terraform' && args[0] === 'apply')) {
+        return [
+            processRequirement(head, 'spawn', segment, ['tier0_external']),
+            requirement('network.connect', 'network.connect', {
+                kind: 'network',
+                host: 'control-plane',
+                protocol: head,
+                mode: 'mutate',
+                payload: 'present',
+            }, segment, ['tier0_external']),
+        ];
+    }
+    if (head === 'cd') {
+        return [];
+    }
+    if (head === 'cp' || head === 'mv') {
+        return decodeCopyMove(head, args, cwd, segment);
+    }
+    if (head === 'rm') {
+        return decodeRm(args, cwd, repoRoot, segment);
+    }
+    if (head === 'vitest' || head === 'eslint' || head === 'biome' || head === 'belay') {
+        return [processRequirement(head, 'spawn', segment, ['process.known_local_spawn'])];
+    }
+    if (head === 'pwd' || head === 'which' || head === 'whoami') {
+        return [processRequirement(head, 'inspect', segment, ['process.pure_inspection'])];
+    }
+    const readOperands = filesystemReadOperands(head, args);
+    if (readOperands !== null) {
+        const lowered = [processRequirement(head, 'inspect', segment, ['process.filesystem_inspect'])];
+        for (const operand of readOperands) {
+            const resolved = resolvePathOperand(operand, cwd);
+            lowered.push(requirement('fs.read', 'fs.read', { kind: 'path', path: resolved }, segment, [
+                'filesystem.read',
+            ]));
+            addSecretRead(lowered, resolved, segment);
+        }
+        return lowered;
+    }
+    const writeOperands = filesystemWriteOperands(head, args);
+    if (writeOperands !== null) {
+        const lowered = [processRequirement(head, 'spawn', segment, ['process.filesystem_mutation'])];
+        for (const operand of writeOperands) {
+            addWriteEffects(lowered, resolvePathOperand(operand, cwd), segment, ['filesystem.write']);
+        }
+        return lowered;
+    }
+    if (head === 'printf' || head === 'echo' || head === 'true' || head === 'false' || head === ':') {
+        return [];
+    }
+    if (!head) {
+        return [
+            requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, segment, [
+                'shell.segment_empty',
+            ]),
+        ];
+    }
+    return unsupportedProcess(head, segment, 'process.grammar_unknown');
+}

package/dist/core/effect-ir/shell-lower/decoders/belay.d.ts

@@ -0,0 +1,2 @@
+import type { ShellEffectRequirement } from '../../shell-build.js';
+export declare function decodeBelay(args: string[], repoRoot: string, segment: string): ShellEffectRequirement[];

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

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { processRequirement, requirement } from '../requirement.js';
+export function decodeBelay(args, repoRoot, segment) {
+    const [section, operation, key] = args;
+    const judgeCommand = section === 'judge' &&
+        operation !== undefined &&
+        ['consent', 'list', 'status', 'test', 'use'].includes(operation);
+    const configRead = section === 'config' &&
+        (operation === undefined ||
+            operation === 'list' ||
+            (operation === 'get' && key?.startsWith('judge.')));
+    const configJudgeMutation = section === 'config' &&
+        ((['set', 'unset'].includes(operation ?? '') && key?.startsWith('judge.')) ||
+            (operation === 'credential' && key === 'mode'));
+    if (judgeCommand || configRead || configJudgeMutation) {
+        return [
+            processRequirement('belay', 'inspect', segment, [
+                'belay_control_plane_command',
+                configJudgeMutation ? 'belay.config_judge_mutation' : 'belay.config_read',
+            ]),
+        ];
+    }
+    if (section === 'config' && ['set', 'unset', 'credential'].includes(operation ?? '')) {
+        return [
+            requirement('control_plane.write', 'control_plane.write', { kind: 'path', path: path.join(repoRoot, '.belay-control-plane') }, segment, ['belay.config_non_judge_mutation']),
+        ];
+    }
+    return [processRequirement('belay', 'spawn', segment, ['process.known_local_spawn'])];
+}

package/dist/core/effect-ir/shell-lower/decoders/builtins.d.ts

@@ -0,0 +1,7 @@
+import type { ShellEffectRequirement } from '../../shell-build.js';
+export declare function decodeSetBuiltin(args: string[]): boolean;
+export declare function decodeShellControlBuiltin(head: string, args: string[]): ShellEffectRequirement[] | null;
+export declare function validLsof(args: string[]): boolean;
+export declare function validPs(args: string[]): boolean;
+export declare function validFilesystemTest(head: string, args: string[]): boolean;
+export declare function bashSyntaxTarget(args: string[]): string | null;

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

@@ -0,0 +1,194 @@
+import { isOptionToken } from '../tokens.js';
+export function decodeSetBuiltin(args) {
+    let index = 0;
+    while (index < args.length) {
+        const arg = args[index] ?? '';
+        if (arg === '--') {
+            index += 1;
+            continue;
+        }
+        if (arg === '-o' || arg === '+o') {
+            if (!args[index + 1]) {
+                return false;
+            }
+            index += 2;
+            continue;
+        }
+        if (/^[-+][A-Za-z0-9]+$/.test(arg)) {
+            index += 1;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+export function decodeShellControlBuiltin(head, args) {
+    if (head === 'set') {
+        return decodeSetBuiltin(args) ? [] : null;
+    }
+    if (head === 'wait') {
+        if (args.length === 0 || args.every((arg) => /^\d+$/.test(arg))) {
+            return [];
+        }
+        return null;
+    }
+    if (head === 'exit') {
+        if (args.length === 0 || (args.length === 1 && /^-?\d+$/.test(args[0] ?? ''))) {
+            return [];
+        }
+        return null;
+    }
+    return null;
+}
+export function validLsof(args) {
+    const flagsWithoutValues = new Set(['-a', '-b', '-l', '-n', '-P', '-R', '-t', '-V']);
+    const flagsWithValues = new Set(['-c', '-d', '-F', '-g', '-p', '-T', '-u', '+d', '+D']);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? '';
+        if (flagsWithoutValues.has(arg) || arg === '-i') {
+            continue;
+        }
+        if (flagsWithValues.has(arg)) {
+            if (!args[index + 1] || isOptionToken(args[index + 1] ?? '')) {
+                return false;
+            }
+            index += 1;
+            continue;
+        }
+        if ((/^-[ablnPRtV]+$/.test(arg) &&
+            [...arg.slice(1)].every((flag) => 'ablnPRtV'.includes(flag))) ||
+            /^-i(?:TCP|UDP)?(?::\d+(?:-\d+)?)?$/.test(arg) ||
+            /^-s(?:TCP|UDP):[A-Za-z]+$/.test(arg) ||
+            /^-(?:c|d|F|g|p|T|u).+$/.test(arg) ||
+            /^\+(?:d|D).+$/.test(arg)) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+export function validPs(args) {
+    const bareForms = new Set(['aux', 'ax', 'x', 'u']);
+    const flagsWithoutValues = new Set(['-A', '-a', '-d', '-e', '-f', '-j', '-l', '-T', '-x']);
+    const flagsWithValues = new Set([
+        '--format',
+        '--group',
+        '--pid',
+        '--ppid',
+        '--sort',
+        '--tty',
+        '--user',
+    ]);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? '';
+        if (bareForms.has(arg) || flagsWithoutValues.has(arg)) {
+            continue;
+        }
+        if (flagsWithValues.has(arg)) {
+            if (!args[index + 1] || isOptionToken(args[index + 1] ?? '')) {
+                return false;
+            }
+            index += 1;
+            continue;
+        }
+        if (/^(?:--format|--group|--pid|--ppid|--sort|--tty|--user)=.+$/.test(arg)) {
+            continue;
+        }
+        if (/^-[^-]/.test(arg)) {
+            const noValue = new Set(['A', 'a', 'd', 'e', 'f', 'j', 'l', 'T', 'x']);
+            const withValue = new Set(['G', 'g', 'N', 'o', 'p', 't', 'U', 'u']);
+            const characters = arg.slice(1);
+            let valid = true;
+            for (let optionIndex = 0; optionIndex < characters.length; optionIndex += 1) {
+                const option = characters[optionIndex] ?? '';
+                if (noValue.has(option)) {
+                    continue;
+                }
+                if (withValue.has(option)) {
+                    if (optionIndex === characters.length - 1) {
+                        if (!args[index + 1] || isOptionToken(args[index + 1] ?? '')) {
+                            return false;
+                        }
+                        index += 1;
+                    }
+                    break;
+                }
+                valid = false;
+                break;
+            }
+            if (valid) {
+                continue;
+            }
+        }
+        return false;
+    }
+    return true;
+}
+export function validFilesystemTest(head, args) {
+    const operands = head === '[' && args.at(-1) === ']' ? args.slice(0, -1) : args;
+    if (head === '[' && args.at(-1) !== ']') {
+        return false;
+    }
+    return (operands.length === 2 &&
+        new Set(['-b', '-c', '-d', '-e', '-f', '-h', '-L', '-r', '-s', '-w', '-x']).has(operands[0] ?? '') &&
+        Boolean(operands[1]));
+}
+export function bashSyntaxTarget(args) {
+    let syntaxOnly = false;
+    let script = null;
+    const shortFlags = new Set('abefhkmnptuvxBCEHPT'.split(''));
+    const longFlags = new Set([
+        '--debugger',
+        '--dump-po-strings',
+        '--dump-strings',
+        '--help',
+        '--login',
+        '--noediting',
+        '--noprofile',
+        '--norc',
+        '--posix',
+        '--restricted',
+        '--verbose',
+        '--version',
+    ]);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index] ?? '';
+        if (arg === '-c' || arg === '-lc') {
+            return null;
+        }
+        if (arg === '-O' || arg === '+O' || arg === '--rcfile' || arg === '--init-file') {
+            if (!args[index + 1] || isOptionToken(args[index + 1] ?? '')) {
+                return null;
+            }
+            index += 1;
+            continue;
+        }
+        if ((arg.startsWith('-O') && arg.length > 2) ||
+            (arg.startsWith('+O') && arg.length > 2) ||
+            (arg.startsWith('--rcfile=') && arg.length > '--rcfile='.length) ||
+            (arg.startsWith('--init-file=') && arg.length > '--init-file='.length)) {
+            continue;
+        }
+        if (longFlags.has(arg)) {
+            continue;
+        }
+        if (/^[+-][A-Za-z]+$/.test(arg)) {
+            const options = arg.slice(1);
+            if ([...options].some((option) => !shortFlags.has(option))) {
+                return null;
+            }
+            syntaxOnly ||= options.includes('n');
+            continue;
+        }
+        if (arg === '--') {
+            script = args[index + 1] ?? null;
+            break;
+        }
+        if (arg.startsWith('-') || arg.startsWith('+')) {
+            return null;
+        }
+        script = arg;
+        break;
+    }
+    return syntaxOnly ? script : null;
+}

package/dist/core/effect-ir/shell-lower/decoders/decode-package-exec.d.ts

@@ -0,0 +1,4 @@
+import { type peelPackageExecArgv } from '../../package-exec.js';
+import type { ShellEffectRequirement } from '../../shell-build.js';
+export declare function decodePackageExec(peel: NonNullable<ReturnType<typeof peelPackageExecArgv>>, cwd: string, repoRoot: string, segment: string): ShellEffectRequirement[];
+export declare function packageExecInnerIsMetadata(peel: NonNullable<ReturnType<typeof peelPackageExecArgv>>): boolean;

package/dist/core/effect-ir/shell-lower/decoders/decode-package-exec.js

@@ -0,0 +1,68 @@
+import { classifyPackageAcquisitionSpec, resolveLocalBin, } from '../../package-exec.js';
+import { requirement } from '../requirement.js';
+export function decodePackageExec(peel, cwd, repoRoot, segment) {
+    if (peel.opaque) {
+        return [
+            requirement('indeterminate', 'indeterminate', { kind: 'unknown' }, segment, [
+                peel.reason,
+                ...peel.signals,
+            ]),
+        ];
+    }
+    if (peel.reason === 'npx_wrapper_readonly') {
+        return [];
+    }
+    const binHead = peel.innerTokens[0] ?? '';
+    const metadataOnly = packageExecInnerIsMetadata(peel);
+    const local = !peel.forceAcquire ? resolveLocalBin(binHead, cwd, repoRoot) : null;
+    if (local) {
+        return metadataOnly
+            ? [
+                requirement('process.exec', 'process.exec', { kind: 'executable', command: local.path, operation: 'inspect' }, segment, ['package_exec.delegate', 'package_exec.local_bin_resolved']),
+            ]
+            : [];
+    }
+    const networkResources = peel.acquisitionSpecs
+        .map((spec) => classifyPackageAcquisitionSpec(spec))
+        .filter((source) => source.kind !== 'local')
+        .map((source) => source.kind === 'registry'
+        ? {
+            kind: 'network',
+            host: 'registry.npmjs.org',
+            protocol: 'registry',
+            mode: 'read',
+            payload: 'none',
+        }
+        : {
+            kind: 'network',
+            host: source.host,
+            ...(source.port ? { port: source.port } : {}),
+            protocol: source.protocol,
+            mode: 'read',
+            payload: 'none',
+        });
+    if (networkResources.length === 0) {
+        networkResources.push({
+            kind: 'network',
+            host: 'registry.npmjs.org',
+            protocol: 'registry',
+            mode: 'read',
+            payload: 'none',
+        });
+    }
+    return [
+        ...networkResources.map((resource) => requirement('network.acquire', 'network.connect', resource, segment, [
+            'package_acquire_possible',
+        ])),
+        requirement('fs.write', 'fs.write', { kind: 'package-cache', manager: peel.launcher === 'pnpm' ? 'pnpm' : 'npm' }, segment, ['package_cache_write']),
+        ...(metadataOnly
+            ? [
+                requirement('process.exec', 'process.exec', { kind: 'executable', command: binHead || peel.launcher, operation: 'inspect' }, segment, ['package_exec.delegate']),
+            ]
+            : []),
+    ];
+}
+export function packageExecInnerIsMetadata(peel) {
+    const args = peel.innerTokens.slice(1);
+    return (args.length > 0 && args.every((arg) => ['--help', '--version', '-V', '-h', '-v'].includes(arg)));
+}

package/dist/core/effect-ir/shell-lower/decoders/docker.d.ts

@@ -0,0 +1,3 @@
+import type { ShellEffectRequirement } from '../../shell-build.js';
+export declare function decodeDockerComposeRun(head: string, args: string[], segment: string): ShellEffectRequirement[] | null;
+export declare function validDockerInfo(args: string[]): boolean;