libdragon 10.6.0 → 10.7.0

package/modules/helpers.js

@@ -1,7 +1,7 @@
 const path = require('path');
 const fs = require('fs/promises');
 const fsClassic = require('fs');
-const chalk = require('chalk');
+const chalk = require('chalk').stderr;
 const { spawn } = require('child_process');
 
 const { globals } = require('./globals');
@@ -18,8 +18,9 @@ class CommandError extends Error {
 
 // The user provided an unexpected input
 class ParameterError extends Error {
-  constructor(message) {
+  constructor(message, actionName) {
     super(message);
+    this.actionName = actionName;
   }
 }
 
@@ -50,51 +51,90 @@ async function dirExists(path) {
     });
 }
 
-// A simple Promise wrapper for child_process.spawn. If interactive is true,
-// stdout becomes a tty when available and we cannot read the stdout from the
-// command anymore. If interactive is "full", the error stream is also piped to
-// the main process as TTY, so it is not readable anymore as well. For the
-// commands using stderr as TTY it should be set to "full"
-function spawnProcess(cmd, params = [], userCommand, interactive = false) {
+// A simple Promise wrapper for child_process.spawn. Return the err/out streams
+// from the process by default. Specify inheritStdout / inheritStderr to disable
+// this and inherit the parent process's stream, passing through the TTY if any.
+function spawnProcess(
+  cmd,
+  params = [],
+  {
+    // Used to decorate the potential CommandError with a prop such that we can
+    // report this error back to the user.
+    userCommand = false,
+    // This is the stream where the process will receive its input.
+    stdin,
+    // If this is true, the related stream is inherited from the parent process
+    // and we cannot read them anymore. So if you need to read a stream, you
+    // should disable it. When disabled, the relevant stream cannot be a tty
+    // anymore. By default, we expect the caller to read err/out.
+    inheritStdin = true,
+    inheritStdout = false,
+    inheritStderr = false,
+    // Passthrough to spawn
+    spawnOptions = {},
+  } = {
+    userCommand: false,
+    inheritStdin: true,
+    inheritStdout: false,
+    inheritStderr: false,
+    spawnOptions: {},
+  }
+) {
   return new Promise((resolve, reject) => {
-    let stdout = [];
-    let stderr = [];
+    const stdout = [];
+    const stderr = [];
 
-    if (globals.verbose) {
-      log(chalk.grey(`Spawning: ${cmd} ${params.join(' ')}`), true);
-    }
+    log(chalk.grey(`Spawning: ${cmd} ${params.join(' ')}`), true);
 
-    const isTTY =
-      process.stdin.isTTY && process.stdout.isTTY && process.stderr.isTTY;
-    const enableTTY = isTTY && !!interactive;
-    const enableErrorTTY = isTTY && interactive === 'full';
+    const enableInTTY = Boolean(process.stdin.isTTY) && inheritStdin;
+    const enableOutTTY = Boolean(process.stdout.isTTY) && inheritStdout;
+    const enableErrorTTY = Boolean(process.stderr.isTTY) && inheritStderr;
 
     const command = spawn(cmd, params, {
-      // We should redirect streams together for the TTY to work
-      // properly if they are all used as TTY
       stdio: [
-        enableTTY ? 'inherit' : 'pipe',
-        enableTTY ? 'inherit' : 'pipe',
+        enableInTTY ? 'inherit' : 'pipe',
+        enableOutTTY ? 'inherit' : 'pipe',
         enableErrorTTY ? 'inherit' : 'pipe',
       ],
+      ...spawnOptions,
     });
 
-    if (!enableTTY && (globals.verbose || userCommand)) {
-      command.stdout.pipe(process.stdout);
+    // See a very old related issue: https://github.com/nodejs/node/issues/947
+    // When the stream is not fully consumed by the pipe target and it exits,
+    // an EPIPE or EOF is thrown. We don't care about those.
+    const eatEpipe = (err) => {
+      if (err.code !== 'EPIPE' && err.code !== 'EOF') {
+        throw err;
+      }
+      // No need to listen for close anymore
+      command.off('close', closeHandler);
+
+      // It was not fully consumed, just resolve into an empty string
+      // No one should be using this anyways. Ideally we could clean a few
+      // last bytes from the buffers to create a correct utf-8 string.
+      resolve('');
+    };
+
+    if (!enableInTTY && stdin) {
+      stdin.pipe(command.stdin);
     }
 
-    if (!enableErrorTTY && (globals.verbose || userCommand)) {
-      command.stderr.pipe(process.stderr);
+    if (!enableOutTTY && (globals.verbose || userCommand)) {
+      command.stdout.pipe(process.stdout);
+      process.stdout.once('error', eatEpipe);
     }
 
-    // We shouldn't need to collect the data if it is a user command.
-    if (!enableTTY && !userCommand) {
+    if (!inheritStdout) {
       command.stdout.on('data', function (data) {
         stdout.push(Buffer.from(data));
       });
     }
 
-    if (!enableErrorTTY) {
+    if (!enableErrorTTY && (globals.verbose || userCommand)) {
+      command.stderr.pipe(process.stderr);
+    }
+
+    if (!inheritStderr) {
       command.stderr.on('data', function (data) {
         stderr.push(Buffer.from(data));
       });
@@ -106,6 +146,9 @@ function spawnProcess(cmd, params = [], userCommand, interactive = false) {
     };
 
     const closeHandler = function (code) {
+      // The stream was fully consumed, if there is this an additional error on
+      // stdout, it must be a legitimate error
+      process.stdout.off('error', eatEpipe);
       command.off('error', errorHandler);
       if (code === 0) {
         resolve(Buffer.concat(stdout).toString());
@@ -127,20 +170,39 @@ function spawnProcess(cmd, params = [], userCommand, interactive = false) {
   });
 }
 
-function dockerExec(
-  libdragonInfo,
-  dockerParams,
-  cmdWithParams,
-  userCommand,
-  interactive
-) {
+function dockerExec(libdragonInfo, dockerParams, cmdWithParams, options) {
+  assert(
+    libdragonInfo.containerId,
+    new Error('Trying to invoke dockerExec without a containerId.')
+  );
+
   // TODO: assert for invalid args
   const haveDockerParams =
     Array.isArray(dockerParams) && Array.isArray(cmdWithParams);
-  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
-  // interactive and TTY?
-  const additionalParams =
-    isTTY && (haveDockerParams ? interactive : userCommand) ? ['-it'] : [];
+
+  if (!haveDockerParams) {
+    options = cmdWithParams;
+  }
+
+  const additionalParams = [];
+
+  // Docker TTY wants in & out streams both to be a TTY
+  // If no options are provided, disable TTY as spawnProcess defaults to no
+  // inherit as well.
+  const enableTTY = options
+    ? options.inheritStdout && options.inheritStdin
+    : false;
+  const ttyEnabled = enableTTY && process.stdout.isTTY && process.stdin.isTTY;
+
+  if (ttyEnabled) {
+    additionalParams.push('-t');
+  }
+
+  // Always enable stdin, also see; https://github.com/anacierdem/libdragon-docker/issues/45
+  // Currently we run all exec commands in stdin mode even if the actual process
+  // does not need any input. This will eat any user input by default.
+  additionalParams.push('-i');
+
   return spawnProcess(
     'docker',
     [
@@ -151,8 +213,7 @@ function dockerExec(
       libdragonInfo.containerId,
       ...(haveDockerParams ? cmdWithParams : dockerParams),
     ],
-    haveDockerParams ? userCommand : cmdWithParams,
-    haveDockerParams ? interactive : userCommand
+    options
   );
 }
 
@@ -223,16 +284,21 @@ function assert(condition, error) {
   }
 }
 
-// TODO: we can handle showStatus here
+function print(text) {
+  // eslint-disable-next-line no-console
+  console.log(text);
+  return;
+}
+
 function log(text, verboseOnly = false) {
   if (!verboseOnly) {
     // eslint-disable-next-line no-console
-    console.log(text);
+    console.error(text);
     return;
   }
   if (globals.verbose) {
     // eslint-disable-next-line no-console
-    console.log(chalk.gray(text));
+    console.error(chalk.gray(text));
     return;
   }
 }
@@ -241,6 +307,7 @@ module.exports = {
   spawnProcess,
   toPosixPath,
   toNativePath,
+  print,
   log,
   dockerExec,
   assert,

package/modules/parameters.js

@@ -0,0 +1,129 @@
+const chalk = require('chalk').stderr;
+
+const { log } = require('./helpers');
+const actions = require('./actions');
+const { fn: printUsage } = require('./actions/help');
+const { STATUS_BAD_PARAM } = require('./constants');
+const { globals } = require('./globals');
+
+const parseParameters = async (argv) => {
+  const options = {
+    EXTRA_PARAMS: [],
+    CURRENT_ACTION: undefined,
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const val = argv[i];
+
+    if (['--verbose', '-v'].includes(val)) {
+      options.VERBOSE = true;
+      globals.verbose = true;
+      continue;
+    }
+
+    // TODO: we might move these to actions as well.
+    if (['--image', '-i'].includes(val)) {
+      options.DOCKER_IMAGE = argv[++i];
+      continue;
+    } else if (val.indexOf('--image=') === 0) {
+      options.DOCKER_IMAGE = val.split('=')[1];
+      continue;
+    }
+
+    if (['--directory', '-d'].includes(val)) {
+      options.VENDOR_DIR = argv[++i];
+      continue;
+    } else if (val.indexOf('--directory=') === 0) {
+      options.VENDOR_DIR = val.split('=')[1];
+      continue;
+    }
+
+    if (['--strategy', '-s'].includes(val)) {
+      options.VENDOR_STRAT = argv[++i];
+      continue;
+    } else if (val.indexOf('--strategy=') === 0) {
+      options.VENDOR_STRAT = val.split('=')[1];
+      continue;
+    }
+
+    if (['--file', '-f'].includes(val)) {
+      options.FILE = argv[++i];
+      continue;
+    } else if (val.indexOf('--file=') === 0) {
+      options.FILE = val.split('=')[1];
+      continue;
+    }
+
+    if (val.indexOf('-') == 0) {
+      log(chalk.red(`Invalid flag \`${val}\``));
+      printUsage();
+      process.exit(STATUS_BAD_PARAM);
+    }
+
+    if (options.CURRENT_ACTION) {
+      log(chalk.red(`Expected only a single action, found: \`${val}\``));
+      printUsage();
+      process.exit(STATUS_BAD_PARAM);
+    }
+
+    options.CURRENT_ACTION = actions[val];
+
+    if (!options.CURRENT_ACTION) {
+      log(chalk.red(`Invalid action \`${val}\``));
+      printUsage();
+      process.exit(STATUS_BAD_PARAM);
+    }
+
+    if (options.CURRENT_ACTION.forwardsRestParams) {
+      options.EXTRA_PARAMS = argv.slice(i + 1);
+      break;
+    }
+  }
+
+  if (!options.CURRENT_ACTION) {
+    log(chalk.red('No action provided'));
+    printUsage();
+    process.exit(STATUS_BAD_PARAM);
+  }
+
+  if (
+    options.CURRENT_ACTION === actions.exec &&
+    options.EXTRA_PARAMS.length === 0
+  ) {
+    log(chalk.red('You should provide a command to exec'));
+    printUsage(undefined, [options.CURRENT_ACTION.name]);
+    process.exit(STATUS_BAD_PARAM);
+  }
+
+  if (
+    ![actions.init, actions.install, actions.update].includes(
+      options.CURRENT_ACTION
+    ) &&
+    options.DOCKER_IMAGE
+  ) {
+    log(chalk.red('Invalid flag: image'));
+    printUsage(undefined, [options.CURRENT_ACTION.name]);
+    process.exit(STATUS_BAD_PARAM);
+  }
+
+  if (
+    options.VENDOR_STRAT &&
+    !['submodule', 'subtree', 'manual'].includes(options.VENDOR_STRAT)
+  ) {
+    log(chalk.red(`Invalid strategy \`${options.VENDOR_STRAT}\``));
+    printUsage();
+    process.exit(STATUS_BAD_PARAM);
+  }
+
+  if (![actions.disasm].includes(options.CURRENT_ACTION) && options.FILE) {
+    log(chalk.red('Invalid flag: file'));
+    printUsage(undefined, [options.CURRENT_ACTION.name]);
+    process.exit(STATUS_BAD_PARAM);
+  }
+
+  return { options };
+};
+
+module.exports = {
+  parseParameters,
+};

package/modules/project-info.js

@@ -4,8 +4,7 @@ const fs = require('fs/promises');
 
 const {
   checkContainerAndClean,
-  runGitMaybeHost,
-  tryCacheContainerId,
+  initGitAndCacheContainerId,
 } = require('./actions/utils');
 
 const { findNPMRoot } = require('./actions/npm-utils');
@@ -27,8 +26,12 @@ const {
   spawnProcess,
   toPosixPath,
   assert,
+  ParameterError,
 } = require('./helpers');
 
+const initAction = require('./actions/init');
+const destroyAction = require('./actions/destroy');
+
 async function findContainerId(libdragonInfo) {
   const idFile = path.join(libdragonInfo.root, '.git', CACHED_CONTAINER_FILE);
   if (await fileExists(idFile)) {
@@ -49,7 +52,13 @@ async function findContainerId(libdragonInfo) {
     ])
   )
     .split('\n')
-    .filter((s) => s.includes(`${libdragonInfo.root} `));
+    // docker seem to save paths with posix separators but make sure we look for
+    // both, just in case
+    .filter(
+      (s) =>
+        s.includes(`${toPosixPath(libdragonInfo.root)} `) ||
+        s.includes(`${libdragonInfo.root} `)
+    );
 
   if (candidates.length > 0) {
     const str = candidates[0];
@@ -57,11 +66,12 @@ async function findContainerId(libdragonInfo) {
     const idIndex = str.indexOf(shortId);
     const longId = str.slice(idIndex, idIndex + 64);
     if (longId.length === 64) {
-      // If there is managed vendoring, make sure we have a git repo
-      if (libdragonInfo.vendorStrategy !== 'manual') {
-        await runGitMaybeHost(libdragonInfo, ['init']);
-      }
-      await tryCacheContainerId({ ...libdragonInfo, containerId: longId });
+      const newInfo = { ...libdragonInfo, containerId: longId };
+      // This shouldn't happen but if the user somehow deleted the .git folder
+      // (we don't have the container id file at this point) we can recover the
+      // project. `git init` is safe anyways and it is not executed if strategy
+      // is `manual`
+      await initGitAndCacheContainerId(newInfo);
       return longId;
     }
   }
@@ -90,14 +100,36 @@ async function findGitRoot() {
   }
 }
 
-async function readProjectInfo() {
+async function readProjectInfo(info) {
+  // No need to do anything here if the action does not depend on the project
+  // The only exception is the init and destroy actions, which do not need an
+  // existing project but readProjectInfo must always run to analyze the situation
+  const forceReadProjectInfo = [initAction, destroyAction].includes(
+    info.options.CURRENT_ACTION
+  );
+  if (
+    info.options.CURRENT_ACTION.mustHaveProject === false &&
+    !forceReadProjectInfo
+  ) {
+    return info;
+  }
+
   const projectRoot = await findLibdragonRoot();
 
-  let info = {
+  if (!projectRoot && !forceReadProjectInfo) {
+    throw new ParameterError(
+      'This is not a libdragon project. Initialize with `libdragon init` first.',
+      info.options.CURRENT_ACTION.name
+    );
+  }
+
+  info = {
+    ...info,
     root: projectRoot ?? (await findNPMRoot()) ?? (await findGitRoot()),
     userInfo: os.userInfo(),
 
     // Use this to discriminate if there is a project when the command is run
+    // Only used for the init action ATM, and it is not ideal to have this here
     haveProjectConfig: !!projectRoot,
 
     // Set the defaults immediately, these should be present at all times even
@@ -169,7 +201,7 @@ async function readProjectInfo() {
 }
 
 /**
- * @param info This is only the base info without action properties like showStatus
+ * @param info This is only the base info without options
  * fn and command line options
  */
 async function writeProjectInfo(info) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libdragon",
-  "version": "10.6.0",
+  "version": "10.7.0",
   "description": "This is a docker wrapper for libdragon",
   "main": "index.js",
   "engines": {

package/skeleton/Makefile

@@ -13,7 +13,7 @@ hello.z64: N64_ROM_TITLE="Hello World"
 $(BUILD_DIR)/hello.elf: $(OBJS)
 
 clean:
-	rm -f $(BUILD_DIR) *.z64
+	rm -f $(BUILD_DIR)/* *.z64
 .PHONY: clean
 
 -include $(wildcard $(BUILD_DIR)/*.d)