chmod +x run

run

#!/usr/bin/env node

/* eslint-disable no-param-reassign, no-fallthrough, guard-for-in, require-atomic-updates */
const path = require('node:path');
const {Worker} = require('node:worker_threads');

const DEBUG = {parsing: false, timing: false};
const debugEnv = process.env.DEBUG;
if (debugEnv) {
  for (const name in DEBUG) {
    DEBUG[name] =
      debugEnv === 'true' || debugEnv === '1' || debugEnv.includes(name);
  }
}
const readFile = (file) => require('node:fs/promises').readFile(file, 'utf-8');
const exists = (filename) =>
  require('node:fs/promises')
    .access(filename)
    .then(() => true)
    .catch(() => false);

const $env = (env) => (env ? {...process.env, ...env} : process.env);

let markId = 0;
function measure(name, parent = '', depth = 0) {
  const start = `${parent}:${name}:${++markId}`;
  performance.mark(start);
  function end() {
    performance.measure(name, {
      start,
      detail: {depth, parent},
    });
  }
  end.submeasure = (sub) => measure(sub, start, depth + 1);
  return end;
}

const color = (code, end) => (str) => `\x1B[${code}m${str}\x1B[${end}m`;
const bold = color(1, 22);
const dim = color(2, 22);
const red = color(31, 39);
const panic = (message) => {
  console.log(red(bold('Error: ') + message));
  process.exit(1);
};

function json5(json) {
  try {
    return JSON.parse(json);
  } catch (_2) {
    return (0, eval)(`(${json})`);
  }
}

const endPkgParse = measure('parse package.json');
let pkg;
const pkgPromise = readFile('package.json').then((json) => {
  pkg = json5(json);
  endPkgParse();
  return pkg;
});

const INITIAL = 0;
const COMMAND = 1;
const ARGS = 2;

function parseShell(script) {
  script += ' ';
  const tokenizer = /(if|then|fi|&&|\|\||[ ;"'`()=])/g;
  const expectedOps = {
    ')': '(',
    fi: 'if',
  };
  const stack = [];
  const logic = [];
  let context = INITIAL;
  let token;
  let index = 0;
  let lastOp;
  let lastEnv;
  let buf = '';
  let command = {name: '', args: [], env: {}};
  const root = [];
  let seq = root;
  const commit = () => {
    if (context === INITIAL) {
      if (lastEnv) {
        if (!command) seq.push((command = {name: '', args: [], env: {}}));
        command.env[lastEnv] = buf;
        lastEnv = undefined;
      } else if (buf) {
        if (!command) seq.push((command = {name: '', args: [], env: {}}));
        command.name = buf;
        context = ARGS;
      }
    } else if (context === ARGS) {
      // unquote
      if (buf[0] === "'" && buf.at(-1) === "'") {
        buf = buf.slice(1, -1);
      } else if (buf[0] === '"' && buf.at(-1) === '"') {
        buf = buf.slice(1, -1).replaceAll('\\"', '"');
      }
      command.args.push(buf);
    }
    buf = '';
  };
  while ((token = tokenizer.exec(script))) {
    let op = token[0];
    buf += script.substring(index, token.index);
    index = tokenizer.lastIndex;
    switch (op) {
      case '&&':
      case '||':
        if (lastOp) continue;
        seq.push({type: op});
      case ';':
        if (lastOp) continue;
        commit();
        command = null;
        context = INITIAL;
        break;
      case ' ':
        if (!buf) continue;
        if (lastOp) {
          if (buf) buf += ' ';
          continue;
        }
        commit();
        break;
      case '=':
        if (context === INITIAL && !lastOp) {
          lastEnv = buf;
          buf = '';
        } else {
          buf += op;
        }
        break;
      case 'if':
        if (context !== INITIAL) {
          buf += op;
          continue;
        }
        logic.push({
          type: 'conditional',
          test: [],
          consequent: [],
          alternate: [],
        });
        seq = logic.at(-1)?.test;
        command = null;
        context = INITIAL;
        break;
      case 'then':
        if (context !== INITIAL) {
          buf += op;
          continue;
        }
        seq = logic.at(-1)?.consequent;
        command = null;
        context = INITIAL;
        break;
      case 'else':
        if (context !== INITIAL) {
          buf += op;
          continue;
        }
        seq = logic.at(-1)?.alternate;
        command = null;
        context = INITIAL;
        break;
      case 'fi':
        if (context !== INITIAL) {
          buf += op;
          continue;
        }
        seq = root;
        if (logic.length) seq.push(logic.pop());
        break;
      case '(':
      case ')':
      case '"':
      case `'`:
      case '`':
        buf += op;
      default:
        if (op in expectedOps) {
          const start = expectedOps[op];
          if (lastOp !== start) {
            const line = `${script}\n${'-'.repeat(token.index)}^`;
            panic(`unexpected "${op}"\n${dim(line)}`);
          }
          op = start;
        }
        if (lastOp === op) {
          stack.pop();
          lastOp = stack.at(-1);
        } else {
          stack.push(op);
          lastOp = op;
        }
        break;
    }
  }
  if (command && seq.at(-1) !== command) seq.push(command);
  return seq;
}

async function run(seq, env = {}) {
  let prev = true;
  for (const node of seq) {
    switch (node.type) {
      case '&&':
        if (!prev) return;
        break;
      case '||':
        if (prev) return prev;
        break;
      case 'conditional':
        if (await run(node.test, env)) {
          prev = await run(node.consequent, env);
        } else if (node.alternate) {
          prev = await run(node.alternate, env);
        }
        break;
      default:
        if (node.name === '$npm_execpath' || node.name === 'npm') {
          let script = node.args.shift();
          if (script === 'run') script = node.args.shift();
          prev = await runScript(script, node.args, {...env, ...node.env});
        } else if (node.name === 'node') {
          const script = node.args.shift();
          prev = await runNode(script, node.args, {...env, ...node.env});
        } else if (node.name === 'test') {
          const a1 = node.args[0].replace(
            /$([a-z0-9_]+)/g,
            (_, c) => process.env[c] ?? _,
          );
          const a2 = node.args[2].replace(
            /$([a-z0-9_]+)/g,
            (_, c) => process.env[c] ?? _,
          );
          if (node.args[1] === '=') prev = a1 === a2;
          else if (node.args[1] === '!=') prev = a1 !== a2;
        } else if (node.name) {
          // panic(`Unknown command ${node.name} (${node.args})`);
          prev = await runBin(node.name, node.args, node.env);
        } else {
          panic(`Unknown node ${JSON.stringify(node)}`);
        }
    }
  }
  return prev;
}

const workerShim = `
const {parentPort} = require('node:worker_threads');
const {dirname, basename, sep} = require('path');
parentPort.once('message', ([mod, filename, args, env, compiledCode]) => {
  process.stdout.isTTY = process.stdin.isTTY = process.stderr.isTTY = true;
  process.argv = [process.argv[0], filename].concat(args);
  module.id = basename(filename);
  module.filename = __filename = filename;
  module.path = __dirname = dirname(__filename);
  Object.assign(process.env, env);
  parentPort.postMessage(0);
  const exit = process.exit.bind(process);
  process.exit = (exitCode) => {
    process.stdout.end();
    process.setUncaughtExceptionCaptureCallback(() => {});
    setTimeout(exit, 0, exitCode);
  };
  if (mod && !compiledCode) return import(filename);
  require = require('node:module').createRequire(require.resolve(filename));
  require('vm').runInThisContext(compiledCode || require('fs').readFileSync(filename, 'utf-8'), {filename});
});
`;
const workerPool = {
  workers: [],
  get: () => workerPool.workers.pop() ?? workerPool.create(),
  create: () => new Worker(workerShim, {eval: true}),
};
workerPool.workers.push(workerPool.create());

const pkgCache = new Map();
function getPkg(filename) {
  const index = filename.lastIndexOf('/node_modules/');
  if (index === -1) return pkgPromise;
  const pkgName = filename.slice(index + 14).match(/^(@[^/]+\/)?[^/]+/g)[0];
  const pkgFile = `${filename.slice(0, index + 14)}${pkgName}/package.json`;
  const cached = pkgCache.get(pkgFile);
  if (cached) return cached;
  const prom = readFile(pkgFile).then(json5);
  pkgCache.set(pkgFile, prom);
  return prom;
}

async function runNode(script, args, env, compiledCode) {
  if (
    process.env.ESBUILD === 'force' &&
    compiledCode === undefined &&
    !script.endsWith('.built.mjs')
  ) {
    return runTs(script, args, env);
  }
  const scriptId = `node(${script} ${args.join(' ')})`;
  const done = measure(scriptId);
  const filename = path.resolve(script);

  const isModule =
    filename.endsWith('.mjs') ||
    ((await getPkg(filename)).type === 'module' && !filename.endsWith('.cjs'));

  return new Promise((resolve) => {
    const end = done.submeasure('worker start');
    const worker = workerPool.get();
    worker.postMessage([isModule, filename, args, $env(env), compiledCode]);
    worker.once('message', done.submeasure('worker init'));
    worker.once('exit', done);
    worker.once('exit', resolve);
    end();
  });
}

async function runTs(script, args, env) {
  const end = measure(`esbuild(${script})`);
  const {build} = require('esbuild');
  const outfile = script.endsWith('.mjs')
    ? script.replace(/([^/]+)\.mjs$/, '.$1.built.mjs')
    : undefined;
  if (!outfile && !/\.[a-z]+$/.test(script)) {
    const [ext, index] = await Promise.all([
      exists(`${script}.ts`),
      exists(`${script}/index.ts`),
    ]);
    if (ext) script += '.ts';
    else if (index) script += '/index.ts';
  }
  const result = await build({
    bundle: true,
    entryPoints: [script],
    target: 'node20',
    platform: 'node',
    format: outfile ? 'esm' : 'cjs',
    packages: 'external',
    write: Boolean(outfile),
    outfile,
    treeShaking: true,
    minifyIdentifiers: true,
    minifySyntax: true,
    nodePaths: [],
  });
  if (result.errors.length) {
    panic(`TS build of ${script} failed:\n${result.errors.join('\n')}`);
  }

  if (outfile) {
    end();
    try {
      return await runNode(outfile, args, env);
    } finally {
      require('node:fs').unlink(outfile, Object);
    }
  }
  let code = result.outputFiles[0].text;

  // move top-level requires to callsites so they only get evaluated when surrounding code is executed
  const idents = {};
  code = code.replace(
    /(?:^var (import_[a-zA-Z0-9_$]+) = ((?:__toESM\()?require\("[^"]+"\)\)?);?$|\b(import_[a-zA-Z0-9_$]+)\b)/gm,
    (_, ident, req, ident2) => {
      if (ident2) return idents[ident2] ?? ident2;
      idents[ident] = req;
      return '';
    },
  );
  end();
  // process.setSourceMapsEnabled(true);
  return runNode(script, args, env, code);
}

const BIN = {
  'ts-node': (args, env) => {
    let script;
    const remainingArgs = args.filter((arg) => {
      if (arg[0] === '-' || script) return true;
      script = arg;
      return false;
    });
    return runTs(script, remainingArgs, env);
  },
};

async function runBin(bin, args, env) {
  if (Object.prototype.hasOwnProperty.call(BIN, bin)) {
    return BIN[bin](args, env);
  }
  let resolvedBin = bin;
  try {
    const done = measure(`resolve-bin(${bin} ${args.join(' ')})`);
    const code = await readFile(`node_modules/.bin/${bin}`);
    resolvedBin = `node_modules/.bin/${bin}`;
    // exec node  "$basedir/../vite/bin/vite.js" "$@"
    const match = code.match(/exec +node +"([^"]+)" +"\$@"/)?.[1];
    if (!match) throw Error(`Unknown format at node_modules/.bin/${bin}`);
    const binFile = path.resolve(
      match.replace('$basedir', './node_modules/.bin'),
    );
    const binRel = path.relative('.', binFile);
    done();
    return runNode(binRel, args, env);
  } catch (err) {
    const done = measure(`run-bin(${bin} ${args.join(' ')})`);
    // console.error(`failed to run "${bin}" seamlessly:`, err);
    return new Promise((resolve) => {
      const {spawn} = require('node:child_process');
      const proc = spawn(resolvedBin, args, {env: $env(env), stdio: 'inherit'});
      // proc.on('error', reject);
      proc.once('exit', (exitCode) => {
        done();
        resolve(exitCode);
      });
    });
  }
}

async function runScript(scriptName, args, env) {
  const script = (await pkgPromise).scripts[scriptName];
  if (!script) {
    const bin = path.basename(scriptName);
    if (await exists(`node_modules/.bin/${bin}`)) {
      return runBin(bin, args, env);
    }
    panic(`Unknown script "${scriptName}".`);
  }
  let scriptWithArgs = script;
  for (const arg of args) scriptWithArgs += ` ${arg}`;
  const done = measure('parse');
  const parsed = parseShell(scriptWithArgs);
  if (DEBUG.parsing) console.log('parsed: ', scriptWithArgs, parsed);
  done();
  return run(parsed, env);
}

(async () => {
  const start = performance.now();
  const cmd = path.basename(process.argv[1]);
  const runner = cmd === 'exec' ? runBin : runScript;
  const name = process.argv[2];
  if (!name) panic('No script name provided.');
  try {
    process.exitCode = await runner(name, process.argv.slice(3));
  } finally {
    let worker;
    while ((worker = workerPool.workers?.pop())) worker.terminate();
    if (DEBUG.timing) {
      console.log(bold(dim(`Done in ${(performance.now() - start) | 0}ms:`)));
      const dur = (ms) => (ms < 1 ? `${(ms * 1000) | 0}µs` : `${ms | 0}ms`);
      for (const entry of performance.getEntriesByType('measure')) {
        const pfx = entry.detail.depth ? '  '.repeat(entry.detail.depth) : '';
        console.log(dim(`${pfx}⏱ ${dur(entry.duration)}: ${entry.name}`));
      }
    }
  }
})();