libdragon 10.4.1 → 10.4.2

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Change Log
 
+## [10.4.2] - 2022-04-03
+
+### Fixed
+
+- Make sure actions depending on an `init` fail in a non-project directory to
+keep the project state consistent. This fixes #51.
+- `update` action now tries to update the toolchain image as well. Previously
+this was not the case contrary to what someone would expect. Considering it won't
+change the behaviour for non-latest images and the toolchain did not have any
+breaking changes for a long time, this is not considered a breaking change either.
+- `start` action was printing stuff other than the container id. It doesn't
+anymore.
+- Stop unnecessarily printing container id and a few messages related to updates.
+- Fix a potential race condition that might cause unexpected failures.
+- Correct some errors' exit codes.
+### Added
+
+- A new exit code (`4`) to represent unexpected conditions.
+
+### Changed
+
+- Deprecated providing the image flag for `install` action by displaying a
+warning and removing it from documentation, without changing behaviour even
+though it is higly unlikely this feature was ever used. It mainly exists for
+historical reasons and it wil be removed in next major release.
+- Update documentation to warn against changing strategy is a one way operation.
+- Update documentation to reflect `update` action changes.
+- Minor refactors.
+- Update submodule for local environment.
+
 ## [10.4.1] - 2022-03-23
 
 ### Fixed

package/index.js

@@ -8,9 +8,14 @@ const {
   STATUS_OK,
   STATUS_BAD_PARAM,
   STATUS_ERROR,
+  STATUS_VALIDATION_ERROR,
 } = require('./modules/constants');
 const { globals } = require('./modules/globals');
-const { CommandError, ParameterError } = require('./modules/helpers');
+const {
+  CommandError,
+  ParameterError,
+  ValidationError,
+} = require('./modules/helpers');
 const { readProjectInfo, writeProjectInfo } = require('./modules/project-info');
 
 let options = {},
@@ -127,6 +132,12 @@ readProjectInfo()
       printUsage(undefined, [currentAction.name]);
       process.exit(STATUS_BAD_PARAM);
     }
+
+    if (e instanceof ValidationError) {
+      console.error(chalk.red(e.message));
+      process.exit(STATUS_VALIDATION_ERROR);
+    }
+
     const userTargetedError = e instanceof CommandError && e.userCommand;
 
     // Show additional information to user if verbose or we did a mistake

package/modules/actions/exec.js

@@ -3,8 +3,12 @@ const path = require('path');
 const { CONTAINER_TARGET_PATH } = require('../constants');
 const { log, dockerExec, toPosixPath } = require('../helpers');
 
-const { fn: start } = require('./start');
-const { dockerHostUserParams, installDependencies } = require('./utils');
+const { start } = require('./start');
+const {
+  dockerHostUserParams,
+  installDependencies,
+  mustHaveProject,
+} = require('./utils');
 
 function dockerRelativeWorkdir(libdragonInfo) {
   return (
@@ -19,6 +23,8 @@ function dockerRelativeWorkdirParams(libdragonInfo) {
 }
 
 const exec = async (libdragonInfo, commandAndParams) => {
+  await mustHaveProject(libdragonInfo);
+
   log(
     `Running ${commandAndParams[0]} at ${dockerRelativeWorkdir(
       libdragonInfo

package/modules/actions/help.js

@@ -39,15 +39,17 @@ const printUsage = (_, actionArr) => {
 
         To disable auto-vendoring, init with \`manual\`. With \`manual\`, libdragon files are expected at the location provided by \`--directory\` flag and the user is responsible for vendoring and updating them. This will allow using any other manual vendoring method.
 
-        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.
+        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.
 
-        It is also possible to opt-out later on by running \`init\` with \`--strategy manual\`, though you will be responsible for managing the existing submodule/subtree.\n`,
+        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',
       typeLabel: '<strategy>',
       group: 'vendoring',
     },
   ];
 
+  // TODO: move these to respective actions
+
   const actions = {
     help: {
       name: 'help [action]',
@@ -68,7 +70,7 @@ const printUsage = (_, actionArr) => {
       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.
 
-      This action is a shortcut to the \`exec\` action under the hood.`,
+      Must be run in an initialized libdragon project. This action is a shortcut to the \`exec\` action under the hood.`,
     },
     exec: {
       name: 'exec <command>',
@@ -77,33 +79,37 @@ const printUsage = (_, actionArr) => {
 
       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.`,
+      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.',
+      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.',
+      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.',
-      group: ['docker'],
       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.
 
-        This can be useful to recover from a half-baked container.`,
+      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:
-        'If you are using auto-vendoring (see `--strategy`), this action will update the submodule/subtree from the remote branch (`trunk`) with a merge/squash strategy and then perform a `libdragon install`. This is the same as an `install` when the vendoring strategy is `manual`. You can use the `install` action to only update all libdragon related artifacts in the container.',
+      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'],
     },
   };

package/modules/actions/index.js

@@ -1,19 +1,5 @@
-const { spawnProcess } = require('../helpers');
-const { checkContainerRunning } = require('./utils');
-
 const { fn: exec } = require('./exec');
 
-const stop = async (libdragonInfo) => {
-  const running =
-    libdragonInfo.containerId &&
-    (await checkContainerRunning(libdragonInfo.containerId));
-  if (!running) {
-    return;
-  }
-
-  await spawnProcess('docker', ['container', 'stop', running]);
-};
-
 const make = async (libdragonInfo, params) => {
   await exec(libdragonInfo, ['make', ...params]);
 };
@@ -21,11 +7,7 @@ const make = async (libdragonInfo, params) => {
 // TODO: separate into files
 module.exports = {
   start: require('./start'),
-  stop: {
-    name: 'stop',
-    fn: stop,
-    showStatus: false, // This will only print out the id
-  },
+  stop: require('./stop'),
   init: require('./init'),
 
   exec: require('./exec'),

package/modules/actions/init.js

@@ -4,7 +4,7 @@ const path = require('path');
 const chalk = require('chalk');
 
 const { fn: install } = require('./install');
-const { fn: start } = require('./start');
+const { start } = require('./start');
 const {
   installDependencies,
   tryCacheContainerId,
@@ -23,6 +23,7 @@ const {
   copyDirContents,
   CommandError,
   ParameterError,
+  ValidationError,
 } = require('../helpers');
 const { setProjectInfoToSave } = require('../project-info');
 
@@ -81,23 +82,29 @@ const autoVendor = async (libdragonInfo) => {
 async function init(libdragonInfo) {
   log(`Initializing a libdragon project at ${libdragonInfo.root}`);
 
-  // TODO: use exists instead & check if it is a directory
-  const files = await fs.readdir(libdragonInfo.root);
+  let newInfo = libdragonInfo;
 
-  const manifestFile = files.find(
-    (name) => name === LIBDRAGON_PROJECT_MANIFEST
-  );
+  // Validate manifest
+  const manifestPath = path.join(newInfo.root, LIBDRAGON_PROJECT_MANIFEST);
+  const manifestStats = await fs.stat(manifestPath).catch((e) => {
+    if (e.code !== 'ENOENT') throw e;
+    return false;
+  });
 
-  let newInfo = libdragonInfo;
+  if (manifestStats && !manifestStats.isDirectory()) {
+    throw new ValidationError(
+      'There is already a `.libdragon` file and it is not a directory.'
+    );
+  }
 
   // Validate vendoring strategy. Do not allow a switch after successful initialization
   if (
-    manifestFile &&
+    newInfo.haveProjectConfig &&
     newInfo.options.VENDOR_STRAT &&
     newInfo.options.VENDOR_STRAT !== 'manual' &&
     newInfo.vendorStrategy !== newInfo.options.VENDOR_STRAT
   ) {
-    throw new Error(
+    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.`
     );
   }
@@ -125,11 +132,11 @@ async function init(libdragonInfo) {
     });
   }
 
-  if (manifestFile) {
+  if (newInfo.haveProjectConfig) {
     log(
       `${path.join(
         newInfo.root,
-        manifestFile
+        LIBDRAGON_PROJECT_MANIFEST
       )} exists. This is already a libdragon project, starting it...`
     );
     if (newInfo.options.DOCKER_IMAGE) {
@@ -137,6 +144,7 @@ async function init(libdragonInfo) {
         `Not changing docker image. Use the install action if you want to override the image.`
       );
     }
+    // TODO: we may make sure git and submodule is initialized here
     await install(newInfo);
     return;
   }
@@ -144,24 +152,27 @@ async function init(libdragonInfo) {
   newInfo.imageName =
     (await updateImage(newInfo, newInfo.imageName)) || newInfo.imageName;
   // Download image and start it
-  const containerReadyPromise = start(newInfo).then((newId) => ({
+  const containerReadyPromise = start(newInfo, true).then((newId) => ({
     ...newInfo,
     containerId: newId,
   }));
 
   let vendorAndGitReadyPromise = containerReadyPromise;
   if (newInfo.vendorStrategy !== 'manual') {
-    const libdragonFile = files.find((name) =>
-      name.match(
-        new RegExp(`^${path.relative(newInfo.root, newInfo.vendorDirectory)}$`)
-      )
-    );
+    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,
+    ]);
 
-    if (libdragonFile) {
-      throw new Error(
-        `${path.join(
+    if (vendorTargetExists) {
+      throw new ValidationError(
+        `${path.resolve(
           newInfo.root,
-          libdragonFile
+          newInfo.vendorDirectory
         )} already exists. That is the libdragon vendoring target, please remove and retry.`
       );
     }

package/modules/actions/install.js

@@ -1,48 +1,44 @@
+const chalk = require('chalk');
+
+const { installDependencies, mustHaveProject } = require('./utils');
+const { start } = require('./start');
+const { updateAndStart } = require('./update-and-start');
 const { log } = require('../helpers');
-const {
-  destroyContainer,
-  installDependencies,
-  updateImage,
-} = require('./utils');
-const { fn: start } = require('./start');
 
 /**
  * Updates the image if flag is provided and install vendors onto the container.
  * We should probably remove the image installation responsibility from this
- * action but it might be a breaking change. Maybe we can keep it backward
- * compatible with additional flags.
+ * action but it might be a breaking change.
  * @param libdragonInfo
+ * @param skipUpdate This is added to skip the update when calling this from
+ * the update action as it already does an update itself. install doing an image
+ * update is pretty much a useless operation, but let's keep it in case someone
+ * depends on it. It used to only update the image if the flag is provided and
+ * we still keep that logic but with a deprecation warning.
  */
-const install = async (libdragonInfo) => {
-  let containerId;
-  const oldImageName = libdragonInfo.imageName;
+const install = async (libdragonInfo, skipUpdate) => {
+  await mustHaveProject(libdragonInfo);
+  let updatedInfo = libdragonInfo;
   const imageName = libdragonInfo.options.DOCKER_IMAGE;
-  // If an image is provided, always attempt to install it
-  // See https://github.com/anacierdem/libdragon-docker/issues/47
-  if (imageName) {
-    log(`Changing image from \`${oldImageName}\` to \`${imageName}\``);
-
-    // Download the new image and if it is different, re-create the container
-    if (await updateImage(libdragonInfo, imageName)) {
-      await destroyContainer(libdragonInfo);
-    }
-
-    containerId = await start({
-      ...libdragonInfo,
-      imageName,
-    });
+  // If an image is provided, attempt to install
+  if (imageName && skipUpdate !== true) {
+    log(
+      chalk.yellow(
+        'Using `install` action to update the docker image is deprecated. Use the `update` action instead.'
+      )
+    );
+    updatedInfo = await updateAndStart(libdragonInfo);
   } else {
     // Make sure existing one is running
-    containerId = await start(libdragonInfo);
+    updatedInfo = {
+      ...updatedInfo,
+      containerId: await start(libdragonInfo),
+    };
   }
 
   // Re-install vendors on new image
   // TODO: skip this if unnecessary
-  await installDependencies({
-    ...libdragonInfo,
-    imageName,
-    containerId,
-  });
+  await installDependencies(updatedInfo);
 };
 
 module.exports = {

package/modules/actions/start.js

@@ -8,6 +8,7 @@ const {
   checkContainerAndClean,
   checkContainerRunning,
   destroyContainer,
+  mustHaveProject,
 } = require('./utils');
 
 /**
@@ -80,14 +81,14 @@ const initContainer = async (libdragonInfo) => {
   return newId;
 };
 
-const start = async (libdragonInfo) => {
+const start = async (libdragonInfo, skipProjectCheck) => {
+  !skipProjectCheck && (await mustHaveProject(libdragonInfo));
   const running =
     libdragonInfo.containerId &&
     (await checkContainerRunning(libdragonInfo.containerId));
 
   if (running) {
     log(`Container ${running} already running.`, true);
-    log(libdragonInfo.containerId);
     return running;
   }
 
@@ -96,19 +97,18 @@ const start = async (libdragonInfo) => {
   if (!id) {
     log(`Container does not exist, re-initializing...`, true);
     id = await initContainer(libdragonInfo);
-    log(id);
     return id;
   }
 
   log(`Starting container: ${id}`, true);
   await spawnProcess('docker', ['container', 'start', id]);
 
-  log(id);
   return id;
 };
 
 module.exports = {
   name: 'start',
-  fn: start,
+  fn: async (libdragonInfo) => log(await start(libdragonInfo)),
+  start,
   showStatus: false, // This will only print out the id
 };

package/modules/actions/stop.js

@@ -0,0 +1,21 @@
+const { spawnProcess } = require('../helpers');
+
+const { checkContainerRunning, mustHaveProject } = require('./utils');
+
+const stop = async (libdragonInfo) => {
+  await mustHaveProject(libdragonInfo);
+  const running =
+    libdragonInfo.containerId &&
+    (await checkContainerRunning(libdragonInfo.containerId));
+  if (!running) {
+    return;
+  }
+
+  await spawnProcess('docker', ['container', 'stop', running]);
+};
+
+module.exports = {
+  name: 'stop',
+  fn: stop,
+  showStatus: false, // This will only print out the id
+};

package/modules/actions/update-and-start.js

@@ -0,0 +1,33 @@
+const { log } = require('../helpers');
+const { updateImage, destroyContainer } = require('./utils');
+const { start } = require('./start');
+
+async function updateAndStart(libdragonInfo) {
+  const oldImageName = libdragonInfo.imageName;
+  const imageName = libdragonInfo.options.DOCKER_IMAGE ?? oldImageName;
+  // If an image is provided, always attempt to install it
+  // See https://github.com/anacierdem/libdragon-docker/issues/47
+  if (oldImageName !== imageName) {
+    log(`Updating image from \`${oldImageName}\` to \`${imageName}\``);
+  } else {
+    log(`Updating image \`${oldImageName}\``);
+  }
+
+  // Download the new image and if it is different, re-create the container
+  if (await updateImage(libdragonInfo, imageName)) {
+    await destroyContainer(libdragonInfo);
+  }
+
+  return {
+    ...libdragonInfo,
+    imageName,
+    containerId: await start({
+      ...libdragonInfo,
+      imageName,
+    }),
+  };
+}
+
+module.exports = {
+  updateAndStart,
+};

package/modules/actions/update.js

@@ -2,17 +2,13 @@ const path = require('path');
 
 const { log } = require('../helpers');
 const { LIBDRAGON_GIT, LIBDRAGON_BRANCH } = require('../constants');
-const { runGitMaybeHost } = require('./utils');
-const { fn: start } = require('./start');
+const { runGitMaybeHost, mustHaveProject } = require('./utils');
 const { fn: install } = require('./install');
+const { updateAndStart } = require('./update-and-start');
 
 const update = async (libdragonInfo) => {
-  const containerId = await start(libdragonInfo);
-
-  const newInfo = {
-    ...libdragonInfo,
-    containerId,
-  };
+  await mustHaveProject(libdragonInfo);
+  const newInfo = await updateAndStart(libdragonInfo);
 
   if (newInfo.vendorStrategy !== 'manual') {
     log(`Updating ${newInfo.vendorStrategy}...`);
@@ -38,7 +34,9 @@ const update = async (libdragonInfo) => {
     ]);
   }
 
-  await install(newInfo);
+  // The second parameter forces it to skip the image update step as we already
+  // do that above.
+  await install(newInfo, true);
 };
 
 module.exports = {

package/modules/actions/utils.js

@@ -18,6 +18,8 @@ const {
   dirExists,
   assert,
   CommandError,
+  ValidationError,
+  ParameterError,
 } = require('../helpers');
 
 function dockerHostUserParams(libdragonInfo) {
@@ -45,7 +47,7 @@ const installDependencies = async (libdragonInfo) => {
     'build.sh'
   );
   if (!(await fileExists(buildScriptPath))) {
-    throw new Error(
+    throw new ValidationError(
       `build.sh not found. Make sure you have a vendored libdragon copy at ${libdragonInfo.vendorDirectory}`
     );
   }
@@ -103,7 +105,7 @@ const installDependencies = async (libdragonInfo) => {
 
               if (paths.length > 1) {
                 reject(
-                  new Error(
+                  new ValidationError(
                     `Using same dependency with different versions is not supported! ${name}`
                   )
                 );
@@ -173,7 +175,7 @@ const updateImage = async (libdragonInfo, newImageName) => {
       'docker',
       ['images', '-q', '--no-trunc', newImageName],
       false,
-      libdragonInfo.showStatus
+      false
     );
 
   // Attempt to compare digests if the new image name is the same
@@ -186,14 +188,15 @@ const updateImage = async (libdragonInfo, newImageName) => {
     const newDigest = await getDigest();
 
     if (existingDigest === newDigest) {
-      libdragonInfo.showStatus && log(`Image is the same: ${newImageName}`);
+      libdragonInfo.showStatus &&
+        log(`Image is the same: ${newImageName}`, true);
       return false;
     }
   } else {
     await download();
   }
 
-  libdragonInfo.showStatus && log(`Image is different: ${newImageName}`);
+  libdragonInfo.showStatus && log(`Image is different: ${newImageName}`, true);
   return newImageName;
 };
 
@@ -301,6 +304,15 @@ async function tryCacheContainerId(libdragonInfo) {
   }
 }
 
+// Throws if the project was not initialized for the current libdragonInfo
+async function mustHaveProject(libdragonInfo) {
+  if (!libdragonInfo.haveProjectConfig) {
+    throw new ParameterError(
+      'This is not a libdragon project. Initialize with `libdragon init` first.'
+    );
+  }
+}
+
 module.exports = {
   installDependencies,
   updateImage,
@@ -311,4 +323,5 @@ module.exports = {
   tryCacheContainerId,
   runGitMaybeHost,
   findNPMRoot,
+  mustHaveProject,
 };

package/modules/constants.js

@@ -13,6 +13,7 @@ module.exports = {
   STATUS_OK: 0,
   STATUS_ERROR: 1,
   STATUS_BAD_PARAM: 2,
+  STATUS_VALIDATION_ERROR: 4,
 
   IMAGE_FILE: 'docker-image', // deprecated
 };

package/modules/helpers.js

@@ -6,6 +6,7 @@ const { spawn } = require('child_process');
 
 const { globals } = require('./globals');
 
+// An error caused by a command explicitly run by the user
 class CommandError extends Error {
   constructor(message, { code, out, userCommand }) {
     super(message);
@@ -15,12 +16,20 @@ class CommandError extends Error {
   }
 }
 
+// The user provided an unexpected input
 class ParameterError extends Error {
   constructor(message) {
     super(message);
   }
 }
 
+// Something was not as expected to continue the operation
+class ValidationError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
 async function fileExists(path) {
   return fs
     .stat(path)
@@ -210,6 +219,7 @@ function assert(condition, error) {
   }
 }
 
+// TODO: we can handle showStatus here
 function log(text, verboseOnly = false) {
   if (!verboseOnly) {
     // eslint-disable-next-line no-console
@@ -234,4 +244,5 @@ module.exports = {
   copyDirContents,
   CommandError,
   ParameterError,
+  ValidationError,
 };

package/modules/project-info.js

@@ -20,13 +20,7 @@ const {
   CONTAINER_TARGET_PATH,
 } = require('./constants');
 
-const {
-  fileExists,
-  log,
-  spawnProcess,
-  dirExists,
-  toPosixPath,
-} = require('./helpers');
+const { fileExists, log, spawnProcess, toPosixPath } = require('./helpers');
 
 async function findContainerId(libdragonInfo) {
   const idFile = path.join(libdragonInfo.root, '.git', CACHED_CONTAINER_FILE);
@@ -67,8 +61,8 @@ async function findContainerId(libdragonInfo) {
 }
 
 async function findLibdragonRoot(start = '.') {
-  const manifest = path.join(start, LIBDRAGON_PROJECT_MANIFEST);
-  if (await dirExists(manifest)) {
+  const manifest = path.join(start, LIBDRAGON_PROJECT_MANIFEST, CONFIG_FILE);
+  if (await fileExists(manifest)) {
     return path.resolve(start);
   } else {
     const parent = path.resolve(start, '..');
@@ -89,42 +83,16 @@ async function findGitRoot() {
   }
 }
 
-/**
- * Creates the manifest folder if it does not exist. Will return true if
- * created, false otherwise.
- */
-async function createManifestIfNotExist(libdragonInfo) {
-  const manifestPath = path.join(
-    libdragonInfo.root,
-    LIBDRAGON_PROJECT_MANIFEST
-  );
-  const manifestExists = await fs.stat(manifestPath).catch((e) => {
-    if (e.code !== 'ENOENT') throw e;
-    return false;
-  });
-
-  if (manifestExists && !manifestExists.isDirectory()) {
-    throw new Error(
-      'There is already a `.libdragon` file and it is not a directory.'
-    );
-  }
-
-  if (!manifestExists) {
-    log(
-      `Creating libdragon project configuration at \`${libdragonInfo.root}\`.`
-    );
-    await fs.mkdir(manifestPath);
-  }
-}
-
 async function readProjectInfo() {
+  const projectRoot = await findLibdragonRoot();
+
   let info = {
-    root:
-      (await findLibdragonRoot()) ??
-      (await findNPMRoot()) ??
-      (await findGitRoot()),
+    root: projectRoot ?? (await findNPMRoot()) ?? (await findGitRoot()),
     userInfo: os.userInfo(),
 
+    // Use this to discriminate if there is a project when the command is run
+    haveProjectConfig: !!projectRoot,
+
     // Set the defaults immediately, these should be present at all times even
     // if we are migrating from the old config because they did not exist before
     imageName: DOCKER_HUB_IMAGE,
@@ -200,27 +168,41 @@ let projectInfoToWrite = {};
  * Updates project info to be written. The provided keys are overwritten without
  * changing the existing values. When the process exists successfully these will
  * get written to the configuration file. Echoes back the given info.
- * @param libdragonInfo
+ * @param info This is only the base info without action properties like showStatus
+ * fn and command line options
  */
-function setProjectInfoToSave(libdragonInfo) {
-  projectInfoToWrite = { ...projectInfoToWrite, ...libdragonInfo };
-  return libdragonInfo;
+function setProjectInfoToSave(info) {
+  projectInfoToWrite = { ...projectInfoToWrite, ...info };
+  return info;
 }
 
-async function writeProjectInfo(libdragonInfo = projectInfoToWrite) {
-  await createManifestIfNotExist(libdragonInfo);
-  const manifestPath = path.join(
-    libdragonInfo.root,
-    LIBDRAGON_PROJECT_MANIFEST
-  );
+/**
+ * @param info This is only the base info without action properties like showStatus
+ * fn and command line options
+ */
+async function writeProjectInfo(info = projectInfoToWrite) {
+  // Do not log anything here as it may litter the output being always run on exit
+
+  const projectPath = path.join(info.root, LIBDRAGON_PROJECT_MANIFEST);
+
+  const pathExists = await fs.stat(projectPath).catch((e) => {
+    if (e.code !== 'ENOENT') throw e;
+    return false;
+  });
+
+  if (!pathExists) {
+    log(`Creating libdragon project configuration at \`${info.root}\`.`, true);
+    await fs.mkdir(projectPath);
+  }
+
   await fs.writeFile(
-    path.join(manifestPath, CONFIG_FILE),
+    path.join(projectPath, CONFIG_FILE),
     JSON.stringify(
       {
-        imageName: libdragonInfo.imageName,
+        imageName: info.imageName,
         // Always save this in posix format
-        vendorDirectory: toPosixPath(libdragonInfo.vendorDirectory),
-        vendorStrategy: libdragonInfo.vendorStrategy,
+        vendorDirectory: toPosixPath(info.vendorDirectory),
+        vendorStrategy: info.vendorStrategy,
       },
       null,
       '  '

package/package.json

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