libdragon 10.4.2 → 10.7.0

package/modules/actions/help.js

@@ -1,9 +1,10 @@
 const chalk = require('chalk');
 const commandLineUsage = require('command-line-usage');
 
-const { log } = require('../helpers');
+const { print } = require('../helpers');
 
-const printUsage = (_, actionArr) => {
+const printUsage = (info) => {
+  const actions = require('./');
   const globalOptionDefinitions = [
     {
       name: 'verbose',
@@ -11,7 +12,6 @@ const printUsage = (_, actionArr) => {
         'Be verbose. This will print all commands dispatched and their outputs as well. Will also start printing error stack traces.',
       alias: 'v',
       typeLabel: ' ',
-      group: 'global',
     },
   ];
 
@@ -26,7 +26,7 @@ const printUsage = (_, actionArr) => {
     },
     {
       name: 'directory',
-      description: `Directory where libdragon files are expected. It must be a project relative path as it will be mounted on the docker container. The cli will create and manage it when using a non-manual strategy. Defaults to \`./libdragon\` if not provided.\n`,
+      description: `Directory where libdragon files are expected. It must be inside the libdragon project as it will be mounted on the docker container. The cli will create and manage it when using a non-manual strategy. Defaults to \`./libdragon\` if not provided.\n`,
       alias: 'd',
       typeLabel: '<path>',
       group: 'vendoring',
@@ -42,107 +42,48 @@ const printUsage = (_, actionArr) => {
         You can always switch to manual by re-running \`init\` with \`--strategy manual\`, though you will be responsible for managing the existing submodule/subtree. Also it is not possible to automatically switch back.
 
         With the \`manual\` strategy, it is still recommended to have a git repository at project root such that container actions can execute faster by caching the container id inside the \`.git\` folder.\n`,
-      alias: 'v',
+      alias: 's',
       typeLabel: '<strategy>',
       group: 'vendoring',
     },
   ];
 
-  // TODO: move these to respective actions
-
-  const actions = {
-    help: {
-      name: 'help [action]',
-      summary: 'Display this help information or details for the given action.',
-    },
-    init: {
-      name: 'init',
-      summary: 'Create a libdragon project in the current directory.',
-      description: `Creates a libdragon project in the current directory. Every libdragon project will have its own docker container instance. If you are in a git repository or an NPM project, libdragon will be initialized at their root also marking there with a \`.libdragon\` folder. Do not remove the \`.libdragon\` folder and commit its contents if you are using source control, as it keeps persistent libdragon project information.
-
-      By default, a git repository and a submodule at \`./libdragon\` will be created to automatically update the vendored libdragon files on subsequent \`update\`s. If you intend to opt-out from this feature, see the \`--strategy manual\` flag to provide your self-managed libdragon copy. The default behaviour is intended for users who primarily want to consume libdragon as is.
-
-      If this is the first time you are creating a libdragon project at that location, this action will also create skeleton project files to kickstart things with the given image, if provided. For subsequent runs, it will act like \`start\` thus can be used to revive an existing project without modifying it.`,
-      group: ['docker', 'vendoring'],
-    },
-    make: {
-      name: 'make [params]',
-      summary: 'Run the libdragon build system in the current directory.',
-      description: `Runs the libdragon build system in the current directory. It will mirror your current working directory to the container.
-
-      Must be run in an initialized libdragon project. This action is a shortcut to the \`exec\` action under the hood.`,
-    },
-    exec: {
-      name: 'exec <command>',
-      summary: 'Execute given command in the current directory.',
-      description: `Executes the given command in the container passing down any arguments provided. If you change your host working directory, the command will be executed in the corresponding folder in the container as well.
-
-      This action will first try to execute the command in the container and if the container is not accessible, it will attempt a complete \`start\` cycle.
-
-      This will properly passthrough your TTY if you have one. So by running \`libdragon exec bash\` you can start an interactive bash session with full TTY support.
-      
-      Must be run in an initialized libdragon project.`,
-    },
-    start: {
-      name: 'start',
-      summary: 'Start the container for current project.',
-      description: `Start the container assigned to the current libdragon project. Will first attempt to start an existing container if found, followed by a new container run and installation similar to the \`install\` action. Will always print out the container id on success.
-
-        Must be run in an initialized libdragon project.`,
-    },
-    name: {
-      name: 'stop',
-      summary: 'Stop the container for current project.',
-      description: `Stop the container assigned to the current libdragon project.
-
-        Must be run in an initialized libdragon project.`,
-    },
-    install: {
-      name: 'install',
-      summary: 'Vendor libdragon as is.',
-      description: `Attempts to build and install everything libdragon related into the container. This includes all the tools and third parties used by libdragon except for the toolchain. If you have made changes to libdragon, you can execute this action to build everything based on your changes. Requires you to have an intact vendoring target (also see the \`--directory\` flag). If you are not working on libdragon itself, you can just use the \`update\` action instead.
-
-      Must be run in an initialized libdragon project. This can be useful to recover from a half-baked container.`,
-    },
-    update: {
-      name: 'update',
-      summary: 'Update libdragon and do an install.',
-      description: `Will update the docker image and if you are using auto-vendoring (see \`--strategy\`), will also update the submodule/subtree from the remote branch (\`trunk\`) with a merge/squash strategy and then perform a \`libdragon install\`. You can use the \`install\` action to only update all libdragon related artifacts in the container.
-
-        Must be run in an initialized libdragon project.`,
-      group: ['docker'],
-    },
-  };
-
-  const actionsToShow = actionArr
-    ?.filter((action) => Object.keys(actions).includes(action))
-    .filter((action) => !['help'].includes(action));
+  const actionsToShow =
+    info?.options.EXTRA_PARAMS?.filter(
+      (action) =>
+        Object.keys(actions).includes(action) && !['help'].includes(action)
+    ) ?? (info ? [info.options.CURRENT_ACTION.name] : []);
 
   const sections = [
     {
       header: chalk.green('Usage:'),
-      content: 'libdragon [flags] <action>',
+      content: `libdragon [flags] <action>
+
+      Joining flags not supported, provide them separately like \`-v -i\` `,
     },
     ...(actionsToShow?.length
       ? actionsToShow.flatMap((action) => [
           {
             header: chalk.green(`${action} action:`),
-            content: actions[action].description,
+            content: actions[action].usage.description,
           },
-          actions[action].group
+          actions[action].usage.group || actions[action].usage.optionList
             ? {
                 header: `accepted flags:`,
-                optionList: optionDefinitions,
-                group: actions[action].group,
+                optionList: [
+                  ...(actions[action].usage.group ? optionDefinitions : []),
+                  ...(actions[action].usage.optionList ?? []),
+                ],
+                group: actions[action].usage.group,
               }
             : {},
         ])
       : [
           {
             header: chalk.green('Available Commands:'),
-            content: Object.values(actions).map((action) => ({
-              name: action.name,
-              summary: action.summary,
+            content: Object.values(actions).map(({ usage }) => ({
+              name: usage.name,
+              summary: usage.summary,
             })),
           },
         ]),
@@ -152,12 +93,16 @@ const printUsage = (_, actionArr) => {
     },
   ];
   const usage = commandLineUsage(sections);
-  log(usage);
+  print(usage);
 };
 
 module.exports = {
   name: 'help',
   fn: printUsage,
-  showStatus: true,
   forwardsRestParams: true,
+  mustHaveProject: false,
+  usage: {
+    name: 'help [action]',
+    summary: 'Display this help information or details for the given action.',
+  },
 };

package/modules/actions/index.js

@@ -1,25 +1,16 @@
-const { fn: exec } = require('./exec');
-
-const make = async (libdragonInfo, params) => {
-  await exec(libdragonInfo, ['make', ...params]);
-};
-
-// TODO: separate into files
 module.exports = {
-  start: require('./start'),
-  stop: require('./stop'),
   init: require('./init'),
+  make: require('./make'),
 
+  update: require('./update'),
   exec: require('./exec'),
-  make: {
-    name: 'make',
-    fn: make,
-    forwardsRestParams: true,
-    showStatus: true,
-  },
-
+  disasm: require('./disasm'),
   install: require('./install'),
-  update: require('./update'),
+
+  start: require('./start'),
+  stop: require('./stop'),
 
   help: require('./help'),
+  version: require('./version'),
+  destroy: require('./destroy'),
 };

package/modules/actions/init.js

@@ -1,13 +1,13 @@
 const fs = require('fs/promises');
 const path = require('path');
 
-const chalk = require('chalk');
+const chalk = require('chalk').stderr;
 
 const { fn: install } = require('./install');
 const { start } = require('./start');
 const {
   installDependencies,
-  tryCacheContainerId,
+  initGitAndCacheContainerId,
   updateImage,
   runGitMaybeHost,
 } = require('./utils');
@@ -24,8 +24,9 @@ const {
   CommandError,
   ParameterError,
   ValidationError,
+  toPosixPath,
+  toNativePath,
 } = require('../helpers');
-const { setProjectInfoToSave } = require('../project-info');
 
 const autoVendor = async (libdragonInfo) => {
   await runGitMaybeHost(libdragonInfo, ['init']);
@@ -79,10 +80,10 @@ const autoVendor = async (libdragonInfo) => {
  * Initialize a new libdragon project in current working directory
  * Also downloads the image
  */
-async function init(libdragonInfo) {
-  log(`Initializing a libdragon project at ${libdragonInfo.root}`);
+async function init(info) {
+  log(`Initializing a libdragon project at ${info.root}`);
 
-  let newInfo = libdragonInfo;
+  let newInfo = info;
 
   // Validate manifest
   const manifestPath = path.join(newInfo.root, LIBDRAGON_PROJECT_MANIFEST);
@@ -105,31 +106,29 @@ async function init(libdragonInfo) {
     newInfo.vendorStrategy !== newInfo.options.VENDOR_STRAT
   ) {
     throw new ParameterError(
-      `Requested strategy switch: ${newInfo.vendorStrategy} -> ${newInfo.options.VENDOR_STRAT} It is not possible to switch vendoring strategy after initializing a project. You can always switch to manual and handle libdragon yourself.`
+      `Requested strategy switch: ${newInfo.vendorStrategy} -> ${newInfo.options.VENDOR_STRAT} It is not possible to switch vendoring strategy after initializing a project. You can always switch to manual and handle libdragon yourself.`,
+      info.options.CURRENT_ACTION.name
     );
   }
 
   // Update the strategy information for the project if the flag is provided
   if (newInfo.options.VENDOR_STRAT) {
-    newInfo = setProjectInfoToSave({
-      ...newInfo,
-      vendorStrategy: newInfo.options.VENDOR_STRAT,
-    });
+    newInfo.vendorStrategy = newInfo.options.VENDOR_STRAT;
   }
 
   // Update the directory information for the project if the flag is provided
   if (newInfo.options.VENDOR_DIR) {
+    const relativeVendorDir = path.relative(info.root, info.options.VENDOR_DIR);
     // Validate vendoring path
-    if (path.isAbsolute(newInfo.options.VENDOR_DIR)) {
+    if (relativeVendorDir.startsWith('..')) {
       throw new ParameterError(
-        '`--directory` must be project-relative as it will be mounted to the docker container.'
+        `\`--directory=${info.options.VENDOR_DIR}\` is outside the project directory.`,
+        info.options.CURRENT_ACTION.name
       );
     }
 
-    newInfo = setProjectInfoToSave({
-      ...newInfo,
-      vendorDirectory: newInfo.options.VENDOR_DIR,
-    });
+    // Immeditately convert it to a posix and relative path
+    newInfo.vendorDirectory = toPosixPath(relativeVendorDir);
   }
 
   if (newInfo.haveProjectConfig) {
@@ -145,57 +144,63 @@ async function init(libdragonInfo) {
       );
     }
     // TODO: we may make sure git and submodule is initialized here
-    await install(newInfo);
-    return;
+    return await install(newInfo);
   }
 
-  newInfo.imageName =
-    (await updateImage(newInfo, newInfo.imageName)) || newInfo.imageName;
+  await updateImage(newInfo, newInfo.imageName);
+
   // Download image and start it
-  const containerReadyPromise = start(newInfo, true).then((newId) => ({
-    ...newInfo,
-    containerId: newId,
-  }));
+  newInfo.containerId = await start(newInfo);
+
+  // We have created a new container, save the new info ASAP
+  await initGitAndCacheContainerId(newInfo);
 
-  let vendorAndGitReadyPromise = containerReadyPromise;
   if (newInfo.vendorStrategy !== 'manual') {
-    const vendorTarget = path.relative(newInfo.root, newInfo.vendorDirectory);
-    const [vendorTargetExists] = await Promise.all([
-      fs.stat(vendorTarget).catch((e) => {
-        if (e.code !== 'ENOENT') throw e;
-        return false;
-      }),
-      containerReadyPromise,
-    ]);
+    const vendorTarget = path.relative(
+      newInfo.root,
+      toNativePath(newInfo.vendorDirectory)
+    );
+    const vendorTargetExists = await fs.stat(vendorTarget).catch((e) => {
+      if (e.code !== 'ENOENT') throw e;
+      return false;
+    });
 
     if (vendorTargetExists) {
       throw new ValidationError(
         `${path.resolve(
-          newInfo.root,
-          newInfo.vendorDirectory
+          vendorTarget
         )} already exists. That is the libdragon vendoring target, please remove and retry.`
       );
     }
 
-    vendorAndGitReadyPromise = containerReadyPromise.then(autoVendor);
+    newInfo = await autoVendor(newInfo);
   }
 
   log(`Preparing project files...`);
   const skeletonFolder = path.join(__dirname, '../../skeleton');
 
   await Promise.all([
-    // We have created a new container, save the new info
-    vendorAndGitReadyPromise.then(tryCacheContainerId),
-    vendorAndGitReadyPromise.then(installDependencies),
+    installDependencies(newInfo),
     // node copy functions does not work with pkg
     copyDirContents(skeletonFolder, newInfo.root),
   ]);
 
   log(chalk.green(`libdragon ready at \`${newInfo.root}\`.`));
+  return newInfo;
 }
 
 module.exports = {
   name: 'init',
   fn: init,
-  showStatus: true,
+  mustHaveProject: false,
+  usage: {
+    name: 'init',
+    summary: 'Create a libdragon project in the current directory.',
+    description: `Creates a libdragon project in the current directory. Every libdragon project will have its own docker container instance. If you are in a git repository or an NPM project, libdragon will be initialized at their root also marking there with a \`.libdragon\` folder. Do not remove the \`.libdragon\` folder and commit its contents if you are using source control, as it keeps persistent libdragon project information.
+
+    By default, a git repository and a submodule at \`./libdragon\` will be created to automatically update the vendored libdragon files on subsequent \`update\`s. If you intend to opt-out from this feature, see the \`--strategy manual\` flag to provide your self-managed libdragon copy. The default behaviour is intended for users who primarily want to consume libdragon as is.
+
+    If this is the first time you are creating a libdragon project at that location, this action will also create skeleton project files to kickstart things with the given image, if provided. For subsequent runs, it will act like \`start\` thus can be used to revive an existing project without modifying it.`,
+    group: ['docker', 'vendoring'],
+  },
 };

package/modules/actions/install.js

@@ -1,6 +1,6 @@
-const chalk = require('chalk');
+const chalk = require('chalk').stderr;
 
-const { installDependencies, mustHaveProject } = require('./utils');
+const { installDependencies } = require('./utils');
 const { start } = require('./start');
 const { updateAndStart } = require('./update-and-start');
 const { log } = require('../helpers');
@@ -17,7 +17,6 @@ const { log } = require('../helpers');
  * we still keep that logic but with a deprecation warning.
  */
 const install = async (libdragonInfo, skipUpdate) => {
-  await mustHaveProject(libdragonInfo);
   let updatedInfo = libdragonInfo;
   const imageName = libdragonInfo.options.DOCKER_IMAGE;
   // If an image is provided, attempt to install
@@ -39,10 +38,17 @@ const install = async (libdragonInfo, skipUpdate) => {
   // Re-install vendors on new image
   // TODO: skip this if unnecessary
   await installDependencies(updatedInfo);
+  return updatedInfo;
 };
 
 module.exports = {
   name: 'install',
   fn: install,
-  showStatus: true,
+  usage: {
+    name: 'install',
+    summary: 'Vendor libdragon as is.',
+    description: `Attempts to build and install everything libdragon related into the container. This includes all the tools and third parties used by libdragon except for the toolchain. If you have made changes to libdragon, you can execute this action to build everything based on your changes. Requires you to have an intact vendoring target (also see the \`--directory\` flag). If you are not working on libdragon itself, you can just use the \`update\` action instead.
+
+    Must be run in an initialized libdragon project. This can be useful to recover from a half-baked container.`,
+  },
 };

package/modules/actions/make.js

@@ -0,0 +1,24 @@
+const { fn: exec } = require('./exec');
+
+const make = async (info) => {
+  return await exec({
+    ...info,
+    options: {
+      ...info.options,
+      EXTRA_PARAMS: ['make', ...info.options.EXTRA_PARAMS],
+    },
+  });
+};
+
+module.exports = {
+  name: 'make',
+  fn: make,
+  forwardsRestParams: true,
+  usage: {
+    name: 'make [params]',
+    summary: 'Run the libdragon build system in the current directory.',
+    description: `Runs the libdragon build system in the current directory. It will mirror your current working directory to the container.
+
+    Must be run in an initialized libdragon project. This action is a shortcut to the \`exec\` action under the hood.`,
+  },
+};

package/modules/actions/npm-utils.js

@@ -0,0 +1,122 @@
+const path = require('path');
+const fsClassic = require('fs');
+
+const _ = require('lodash');
+
+const { dockerHostUserParams } = require('./docker-utils');
+
+const { CONTAINER_TARGET_PATH } = require('../constants');
+const {
+  fileExists,
+  toPosixPath,
+  spawnProcess,
+  dockerExec,
+  ValidationError,
+} = require('../helpers');
+
+async function findNPMRoot() {
+  try {
+    const root = path.resolve((await runNPM(['root'])).trim(), '..');
+    // Only report if package.json really exists. npm fallbacks to cwd
+    if (await fileExists(path.join(root, 'package.json'))) {
+      return root;
+    }
+  } catch {
+    // User does not have and does not care about NPM if it didn't work
+    return undefined;
+  }
+}
+
+// Install other NPM dependencies if this is an NPM project
+const installNPMDependencies = async (libdragonInfo) => {
+  const npmRoot = await findNPMRoot();
+  if (npmRoot) {
+    const packageJsonPath = path.join(npmRoot, 'package.json');
+
+    const { dependencies, devDependencies } = require(packageJsonPath);
+
+    const deps = await Promise.all(
+      Object.keys({
+        ...dependencies,
+        ...devDependencies,
+      })
+        .filter((dep) => dep !== 'libdragon')
+        .map(async (dep) => {
+          const npmPath = await runNPM(['ls', dep, '--parseable=true']);
+          return {
+            name: dep,
+            paths: _.uniq(npmPath.split('\n').filter((f) => f)),
+          };
+        })
+    );
+
+    await Promise.all(
+      deps.map(({ name, paths }) => {
+        return new Promise((resolve, reject) => {
+          fsClassic.access(
+            path.join(paths[0], 'Makefile'),
+            fsClassic.F_OK,
+            async (e) => {
+              if (e) {
+                // File does not exist - skip
+                resolve();
+                return;
+              }
+
+              if (paths.length > 1) {
+                reject(
+                  new ValidationError(
+                    `Using same dependency with different versions is not supported! ${name}`
+                  )
+                );
+                return;
+              }
+
+              try {
+                const relativePath = toPosixPath(
+                  path.relative(libdragonInfo.root, paths[0])
+                );
+                const containerPath = path.posix.join(
+                  CONTAINER_TARGET_PATH,
+                  relativePath
+                );
+                const makePath = path.posix.join(containerPath, 'Makefile');
+
+                await dockerExec(
+                  libdragonInfo,
+                  [...dockerHostUserParams(libdragonInfo)],
+                  [
+                    '/bin/bash',
+                    '-c',
+                    '[ -f ' +
+                      makePath +
+                      ' ] && make -C ' +
+                      containerPath +
+                      ' && make -C ' +
+                      containerPath +
+                      ' install',
+                  ]
+                );
+
+                resolve();
+              } catch (e) {
+                reject(e);
+              }
+            }
+          );
+        });
+      })
+    );
+  }
+};
+
+function runNPM(params) {
+  return spawnProcess(
+    /^win/.test(process.platform) ? 'npm.cmd' : 'npm',
+    params
+  );
+}
+module.exports = {
+  installNPMDependencies,
+  findNPMRoot,
+};

package/modules/actions/start.js

@@ -1,14 +1,12 @@
-const chalk = require('chalk');
+const chalk = require('chalk').stderr;
 
 const { CONTAINER_TARGET_PATH } = require('../constants');
-const { spawnProcess, log, dockerExec } = require('../helpers');
-const { setProjectInfoToSave } = require('../project-info');
+const { spawnProcess, log, print, dockerExec } = require('../helpers');
 
 const {
   checkContainerAndClean,
   checkContainerRunning,
   destroyContainer,
-  mustHaveProject,
 } = require('./utils');
 
 /**
@@ -18,7 +16,7 @@ const initContainer = async (libdragonInfo) => {
   let newId;
   try {
     // Create a new container
-    libdragonInfo.showStatus && log('Creating new container...');
+    log('Creating new container...');
     newId = (
       await spawnProcess('docker', [
         'run',
@@ -71,18 +69,12 @@ const initContainer = async (libdragonInfo) => {
     '{{.Name}}',
   ]);
 
-  libdragonInfo.showStatus &&
-    log(
-      chalk.green(`Successfully initialized docker container: ${name.trim()}`)
-    );
+  log(chalk.green(`Successfully initialized docker container: ${name.trim()}`));
 
-  // Schedule an update to write image name
-  setProjectInfoToSave(libdragonInfo);
   return newId;
 };
 
-const start = async (libdragonInfo, skipProjectCheck) => {
-  !skipProjectCheck && (await mustHaveProject(libdragonInfo));
+const start = async (libdragonInfo) => {
   const running =
     libdragonInfo.containerId &&
     (await checkContainerRunning(libdragonInfo.containerId));
@@ -108,7 +100,17 @@ const start = async (libdragonInfo, skipProjectCheck) => {
 
 module.exports = {
   name: 'start',
-  fn: async (libdragonInfo) => log(await start(libdragonInfo)),
+  fn: async (libdragonInfo) => {
+    const containerId = await start(libdragonInfo);
+    print(containerId);
+    return { ...libdragonInfo, containerId };
+  },
   start,
-  showStatus: false, // This will only print out the id
+  usage: {
+    name: 'start',
+    summary: 'Start the container for current project.',
+    description: `Start the container assigned to the current libdragon project. Will first attempt to start an existing container if found, followed by a new container run and installation similar to the \`install\` action. Will always print out the container id to stdout on success except when verbose is set.
+
+      Must be run in an initialized libdragon project.`,
+  },
 };

package/modules/actions/stop.js

@@ -1,9 +1,8 @@
 const { spawnProcess } = require('../helpers');
 
-const { checkContainerRunning, mustHaveProject } = require('./utils');
+const { checkContainerRunning } = require('./utils');
 
 const stop = async (libdragonInfo) => {
-  await mustHaveProject(libdragonInfo);
   const running =
     libdragonInfo.containerId &&
     (await checkContainerRunning(libdragonInfo.containerId));
@@ -12,10 +11,17 @@ const stop = async (libdragonInfo) => {
   }
 
   await spawnProcess('docker', ['container', 'stop', running]);
+  return libdragonInfo;
 };
 
 module.exports = {
   name: 'stop',
   fn: stop,
-  showStatus: false, // This will only print out the id
+  usage: {
+    name: 'stop',
+    summary: 'Stop the container for current project.',
+    description: `Stop the container assigned to the current libdragon project.
+
+      Must be run in an initialized libdragon project.`,
+  },
 };