138 lines
3.7 KiB
TypeScript
138 lines
3.7 KiB
TypeScript
import { exec } from '../dependencies.ts';
|
|
|
|
export interface ShellRunOptions {
|
|
pwd: string;
|
|
}
|
|
|
|
class System {
|
|
/**
|
|
* Run any command as if you're typing in shell.
|
|
* Make sure it's Windows/MacOS/Ubuntu compatible or has alternative commands.
|
|
*
|
|
* Intended to always be silent and capture the output.
|
|
*/
|
|
static async shellRun(rawCommand: string, options: ShellRunOptions = {}) {
|
|
const { pwd } = options;
|
|
|
|
let command = rawCommand;
|
|
if (pwd) command = `cd ${pwd} ; ${command}`;
|
|
|
|
return System.newRun('sh', ['-c', command]);
|
|
}
|
|
|
|
/**
|
|
* Example:
|
|
* System.newRun(sh, ['-c', 'echo something'])
|
|
*
|
|
* private for now, but could become public if this happens to be a great replacement for the other run method.
|
|
*/
|
|
private static async newRun(command, args: string | string[] = []) {
|
|
if (!Array.isArray(args)) args = [args];
|
|
|
|
const argsString = args.join(' ');
|
|
const process = Deno.run({
|
|
cmd: [command, ...args],
|
|
stdout: 'piped',
|
|
stderr: 'piped',
|
|
});
|
|
|
|
const status = await process.status();
|
|
const outputBuffer = await process.output();
|
|
const errorBuffer = await process.stderrOutput();
|
|
|
|
process.close();
|
|
|
|
const output = new TextDecoder().decode(outputBuffer).replace(/\n+$/, '');
|
|
const error = new TextDecoder().decode(errorBuffer).replace(/\n+$/, '');
|
|
|
|
const result = { status, output };
|
|
|
|
// Log command output if verbose is enabled
|
|
if (log.isVeryVerbose) {
|
|
const symbol = status.success ? '✅' : '❗';
|
|
const truncatedOutput = output.length >= 30 ? `${output.slice(0, 27)}...` : output;
|
|
log.debug('Command:', command, argsString, symbol, {
|
|
status,
|
|
output: log.isMaxVerbose ? output : truncatedOutput,
|
|
});
|
|
}
|
|
|
|
if (error) throw new Error(error);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @deprecated use more simplified `shellRun` if possible.
|
|
*/
|
|
static async run(command, arguments_: any = [], options = {}, shouldLog = true) {
|
|
let result = '';
|
|
let error = '';
|
|
let debug = '';
|
|
|
|
const listeners = {
|
|
stdout: (dataBuffer) => {
|
|
result += dataBuffer.toString();
|
|
},
|
|
stderr: (dataBuffer) => {
|
|
error += dataBuffer.toString();
|
|
},
|
|
debug: (dataString) => {
|
|
debug += dataString.toString();
|
|
},
|
|
};
|
|
|
|
const showOutput = () => {
|
|
if (debug !== '' && shouldLog) {
|
|
log.debug(debug);
|
|
}
|
|
|
|
if (result !== '' && shouldLog) {
|
|
log.info(result);
|
|
}
|
|
|
|
if (error !== '' && shouldLog) {
|
|
log.warning(error);
|
|
}
|
|
};
|
|
|
|
const throwContextualError = (message: string) => {
|
|
let commandAsString = command;
|
|
if (Array.isArray(arguments_)) {
|
|
commandAsString += ` ${arguments_.join(' ')}`;
|
|
} else if (typeof arguments_ === 'string') {
|
|
commandAsString += ` ${arguments_}`;
|
|
}
|
|
|
|
throw new Error(`Failed to run "${commandAsString}".\n ${message}`);
|
|
};
|
|
|
|
try {
|
|
if (command.trim() === '') {
|
|
throw new Error(`Failed to execute empty command`);
|
|
}
|
|
|
|
const { exitCode, success, output } = await exec(command, arguments_, { silent: true, listeners, ...options });
|
|
showOutput();
|
|
if (!success) {
|
|
throwContextualError(`Command returned non-zero exit code (${exitCode}).\nError: ${error}`);
|
|
}
|
|
|
|
// Todo - remove this after verifying it works as expected
|
|
const trimmedResult = result.replace(/\n+$/, '');
|
|
if (!output && trimmedResult) {
|
|
log.warning('returning result instead of output for backward compatibility');
|
|
|
|
return trimmedResult;
|
|
}
|
|
|
|
return output;
|
|
} catch (inCommandError) {
|
|
showOutput();
|
|
throwContextualError(`In-command error caught: ${inCommandError}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
export default System;
|