@namzu/sdk 51.1.0 → 52.1.0

package/dist/authorization/shell-paths.js

@@ -0,0 +1,697 @@
+/**
+ * The files a shell command line names, read before it runs.
+ *
+ * The file tools declare a `pathArgument`, so the kernel can see which path a
+ * call reaches. A shell command line has no such argument: `cat /etc/passwd`
+ * and `echo x > ~/.profile` carry their paths inside one string, and a
+ * boundary that only reads declared arguments let both through.
+ *
+ * This is the reference terminal's answer, ported: a table of the commands
+ * whose positional arguments are paths (its path-command table and
+ * per-command extractors, version 2.1.302), the kind of access each makes (read,
+ * write or create), and the output redirections of the line. It is a
+ * reading of the text, not a model of the shell:
+ *
+ * - a word that expands at runtime (`$VAR`, `$(...)`) has no path to read;
+ *   it is reported with `unresolved` so the caller decides what an unreadable
+ *   write target is worth (the reference asks);
+ * - a `cd` earlier in the line moves every relative path after it, which the
+ *   reading does not follow, so the caller is told one happened;
+ * - a command that is not in the table contributes nothing.
+ *
+ * Nothing here touches the file system. The caller resolves the paths
+ * against the turn's roots and decides what is outside them or protected.
+ */
+import { unwrapReexecChain } from './reexec-wrapper.js';
+import { basename, lexShellCommandLine, } from './shell-lexer.js';
+const EXEC_FLAGS = new Set(['-exec', '-execdir', '-ok', '-okdir']);
+function invocationOf(words) {
+    if (words.length === 0)
+        return undefined;
+    const step = unwrapReexecChain(words);
+    if (!('rest' in step))
+        return undefined;
+    const [head, ...args] = step.rest;
+    if (head === undefined || head.expands)
+        return undefined;
+    return { program: basename(head.value), args };
+}
+/** Every program a line runs, and every redirection it carries. */
+export function readShellLine(line, dialect) {
+    const lexed = lexShellCommandLine(line, { dialect });
+    const invocations = [];
+    for (const command of lexed.commands) {
+        const own = invocationOf(command.words.slice(command.assignments));
+        if (own === undefined)
+            continue;
+        invocations.push(own);
+        if (own.program !== 'find')
+            continue;
+        // `find … -exec CMD … ;` runs CMD on each match; its arguments up to the
+        // terminator are CMD's.
+        for (let i = 0; i < own.args.length; i += 1) {
+            const flag = own.args[i];
+            if (flag.expands || !EXEC_FLAGS.has(flag.value))
+                continue;
+            const clause = [];
+            for (let j = i + 1; j < own.args.length; j += 1) {
+                const word = own.args[j];
+                if (!word.expands && (word.value === ';' || word.value === '+'))
+                    break;
+                clause.push(word);
+            }
+            const nested = invocationOf(clause);
+            if (nested !== undefined)
+                invocations.push(nested);
+        }
+    }
+    return {
+        invocations,
+        redirections: lexed.redirections,
+        complete: lexed.complete,
+    };
+}
+/** Devices a command may name without it being a file. */
+const HARMLESS_TARGETS = new Set([
+    '/dev/null',
+    '/dev/stdin',
+    '/dev/stdout',
+    '/dev/stderr',
+    '/dev/tty',
+]);
+function isHarmlessTarget(path) {
+    return (HARMLESS_TARGETS.has(path) ||
+        /^\/dev\/fd\/\d+$/.test(path) ||
+        /^\/proc\/self\/fd\/[0-2]$/.test(path));
+}
+/** Whether a word's value still holds an expansion the shell will perform. */
+export function expandsAtRuntime(word) {
+    return word.expands && (/[$`]/.test(word.value) || word.substitutes);
+}
+/** Arguments that are not flags: everything after `--`, and everything from the first operand on. */
+function operands(args) {
+    const out = [];
+    let afterDashes = false;
+    let started = false;
+    for (const arg of args) {
+        if (afterDashes || started)
+            out.push(arg);
+        else if (arg.value === '--')
+            afterDashes = true;
+        else if (arg.value === '-' || !arg.value.startsWith('-')) {
+            out.push(arg);
+            started = true;
+        }
+    }
+    return out;
+}
+/** Operands of a command whose flags are known: an unknown flag stops flag parsing, as in the reference. */
+function operandsByTable(table) {
+    const kind = (flag) => {
+        if (flag.startsWith('--')) {
+            if (flag.includes('='))
+                return 'attached';
+            if (table.booleanLong.has(flag))
+                return 'boolean';
+            if (table.attachedLong?.has(flag))
+                return 'attached';
+            return table.valuedLong.has(flag) ? 'valued' : 'unknown';
+        }
+        if (/^-\d+$/.test(flag))
+            return 'attached';
+        for (let i = 1; i < flag.length; i += 1) {
+            const letter = flag[i];
+            if (table.booleanShort.includes(letter))
+                continue;
+            if (table.attachedShort?.includes(letter))
+                return 'attached';
+            if (!table.valuedShort.includes(letter))
+                return 'unknown';
+            return i === flag.length - 1 ? 'valued' : 'attached';
+        }
+        return 'boolean';
+    };
+    return (args) => {
+        const out = [];
+        let afterDashes = false;
+        let started = false;
+        let parsing = true;
+        for (let i = 0; i < args.length; i += 1) {
+            const arg = args[i];
+            if (afterDashes || started)
+                out.push(arg);
+            else if (arg.value === '--')
+                afterDashes = true;
+            else if (arg.value !== '-' && arg.value.startsWith('-')) {
+                if (!parsing)
+                    continue;
+                const k = kind(arg.value);
+                if (k === 'valued')
+                    i += 1;
+                else if (k === 'unknown')
+                    parsing = false;
+            }
+            else {
+                out.push(arg);
+                started = true;
+            }
+        }
+        return out;
+    };
+}
+const set = (...names) => new Set(names);
+/** Operands of `grep`-family and `rg`: the first operand is the pattern unless `-e`/`-f` gave one. */
+function patternThenFiles(valued, fallback = []) {
+    const patternFlags = ['-e', '--regexp', '-f', '--file'];
+    const fileFlags = ['-f', '--file'];
+    const attachedValue = (flag, names) => {
+        if (!flag.startsWith('-'))
+            return undefined;
+        const eq = flag.indexOf('=');
+        if (eq >= 0)
+            return names.includes(flag.slice(0, eq)) ? flag.slice(eq + 1) : undefined;
+        for (const name of names) {
+            if (name.length === 2 && name[0] === '-' && flag.startsWith(name) && flag !== name) {
+                return flag.slice(2);
+            }
+        }
+        return undefined;
+    };
+    return (args) => {
+        const out = [];
+        let patternGiven = false;
+        let afterDashes = false;
+        let started = false;
+        const take = (value) => {
+            if (value)
+                out.push(word(value));
+        };
+        for (let i = 0; i < args.length; i += 1) {
+            const arg = args[i];
+            const text = arg.value;
+            if (!afterDashes && !started && text === '--') {
+                afterDashes = true;
+                continue;
+            }
+            if (!afterDashes && !started && text !== '-' && text.startsWith('-')) {
+                const eq = text.indexOf('=');
+                const name = eq >= 0 ? text.slice(0, eq) : text;
+                if (patternFlags.includes(name)) {
+                    patternGiven = true;
+                    if (name === '-f' || name === '--file') {
+                        take(eq >= 0 ? text.slice(eq + 1) : args[i + 1]?.value);
+                    }
+                }
+                if (/^-[a-zA-Z]*f$/.test(name) && name !== '-f' && eq < 0 && args[i + 1] !== undefined) {
+                    patternGiven = true;
+                    take(args[i + 1]?.value);
+                    i += 1;
+                    continue;
+                }
+                if (['--exclude-from', '--include-from', '--ignore-file'].includes(name)) {
+                    take(eq >= 0 ? text.slice(eq + 1) : args[i + 1]?.value);
+                    if (eq < 0)
+                        i += 1;
+                    continue;
+                }
+                if (eq < 0) {
+                    const attachedFile = attachedValue(text, fileFlags);
+                    if (attachedFile !== undefined) {
+                        patternGiven = true;
+                        take(attachedFile);
+                        continue;
+                    }
+                    if (text.length > 2 && text.startsWith('-e')) {
+                        patternGiven = true;
+                        continue;
+                    }
+                }
+                if (valued.has(name) && eq < 0)
+                    i += 1;
+                continue;
+            }
+            if (started && !afterDashes) {
+                const attachedFile = attachedValue(text, fileFlags);
+                if (attachedFile !== undefined)
+                    take(attachedFile);
+            }
+            started = true;
+            if (!patternGiven) {
+                patternGiven = true;
+                continue;
+            }
+            out.push(arg);
+        }
+        return out.length > 0 ? out : fallback.map(word);
+    };
+}
+/** A synthetic word for a path the extractor derived rather than read. */
+function word(value) {
+    return {
+        text: value,
+        value,
+        expands: false,
+        quoted: false,
+        substitutes: false,
+    };
+}
+const grepOperands = (args) => {
+    const found = patternThenFiles(set('-e', '--regexp', '-f', '--file', '--exclude', '--include', '--exclude-dir', '--include-dir', '-m', '--max-count', '-A', '--after-context', '-B', '--before-context', '-C', '--context'))(args);
+    if (found.length === 0 && args.some((a) => ['-r', '-R', '--recursive'].includes(a.value))) {
+        return [word('.')];
+    }
+    return found;
+};
+const rgOperands = patternThenFiles(set('-e', '--regexp', '-f', '--file', '-t', '--type', '-T', '--type-not', '-g', '--glob', '-m', '--max-count', '--max-depth', '-r', '--replace', '-A', '--after-context', '-B', '--before-context', '-C', '--context'), ['.']);
+function awkOperands(args) {
+    const valued = set('-F', '--field-separator', '-v', '--assign', '-e', '--source');
+    const files = ['-f', '--file', '-E', '--exec'];
+    const out = [];
+    let afterDashes = false;
+    let started = false;
+    let programGiven = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        const text = arg.value;
+        if (!afterDashes && !started && text === '--') {
+            afterDashes = true;
+            continue;
+        }
+        if (!afterDashes && !started && text !== '-' && text.startsWith('-')) {
+            const eq = text.indexOf('=');
+            const name = eq >= 0 ? text.slice(0, eq) : text;
+            if (valued.has(name)) {
+                if (name === '-e' || name === '--source')
+                    programGiven = true;
+                if (eq < 0)
+                    i += 1;
+                continue;
+            }
+            if (files.includes(name)) {
+                programGiven = true;
+                if (eq >= 0)
+                    out.push(word(text.slice(eq + 1)));
+                else if (args[i + 1] !== undefined) {
+                    out.push(args[i + 1]);
+                    i += 1;
+                }
+                continue;
+            }
+            continue;
+        }
+        started = true;
+        if (!programGiven) {
+            programGiven = true;
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+function sedOperands(args) {
+    const out = [];
+    let skipNext = false;
+    let scriptGiven = false;
+    let afterDashes = false;
+    let started = false;
+    for (let i = 0; i < args.length; i += 1) {
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        const arg = args[i];
+        const text = arg.value;
+        if (!afterDashes && !started && text === '--') {
+            afterDashes = true;
+            continue;
+        }
+        if (!afterDashes && !started && text !== '-' && text.startsWith('-')) {
+            if (text === '-f' || text === '--file') {
+                const next = args[i + 1];
+                if (next !== undefined)
+                    out.push(next);
+                skipNext = true;
+                scriptGiven = true;
+            }
+            else if (text === '-e' || text === '--expression') {
+                skipNext = true;
+                scriptGiven = true;
+            }
+            else if (!text.startsWith('--') && (text.includes('e') || text.includes('f'))) {
+                scriptGiven = true;
+            }
+            continue;
+        }
+        started = true;
+        if (!scriptGiven) {
+            scriptGiven = true;
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+function findOperands(args) {
+    const out = [];
+    const takesPath = new Set([
+        '-newer',
+        '-anewer',
+        '-cnewer',
+        '-mnewer',
+        '-samefile',
+        '-path',
+        '-wholename',
+        '-ilname',
+        '-lname',
+        '-ipath',
+        '-iwholename',
+    ]);
+    let expressionStarted = false;
+    let afterDashes = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg.value)
+            continue;
+        if (afterDashes) {
+            out.push(arg);
+            continue;
+        }
+        if (arg.value === '--') {
+            afterDashes = true;
+            continue;
+        }
+        if (arg.value.startsWith('-')) {
+            if (['-H', '-L', '-P'].includes(arg.value))
+                continue;
+            expressionStarted = true;
+            if (takesPath.has(arg.value) || /^-newer[acmBt][acmtB]$/.test(arg.value)) {
+                const next = args[i + 1];
+                if (next?.value) {
+                    out.push(next);
+                    i += 1;
+                }
+            }
+            continue;
+        }
+        if (!expressionStarted)
+            out.push(arg);
+    }
+    return out.length > 0 ? out : [word('.')];
+}
+function gitOperands(args) {
+    const valuedGlobals = new Set([
+        '-C',
+        '-c',
+        '--git-dir',
+        '--work-tree',
+        '--namespace',
+        '--super-prefix',
+        '--config-env',
+        '--attr-source',
+        '--shallow-file',
+    ]);
+    let index = 0;
+    let base = '';
+    const join = (value) => base === '' ? value : `${base.replace(/\/+$/, '')}/${value}`;
+    const absolute = (value) => value.startsWith('/') || value.startsWith('~');
+    const setBase = (value) => {
+        base = absolute(value) ? value : join(value);
+    };
+    while (index < args.length && args[index].value.startsWith('-')) {
+        const flag = args[index].value;
+        index += 1;
+        if (valuedGlobals.has(flag) && index < args.length) {
+            const value = args[index].value;
+            if (flag === '-C' || flag === '--work-tree')
+                setBase(value);
+            index += 1;
+        }
+        else if (flag.startsWith('--work-tree=')) {
+            setBase(flag.slice('--work-tree='.length));
+        }
+    }
+    const sub = args[index]?.value;
+    const rest = args.slice(index + 1);
+    const place = (value) => (base === '' || absolute(value) ? value : join(value));
+    if (sub === 'grep') {
+        const files = patternThenFiles(set('-e', '--regexp', '-f', '--file', '-A', '--after-context', '-B', '--before-context', '-C', '--context', '-m', '--max-count', '--max-depth', '--threads'))(rest);
+        return files.length > 0
+            ? files.map((f) => word(place(f.value)))
+            : [word(base === '' ? '.' : base)];
+    }
+    if (sub !== 'diff')
+        return [];
+    const out = [];
+    let afterDashes = false;
+    for (const arg of rest) {
+        if (!afterDashes && arg.value === '--')
+            afterDashes = true;
+        else if (afterDashes || arg.value === '-' || !arg.value.startsWith('-')) {
+            const path = place(arg.value);
+            if (!isHarmlessTarget(path))
+                out.push(word(path));
+        }
+    }
+    return out;
+}
+function manOperands(args) {
+    const local = args.some((a) => a.value === '--local-file' || (/^-[^-]/.test(a.value) && a.value.includes('l')));
+    const out = [];
+    args.forEach((arg, i) => {
+        const previous = args[i - 1]?.value;
+        if (i > 0 && (previous === '-C' || previous === '--config-file')) {
+            out.push(arg);
+            return;
+        }
+        const text = arg.value;
+        const found = [];
+        if (!text.startsWith('-'))
+            found.push(text);
+        else {
+            if (text.includes('='))
+                found.push(text.slice(text.indexOf('=') + 1));
+            if (text.length > 2 && !text.startsWith('--'))
+                found.push(text.slice(2));
+            const cut = text.search(/[\\/~]/);
+            if (cut > 0)
+                found.push(text.slice(cut));
+        }
+        for (const value of new Set(found)) {
+            if (value !== '' &&
+                (local || /[\\/]/.test(value) || value.startsWith('~') || value.startsWith('.'))) {
+                out.push(word(value));
+            }
+        }
+    });
+    return out;
+}
+function jqOperands(args) {
+    const valued = set('-e', '--expression', '--arg', '--argjson', '--args', '--jsonargs', '-L', '--library-path', '--indent', '--tab');
+    const out = [];
+    let afterDashes = false;
+    let filterGiven = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        const text = arg.value;
+        if (!afterDashes && text === '--') {
+            afterDashes = true;
+            continue;
+        }
+        if (!afterDashes && text.startsWith('-')) {
+            const eq = text.indexOf('=');
+            const name = eq >= 0 ? text.slice(0, eq) : text;
+            if (name === '-e' || name === '--expression')
+                filterGiven = true;
+            if (name === '-f' || name === '--from-file') {
+                filterGiven = true;
+                if (eq >= 0)
+                    out.push(word(text.slice(eq + 1)));
+                else if (args[i + 1] !== undefined) {
+                    out.push(args[i + 1]);
+                    i += 1;
+                }
+                continue;
+            }
+            if (name === '--slurpfile' || name === '--rawfile') {
+                const file = args[i + 2];
+                if (file !== undefined)
+                    out.push(file);
+                i += 2;
+                continue;
+            }
+            if (valued.has(name) && eq < 0)
+                i += 1;
+            continue;
+        }
+        if (!filterGiven) {
+            filterGiven = true;
+            continue;
+        }
+        out.push(arg);
+    }
+    return out;
+}
+const trOperands = (args) => {
+    const deleting = args.some((a) => a.value === '-d' ||
+        a.value === '--delete' ||
+        (a.value.startsWith('-') && a.value.includes('d')));
+    return operands(args).slice(deleting ? 1 : 2);
+};
+const teeOperands = (args) => operands(args).filter((a) => !isHarmlessTarget(a.value));
+const cdOperands = (args) => {
+    const found = operands(args);
+    if (found.length === 0)
+        return args[args.length - 1]?.value === '-' ? [word('-')] : [word('~')];
+    return [found[0]];
+};
+const lsOperands = (args) => {
+    const found = operands(args);
+    return found.length > 0 ? found : [word('.')];
+};
+const table = (booleanShort, valuedShort, booleanLong, valuedLong, attachedShort, attachedLong) => ({
+    booleanShort,
+    valuedShort,
+    booleanLong,
+    valuedLong,
+    attachedShort,
+    attachedLong,
+});
+const EXTRACTORS = {
+    cd: cdOperands,
+    ls: lsOperands,
+    find: findOperands,
+    mkdir: operands,
+    touch: operands,
+    rm: operands,
+    rmdir: operands,
+    mv: operands,
+    cp: operands,
+    cat: operands,
+    head: operands,
+    tail: operands,
+    sort: operands,
+    uniq: operands,
+    wc: operands,
+    cut: operandsByTable(table('nswz', 'bcdf', set('--complement', '--only-delimited', '--zero-terminated'), set('--bytes', '--characters', '--delimiter', '--fields', '--output-delimiter'))),
+    paste: operandsByTable(table('sz', 'd', set('--serial', '--zero-terminated'), set('--delimiters'))),
+    column: operandsByTable(table('txdemLJhV', 'cosNOClEHRTWrip', set('--table', '--fillrows', '--table-noheadings', '--table-header-repeat', '--table-maxout', '--keep-empty-lines', '--json'), set('--separator', '--output-separator', '--output-width', '--table-name', '--table-order', '--table-column', '--table-columns', '--table-columns-limit', '--table-noextreme', '--table-hide', '--table-right', '--table-truncate', '--table-wrap', '--tree', '--tree-id', '--tree-parent'))),
+    file: operands,
+    stat: operands,
+    diff: operands,
+    awk: awkOperands,
+    gawk: awkOperands,
+    mawk: awkOperands,
+    nawk: awkOperands,
+    strings: operands,
+    hexdump: operands,
+    od: operands,
+    base64: operands,
+    nl: operands,
+    sha256sum: operands,
+    sha1sum: operands,
+    md5sum: operands,
+    tee: teeOperands,
+    tr: trOperands,
+    grep: grepOperands,
+    egrep: grepOperands,
+    fgrep: grepOperands,
+    tac: operandsByTable(table('br', 's', set('--before', '--regex'), set('--separator'))),
+    rev: operands,
+    fold: operandsByTable(table('bs', 'w', set('--bytes', '--spaces'), set('--width'))),
+    expand: operandsByTable(table('i', 't', set('--initial'), set('--tabs'))),
+    unexpand: operandsByTable(table('af', 't', set('--all', '--first-only'), set('--tabs'))),
+    fmt: operandsByTable(table('csumn', 'wgdl', set('--crown-margin', '--split-only', '--tagged-paragraph', '--uniform-spacing'), set('--width', '--goal', '--prefix'))),
+    comm: operandsByTable(table('123iz', '', set('--check-order', '--nocheck-order', '--total', '--zero-terminated'), set('--output-delimiter'))),
+    cmp: operandsByTable(table('blsvxzh', '', set('--print-bytes', '--verbose', '--quiet', '--silent'), set('--ignore-initial', '--bytes'))),
+    pr: operandsByTable(table('acdFfJmprtTv', 'hlwWoND', set('--across', '--show-control-chars', '--double-space', '--form-feed', '--join-lines', '--merge', '--no-file-warnings', '--omit-header', '--omit-pagination', '--show-nonprinting'), set('--header', '--length', '--width', '--page-width', '--indent', '--first-line-number', '--date-format', '--columns'), 'einsS', set('--expand-tabs', '--output-tabs', '--number-lines', '--separator', '--sep-string'))),
+    numfmt: operandsByTable(table('z', 'd', set('--grouping', '--zero-terminated', '--debug'), set('--from', '--to', '--from-unit', '--to-unit', '--format', '--padding', '--delimiter', '--field', '--round', '--suffix', '--invalid'), undefined, set('--header'))),
+    tsort: operands,
+    man: manOperands,
+    rg: rgOperands,
+    sed: sedOperands,
+    jq: jqOperands,
+    git: gitOperands,
+};
+/** Commands that create or change what their operands name. `sed` is added per call when it edits in place. */
+const WRITERS = new Set(['mkdir', 'touch', 'rm', 'rmdir', 'mv', 'cp', 'tee']);
+const CD_PROGRAMS = new Set(['cd', 'pushd', 'popd', 'chdir']);
+/** `sed -i`, `-i.bak`, `-ni`, `--in-place[=SUFFIX]`: the script's output replaces the file. */
+function editsInPlace(args) {
+    return args.some((a) => {
+        const text = a.value;
+        if (text === '--')
+            return false;
+        if (text.startsWith('--'))
+            return text === '--in-place' || text.startsWith('--in-place=');
+        return /^-[A-Za-z]*i/.test(text);
+    });
+}
+/**
+ * The paths `reading` names: positional arguments of the commands in the
+ * table, and the targets of its redirections.
+ */
+export function shellPathAccess(reading) {
+    const uses = [];
+    let changesDirectory = false;
+    for (const { program, args } of reading.invocations) {
+        if (CD_PROGRAMS.has(program))
+            changesDirectory = true;
+        const extract = EXTRACTORS[program];
+        if (extract === undefined)
+            continue;
+        const access = WRITERS.has(program) || (program === 'sed' && editsInPlace(args)) ? 'write' : 'read';
+        for (const arg of extract(args)) {
+            if (arg.value === '' || isHarmlessTarget(arg.value))
+                continue;
+            uses.push({
+                path: arg.value,
+                access,
+                via: program,
+                unresolved: expandsAtRuntime(arg),
+            });
+        }
+    }
+    for (const redirection of reading.redirections) {
+        const target = redirection.target;
+        if (target.value === '' || isHarmlessTarget(target.value))
+            continue;
+        switch (redirection.operator) {
+            case '>':
+            case '>>':
+            case '>|':
+            case '&>':
+            case '&>>':
+            case '<>':
+                uses.push({
+                    path: target.value,
+                    access: 'write',
+                    via: 'redirect',
+                    unresolved: expandsAtRuntime(target),
+                });
+                break;
+            case '>&':
+                // `>&2` and `>&-` duplicate or close a descriptor; any other word is a file.
+                if (!/^(?:\d+-?|-)$/.test(target.value)) {
+                    uses.push({
+                        path: target.value,
+                        access: 'write',
+                        via: 'redirect',
+                        unresolved: expandsAtRuntime(target),
+                    });
+                }
+                break;
+            case '<':
+                uses.push({
+                    path: target.value,
+                    access: 'read',
+                    via: 'redirect',
+                    unresolved: expandsAtRuntime(target),
+                });
+                break;
+            default:
+                break;
+        }
+    }
+    return { uses, changesDirectory };
+}
+//# sourceMappingURL=shell-paths.js.map