@yarnpkg/shell/lib/index.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const fslib_1 = require("@yarnpkg/fslib");
const parsers_1 = require("@yarnpkg/parsers");
const fast_glob_1 = __importDefault(require("fast-glob"));
const stream_1 = require("stream");
const pipe_1 = require("./pipe");
const pipe_2 = require("./pipe");
function cloneState(state, mergeWith = {}) {
    const newState = { ...state, ...mergeWith };
    newState.environment = { ...state.environment, ...mergeWith.environment };
    newState.variables = { ...state.variables, ...mergeWith.variables };
    return newState;
}
const BUILTINS = new Map([
    [`cd`, async ([target, ...rest], opts, state) => {
            const resolvedTarget = fslib_1.ppath.resolve(state.cwd, fslib_1.npath.toPortablePath(target));
            const stat = await fslib_1.xfs.statPromise(resolvedTarget);
            if (!stat.isDirectory()) {
                state.stderr.write(`cd: not a directory\n`);
                return 1;
            }
            else {
                state.cwd = resolvedTarget;
                return 0;
            }
        }],
    [`pwd`, async (args, opts, state) => {
            state.stdout.write(`${fslib_1.npath.fromPortablePath(state.cwd)}\n`);
            return 0;
        }],
    [`true`, async (args, opts, state) => {
            return 0;
        }],
    [`false`, async (args, opts, state) => {
            return 1;
        }],
    [`exit`, async ([code, ...rest], opts, state) => {
            return state.exitCode = parseInt(code, 10);
        }],
    [`echo`, async (args, opts, state) => {
            state.stdout.write(`${args.join(` `)}\n`);
            return 0;
        }],
    [`__ysh_run_procedure`, async (args, opts, state) => {
            const procedure = state.procedures[args[0]];
            const exitCode = await pipe_2.start(procedure, {
                stdin: new pipe_2.ProtectedStream(state.stdin),
                stdout: new pipe_2.ProtectedStream(state.stdout),
                stderr: new pipe_2.ProtectedStream(state.stderr),
            }).run();
            return exitCode;
        }],
    [`__ysh_set_redirects`, async (args, opts, state) => {
            let stdin = state.stdin;
            let stdout = state.stdout;
            const stderr = state.stderr;
            const inputs = [];
            const outputs = [];
            let t = 0;
            while (args[t] !== `--`) {
                const type = args[t++];
                const count = Number(args[t++]);
                const last = t + count;
                for (let u = t; u < last; ++t, ++u) {
                    switch (type) {
                        case `<`:
                            {
                                inputs.push(() => {
                                    return fslib_1.xfs.createReadStream(fslib_1.ppath.resolve(state.cwd, fslib_1.npath.toPortablePath(args[u])));
                                });
                            }
                            break;
                        case `<<<`:
                            {
                                inputs.push(() => {
                                    const input = new stream_1.PassThrough();
                                    process.nextTick(() => {
                                        input.write(`${args[u]}\n`);
                                        input.end();
                                    });
                                    return input;
                                });
                            }
                            break;
                        case `>`:
                            {
                                outputs.push(fslib_1.xfs.createWriteStream(fslib_1.ppath.resolve(state.cwd, fslib_1.npath.toPortablePath(args[u]))));
                            }
                            break;
                        case `>>`:
                            {
                                outputs.push(fslib_1.xfs.createWriteStream(fslib_1.ppath.resolve(state.cwd, fslib_1.npath.toPortablePath(args[u])), { flags: `a` }));
                            }
                            break;
                    }
                }
            }
            if (inputs.length > 0) {
                const pipe = new stream_1.PassThrough();
                stdin = pipe;
                const bindInput = (n) => {
                    if (n === inputs.length) {
                        pipe.end();
                    }
                    else {
                        const input = inputs[n]();
                        input.pipe(pipe, { end: false });
                        input.on(`end`, () => {
                            bindInput(n + 1);
                        });
                    }
                };
                bindInput(0);
            }
            if (outputs.length > 0) {
                const pipe = new stream_1.PassThrough();
                stdout = pipe;
                for (const output of outputs) {
                    pipe.pipe(output);
                }
            }
            const exitCode = await pipe_2.start(makeCommandAction(args.slice(t + 1), opts, state), {
                stdin: new pipe_2.ProtectedStream(stdin),
                stdout: new pipe_2.ProtectedStream(stdout),
                stderr: new pipe_2.ProtectedStream(stderr),
            }).run();
            // Close all the outputs (since the shell never closes the output stream)
            await Promise.all(outputs.map(output => {
                // Wait until the output got flushed to the disk
                return new Promise(resolve => {
                    output.on(`close`, () => {
                        resolve();
                    });
                    output.end();
                });
            }));
            return exitCode;
        }],
]);
async function executeBufferedSubshell(ast, opts, state) {
    const chunks = [];
    const stdout = new stream_1.PassThrough();
    stdout.on(`data`, chunk => chunks.push(chunk));
    await executeShellLine(ast, opts, cloneState(state, { stdout }));
    return Buffer.concat(chunks).toString().replace(/[\r\n]+$/, ``);
}
async function applyEnvVariables(environmentSegments, opts, state) {
    const envPromises = environmentSegments.map(async (envSegment) => {
        const interpolatedArgs = await interpolateArguments(envSegment.args, opts, state);
        return {
            name: envSegment.name,
            value: interpolatedArgs.join(` `),
        };
    });
    const interpolatedEnvs = await Promise.all(envPromises);
    return interpolatedEnvs.reduce((envs, env) => {
        envs[env.name] = env.value;
        return envs;
    }, {});
}
async function interpolateArguments(commandArgs, opts, state) {
    const redirections = new Map();
    const interpolated = [];
    let interpolatedSegments = [];
    const split = (raw) => {
        return raw.match(/[^ \r\n\t]+/g) || [];
    };
    const push = (segment) => {
        interpolatedSegments.push(segment);
    };
    const close = () => {
        if (interpolatedSegments.length > 0)
            interpolated.push(interpolatedSegments.join(``));
        interpolatedSegments = [];
    };
    const pushAndClose = (segment) => {
        push(segment);
        close();
    };
    const redirect = (type, target) => {
        let targets = redirections.get(type);
        if (typeof targets === `undefined`)
            redirections.set(type, targets = []);
        targets.push(target);
    };
    for (const commandArg of commandArgs) {
        switch (commandArg.type) {
            case `redirection`:
                {
                    const interpolatedArgs = await interpolateArguments(commandArg.args, opts, state);
                    for (const interpolatedArg of interpolatedArgs) {
                        redirect(commandArg.subtype, interpolatedArg);
                    }
                }
                break;
            case `argument`:
                {
                    for (const segment of commandArg.segments) {
                        switch (segment.type) {
                            case `text`:
                                {
                                    push(segment.text);
                                }
                                break;
                            case `glob`:
                                {
                                    const matches = await opts.glob.match(segment.pattern, { cwd: state.cwd });
                                    if (!matches.length)
                                        throw new Error(`No file matches found: "${segment.pattern}". Note: Glob patterns currently only support files that exist on the filesystem (Help Wanted)`);
                                    for (const match of matches.sort()) {
                                        pushAndClose(match);
                                    }
                                }
                                break;
                            case `shell`:
                                {
                                    const raw = await executeBufferedSubshell(segment.shell, opts, state);
                                    if (segment.quoted) {
                                        push(raw);
                                    }
                                    else {
                                        const parts = split(raw);
                                        for (let t = 0; t < parts.length - 1; ++t)
                                            pushAndClose(parts[t]);
                                        push(parts[parts.length - 1]);
                                    }
                                }
                                break;
                            case `variable`:
                                {
                                    switch (segment.name) {
                                        case `#`:
                                            {
                                                push(String(opts.args.length));
                                            }
                                            break;
                                        case `@`:
                                            {
                                                if (segment.quoted) {
                                                    for (const raw of opts.args) {
                                                        pushAndClose(raw);
                                                    }
                                                }
                                                else {
                                                    for (const raw of opts.args) {
                                                        const parts = split(raw);
                                                        for (let t = 0; t < parts.length - 1; ++t)
                                                            pushAndClose(parts[t]);
                                                        push(parts[parts.length - 1]);
                                                    }
                                                }
                                            }
                                            break;
                                        case `*`:
                                            {
                                                const raw = opts.args.join(` `);
                                                if (segment.quoted) {
                                                    push(raw);
                                                }
                                                else {
                                                    for (const part of split(raw)) {
                                                        pushAndClose(part);
                                                    }
                                                }
                                            }
                                            break;
                                        default:
                                            {
                                                const argIndex = parseInt(segment.name, 10);
                                                if (Number.isFinite(argIndex)) {
                                                    if (!(argIndex >= 0 && argIndex < opts.args.length)) {
                                                        throw new Error(`Unbound argument #${argIndex}`);
                                                    }
                                                    else {
                                                        push(opts.args[argIndex]);
                                                    }
                                                }
                                                else {
                                                    if (Object.prototype.hasOwnProperty.call(state.variables, segment.name)) {
                                                        push(state.variables[segment.name]);
                                                    }
                                                    else if (Object.prototype.hasOwnProperty.call(state.environment, segment.name)) {
                                                        push(state.environment[segment.name]);
                                                    }
                                                    else if (segment.defaultValue) {
                                                        push((await interpolateArguments(segment.defaultValue, opts, state)).join(` `));
                                                    }
                                                    else {
                                                        throw new Error(`Unbound variable "${segment.name}"`);
                                                    }
                                                }
                                            }
                                            break;
                                    }
                                }
                                break;
                        }
                    }
                }
                break;
        }
        close();
    }
    if (redirections.size > 0) {
        const redirectionArgs = [];
        for (const [subtype, targets] of redirections.entries())
            redirectionArgs.splice(redirectionArgs.length, 0, subtype, String(targets.length), ...targets);
        interpolated.splice(0, 0, `__ysh_set_redirects`, ...redirectionArgs, `--`);
    }
    return interpolated;
}
/**
 * Executes a command chain. A command chain is a list of commands linked
 * together thanks to the use of either of the `|` or `|&` operators:
 *
 * $ cat hello | grep world | grep -v foobar
 */
function makeCommandAction(args, opts, state) {
    if (!opts.builtins.has(args[0]))
        args = [`command`, ...args];
    const nativeCwd = fslib_1.npath.fromPortablePath(state.cwd);
    let env = state.environment;
    if (typeof env.PWD !== `undefined`)
        env = { ...env, PWD: nativeCwd };
    const [name, ...rest] = args;
    if (name === `command`) {
        return pipe_1.makeProcess(rest[0], rest.slice(1), opts, {
            cwd: nativeCwd,
            env,
        });
    }
    const builtin = opts.builtins.get(name);
    if (typeof builtin === `undefined`)
        throw new Error(`Assertion failed: A builtin should exist for "${name}"`);
    return pipe_1.makeBuiltin(async ({ stdin, stdout, stderr }) => {
        state.stdin = stdin;
        state.stdout = stdout;
        state.stderr = stderr;
        return await builtin(rest, opts, state);
    });
}
function makeSubshellAction(ast, opts, state) {
    return (stdio) => {
        const stdin = new stream_1.PassThrough();
        const promise = executeShellLine(ast, opts, cloneState(state, { stdin }));
        return { stdin, promise };
    };
}
async function executeCommandChain(node, opts, state) {
    let current = node;
    let pipeType = null;
    let execution = null;
    while (current) {
        // Only the final segment is allowed to modify the shell state; all the
        // other ones are isolated
        const activeState = current.then
            ? { ...state }
            : state;
        let action;
        switch (current.type) {
            case `command`:
                {
                    const args = await interpolateArguments(current.args, opts, state);
                    const environment = await applyEnvVariables(current.envs, opts, state);
                    action = current.envs.length
                        ? makeCommandAction(args, opts, cloneState(activeState, { environment }))
                        : makeCommandAction(args, opts, activeState);
                }
                break;
            case `subshell`:
                {
                    const args = await interpolateArguments(current.args, opts, state);
                    // We don't interpolate the subshell because it will be recursively
                    // interpolated within its own context
                    const procedure = makeSubshellAction(current.subshell, opts, activeState);
                    if (args.length === 0) {
                        action = procedure;
                    }
                    else {
                        let key;
                        do {
                            key = String(Math.random());
                        } while (Object.prototype.hasOwnProperty.call(activeState.procedures, key));
                        activeState.procedures = { ...activeState.procedures };
                        activeState.procedures[key] = procedure;
                        action = makeCommandAction([...args, `__ysh_run_procedure`, key], opts, activeState);
                    }
                }
                break;
            case `envs`:
                {
                    const environment = await applyEnvVariables(current.envs, opts, state);
                    activeState.environment = { ...activeState.environment, ...environment };
                    action = makeCommandAction([`true`], opts, activeState);
                }
                break;
        }
        if (typeof action === `undefined`)
            throw new Error(`Assertion failed: An action should have been generated`);
        if (pipeType === null) {
            // If we're processing the left-most segment of the command, we start a
            // new execution pipeline
            execution = pipe_2.start(action, {
                stdin: new pipe_2.ProtectedStream(activeState.stdin),
                stdout: new pipe_2.ProtectedStream(activeState.stdout),
                stderr: new pipe_2.ProtectedStream(activeState.stderr),
            });
        }
        else {
            if (execution === null)
                throw new Error(`The execution pipeline should have been setup`);
            // Otherwise, depending on the exaxct pipe type, we either pipe stdout
            // only or stdout and stderr
            switch (pipeType) {
                case `|`:
                    {
                        execution = execution.pipeTo(action);
                    }
                    break;
                case `|&`:
                    {
                        execution = execution.pipeTo(action);
                    }
                    break;
            }
        }
        if (current.then) {
            pipeType = current.then.type;
            current = current.then.chain;
        }
        else {
            current = null;
        }
    }
    if (execution === null)
        throw new Error(`Assertion failed: The execution pipeline should have been setup`);
    return await execution.run();
}
/**
 * Execute a command line. A command line is a list of command shells linked
 * together thanks to the use of either of the `||` or `&&` operators.
 */
async function executeCommandLine(node, opts, state) {
    if (!node.then)
        return await executeCommandChain(node.chain, opts, state);
    const code = await executeCommandChain(node.chain, opts, state);
    // If the execution aborted (usually through "exit"), we must bailout
    if (state.exitCode !== null)
        return state.exitCode;
    // We must update $?, which always contains the exit code from
    // the right-most command
    state.variables[`?`] = String(code);
    switch (node.then.type) {
        case `&&`:
            {
                if (code === 0) {
                    return await executeCommandLine(node.then.line, opts, state);
                }
                else {
                    return code;
                }
            }
            break;
        case `||`:
            {
                if (code !== 0) {
                    return await executeCommandLine(node.then.line, opts, state);
                }
                else {
                    return code;
                }
            }
            break;
        default:
            {
                throw new Error(`Unsupported command type: "${node.then.type}"`);
            }
            break;
    }
}
async function executeShellLine(node, opts, state) {
    let rightMostExitCode = 0;
    for (const command of node) {
        rightMostExitCode = await executeCommandLine(command, opts, state);
        // If the execution aborted (usually through "exit"), we must bailout
        if (state.exitCode !== null)
            return state.exitCode;
        // We must update $?, which always contains the exit code from
        // the right-most command
        state.variables[`?`] = String(rightMostExitCode);
    }
    return rightMostExitCode;
}
function locateArgsVariableInSegment(segment) {
    switch (segment.type) {
        case `variable`:
            {
                return segment.name === `@` || segment.name === `#` || segment.name === `*` || Number.isFinite(parseInt(segment.name, 10)) || (!!segment.defaultValue && segment.defaultValue.some(arg => locateArgsVariableInArgument(arg)));
            }
            break;
        case `shell`:
            {
                return locateArgsVariable(segment.shell);
            }
            break;
        default:
            {
                return false;
            }
            break;
    }
}
function locateArgsVariableInArgument(arg) {
    switch (arg.type) {
        case `redirection`:
            {
                return arg.args.some(arg => locateArgsVariableInArgument(arg));
            }
            break;
        case `argument`:
            {
                return arg.segments.some(segment => locateArgsVariableInSegment(segment));
            }
            break;
        default:
            throw new Error(`Unreacheable`);
    }
}
function locateArgsVariable(node) {
    return node.some(command => {
        while (command) {
            let chain = command.chain;
            while (chain) {
                let hasArgs;
                switch (chain.type) {
                    case `subshell`:
                        {
                            hasArgs = locateArgsVariable(chain.subshell);
                        }
                        break;
                    case `command`:
                        {
                            hasArgs = chain.envs.some(env => env.args.some(arg => {
                                return locateArgsVariableInArgument(arg);
                            })) || chain.args.some(arg => {
                                return locateArgsVariableInArgument(arg);
                            });
                        }
                        break;
                }
                if (hasArgs)
                    return true;
                if (!chain.then)
                    break;
                chain = chain.then.chain;
            }
            if (!command.then)
                break;
            command = command.then.line;
        }
        return false;
    });
}
async function execute(command, args = [], { builtins = {}, cwd = fslib_1.npath.toPortablePath(process.cwd()), env = process.env, stdin = process.stdin, stdout = process.stdout, stderr = process.stderr, variables = {}, glob = {
    isGlobPattern: fast_glob_1.default.isDynamicPattern,
    match: (pattern, { cwd, fs = fslib_1.xfs }) => fast_glob_1.default(pattern, {
        cwd: fslib_1.npath.fromPortablePath(cwd),
        // @ts-ignore: `fs` is wrapped in `PosixFS`
        fs: new fslib_1.PosixFS(fs),
    }),
}, } = {}) {
    const normalizedEnv = {};
    for (const [key, value] of Object.entries(env))
        if (typeof value !== `undefined`)
            normalizedEnv[key] = value;
    const normalizedBuiltins = new Map(BUILTINS);
    for (const [key, builtin] of Object.entries(builtins))
        normalizedBuiltins.set(key, builtin);
    // This is meant to be the equivalent of /dev/null
    if (stdin === null) {
        stdin = new stream_1.PassThrough();
        stdin.end();
    }
    const ast = parsers_1.parseShell(command, glob);
    // If the shell line doesn't use the args, inject it at the end of the
    // right-most command
    if (!locateArgsVariable(ast) && ast.length > 0 && args.length > 0) {
        let command = ast[ast.length - 1];
        while (command.then)
            command = command.then.line;
        let chain = command.chain;
        while (chain.then)
            chain = chain.then.chain;
        if (chain.type === `command`) {
            chain.args = chain.args.concat(args.map(arg => {
                return {
                    type: `argument`,
                    segments: [{
                            type: `text`,
                            text: arg,
                        }],
                };
            }));
        }
    }
    return await executeShellLine(ast, {
        args,
        builtins: normalizedBuiltins,
        initialStdin: stdin,
        initialStdout: stdout,
        initialStderr: stderr,
        glob,
    }, {
        cwd,
        environment: normalizedEnv,
        exitCode: null,
        procedures: {},
        stdin,
        stdout,
        stderr,
        variables: Object.assign(Object.create(variables), {
            [`?`]: 0,
        }),
    });
}
exports.execute = execute;