@datacamp/learn-vm-scripts 0.0.1-rc.9 → 0.0.3-rc.0

package/README.md

@@ -21,14 +21,6 @@
    yarn install
    ```
 
-### Configuration
-
-This project uses environment variables to configure the `executablePath` and `userDataDir` for Puppeteer. The configuration is done using `.env` files.
-
-#### Updating .env.development
-
-The `.env.development` file should be updated with the values of your local Chrome installation:
-
 ## Usage
 
 This project contains a program that logs in to a cloud provider using Puppeteer.
@@ -42,7 +34,7 @@ yarn build
 To start the file watcher:
 
 ```sh
-yarn cli -- --inputFilePath <path-to-input-file> --outputFilePath <path-to-output-file>
+yarn cli -- --inputFilePath <path-to-input-file> --outputFilePath <path-to-output-file> --executablePath <path-to-chromium-executable> --userDataDir <path-to-user-data-dir>
 ```
 
 The program watches the input file for changes.
@@ -53,6 +45,5 @@ To log in to a cloud provider, write the following JSON object to the input file
 ```
 
 ❗️The input has to be written to a single line.
-Each line is parsed individually.
-
 When the login process is complete, the program writes a line to the output file.
+After this, the program exits.

package/dist/index.cjs

@@ -33,344 +33,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/dotenv/package.json
-var require_package = __commonJS({
-  "node_modules/dotenv/package.json"(exports2, module2) {
-    module2.exports = {
-      name: "dotenv",
-      version: "16.4.5",
-      description: "Loads environment variables from .env file",
-      main: "lib/main.js",
-      types: "lib/main.d.ts",
-      exports: {
-        ".": {
-          types: "./lib/main.d.ts",
-          require: "./lib/main.js",
-          default: "./lib/main.js"
-        },
-        "./config": "./config.js",
-        "./config.js": "./config.js",
-        "./lib/env-options": "./lib/env-options.js",
-        "./lib/env-options.js": "./lib/env-options.js",
-        "./lib/cli-options": "./lib/cli-options.js",
-        "./lib/cli-options.js": "./lib/cli-options.js",
-        "./package.json": "./package.json"
-      },
-      scripts: {
-        "dts-check": "tsc --project tests/types/tsconfig.json",
-        lint: "standard",
-        "lint-readme": "standard-markdown",
-        pretest: "npm run lint && npm run dts-check",
-        test: "tap tests/*.js --100 -Rspec",
-        "test:coverage": "tap --coverage-report=lcov",
-        prerelease: "npm test",
-        release: "standard-version"
-      },
-      repository: {
-        type: "git",
-        url: "git://github.com/motdotla/dotenv.git"
-      },
-      funding: "https://dotenvx.com",
-      keywords: [
-        "dotenv",
-        "env",
-        ".env",
-        "environment",
-        "variables",
-        "config",
-        "settings"
-      ],
-      readmeFilename: "README.md",
-      license: "BSD-2-Clause",
-      devDependencies: {
-        "@definitelytyped/dtslint": "^0.0.133",
-        "@types/node": "^18.11.3",
-        decache: "^4.6.1",
-        sinon: "^14.0.1",
-        standard: "^17.0.0",
-        "standard-markdown": "^7.1.0",
-        "standard-version": "^9.5.0",
-        tap: "^16.3.0",
-        tar: "^6.1.11",
-        typescript: "^4.8.4"
-      },
-      engines: {
-        node: ">=12"
-      },
-      browser: {
-        fs: false
-      }
-    };
-  }
-});
-
-// node_modules/dotenv/lib/main.js
-var require_main = __commonJS({
-  "node_modules/dotenv/lib/main.js"(exports2, module2) {
-    var fs7 = require("fs");
-    var path9 = require("path");
-    var os8 = require("os");
-    var crypto = require("crypto");
-    var packageJson = require_package();
-    var version = packageJson.version;
-    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
-    function parse(src) {
-      const obj = {};
-      let lines = src.toString();
-      lines = lines.replace(/\r\n?/mg, "\n");
-      let match;
-      while ((match = LINE.exec(lines)) != null) {
-        const key = match[1];
-        let value = match[2] || "";
-        value = value.trim();
-        const maybeQuote = value[0];
-        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-        if (maybeQuote === '"') {
-          value = value.replace(/\\n/g, "\n");
-          value = value.replace(/\\r/g, "\r");
-        }
-        obj[key] = value;
-      }
-      return obj;
-    }
-    function _parseVault(options) {
-      const vaultPath = _vaultPath(options);
-      const result = DotenvModule.configDotenv({ path: vaultPath });
-      if (!result.parsed) {
-        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
-        err.code = "MISSING_DATA";
-        throw err;
-      }
-      const keys = _dotenvKey(options).split(",");
-      const length = keys.length;
-      let decrypted;
-      for (let i = 0; i < length; i++) {
-        try {
-          const key = keys[i].trim();
-          const attrs = _instructions(result, key);
-          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
-          break;
-        } catch (error) {
-          if (i + 1 >= length) {
-            throw error;
-          }
-        }
-      }
-      return DotenvModule.parse(decrypted);
-    }
-    function _log(message) {
-      console.log(`[dotenv@${version}][INFO] ${message}`);
-    }
-    function _warn(message) {
-      console.log(`[dotenv@${version}][WARN] ${message}`);
-    }
-    function _debug(message) {
-      console.log(`[dotenv@${version}][DEBUG] ${message}`);
-    }
-    function _dotenvKey(options) {
-      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
-        return options.DOTENV_KEY;
-      }
-      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
-        return process.env.DOTENV_KEY;
-      }
-      return "";
-    }
-    function _instructions(result, dotenvKey) {
-      let uri;
-      try {
-        uri = new URL(dotenvKey);
-      } catch (error) {
-        if (error.code === "ERR_INVALID_URL") {
-          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        }
-        throw error;
-      }
-      const key = uri.password;
-      if (!key) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environment = uri.searchParams.get("environment");
-      if (!environment) {
-        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
-        err.code = "INVALID_DOTENV_KEY";
-        throw err;
-      }
-      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
-      const ciphertext = result.parsed[environmentKey];
-      if (!ciphertext) {
-        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
-        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
-        throw err;
-      }
-      return { ciphertext, key };
-    }
-    function _vaultPath(options) {
-      let possibleVaultPath = null;
-      if (options && options.path && options.path.length > 0) {
-        if (Array.isArray(options.path)) {
-          for (const filepath of options.path) {
-            if (fs7.existsSync(filepath)) {
-              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
-            }
-          }
-        } else {
-          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
-        }
-      } else {
-        possibleVaultPath = path9.resolve(process.cwd(), ".env.vault");
-      }
-      if (fs7.existsSync(possibleVaultPath)) {
-        return possibleVaultPath;
-      }
-      return null;
-    }
-    function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path9.join(os8.homedir(), envPath.slice(1)) : envPath;
-    }
-    function _configVault(options) {
-      _log("Loading env from encrypted .env.vault");
-      const parsed = DotenvModule._parseVault(options);
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      DotenvModule.populate(processEnv, parsed, options);
-      return { parsed };
-    }
-    function configDotenv(options) {
-      const dotenvPath = path9.resolve(process.cwd(), ".env");
-      let encoding = "utf8";
-      const debug5 = Boolean(options && options.debug);
-      if (options && options.encoding) {
-        encoding = options.encoding;
-      } else {
-        if (debug5) {
-          _debug("No encoding is specified. UTF-8 is used by default");
-        }
-      }
-      let optionPaths = [dotenvPath];
-      if (options && options.path) {
-        if (!Array.isArray(options.path)) {
-          optionPaths = [_resolveHome(options.path)];
-        } else {
-          optionPaths = [];
-          for (const filepath of options.path) {
-            optionPaths.push(_resolveHome(filepath));
-          }
-        }
-      }
-      let lastError;
-      const parsedAll = {};
-      for (const path10 of optionPaths) {
-        try {
-          const parsed = DotenvModule.parse(fs7.readFileSync(path10, { encoding }));
-          DotenvModule.populate(parsedAll, parsed, options);
-        } catch (e) {
-          if (debug5) {
-            _debug(`Failed to load ${path10} ${e.message}`);
-          }
-          lastError = e;
-        }
-      }
-      let processEnv = process.env;
-      if (options && options.processEnv != null) {
-        processEnv = options.processEnv;
-      }
-      DotenvModule.populate(processEnv, parsedAll, options);
-      if (lastError) {
-        return { parsed: parsedAll, error: lastError };
-      } else {
-        return { parsed: parsedAll };
-      }
-    }
-    function config3(options) {
-      if (_dotenvKey(options).length === 0) {
-        return DotenvModule.configDotenv(options);
-      }
-      const vaultPath = _vaultPath(options);
-      if (!vaultPath) {
-        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
-        return DotenvModule.configDotenv(options);
-      }
-      return DotenvModule._configVault(options);
-    }
-    function decrypt(encrypted, keyStr) {
-      const key = Buffer.from(keyStr.slice(-64), "hex");
-      let ciphertext = Buffer.from(encrypted, "base64");
-      const nonce = ciphertext.subarray(0, 12);
-      const authTag = ciphertext.subarray(-16);
-      ciphertext = ciphertext.subarray(12, -16);
-      try {
-        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
-        aesgcm.setAuthTag(authTag);
-        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
-      } catch (error) {
-        const isRange = error instanceof RangeError;
-        const invalidKeyLength = error.message === "Invalid key length";
-        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
-        if (isRange || invalidKeyLength) {
-          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
-          err.code = "INVALID_DOTENV_KEY";
-          throw err;
-        } else if (decryptionFailed) {
-          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
-          err.code = "DECRYPTION_FAILED";
-          throw err;
-        } else {
-          throw error;
-        }
-      }
-    }
-    function populate(processEnv, parsed, options = {}) {
-      const debug5 = Boolean(options && options.debug);
-      const override = Boolean(options && options.override);
-      if (typeof parsed !== "object") {
-        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
-        err.code = "OBJECT_REQUIRED";
-        throw err;
-      }
-      for (const key of Object.keys(parsed)) {
-        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
-          if (override === true) {
-            processEnv[key] = parsed[key];
-          }
-          if (debug5) {
-            if (override === true) {
-              _debug(`"${key}" is already defined and WAS overwritten`);
-            } else {
-              _debug(`"${key}" is already defined and was NOT overwritten`);
-            }
-          }
-        } else {
-          processEnv[key] = parsed[key];
-        }
-      }
-    }
-    var DotenvModule = {
-      configDotenv,
-      _configVault,
-      _parseVault,
-      config: config3,
-      decrypt,
-      parse,
-      populate
-    };
-    module2.exports.configDotenv = DotenvModule.configDotenv;
-    module2.exports._configVault = DotenvModule._configVault;
-    module2.exports._parseVault = DotenvModule._parseVault;
-    module2.exports.config = DotenvModule.config;
-    module2.exports.decrypt = DotenvModule.decrypt;
-    module2.exports.parse = DotenvModule.parse;
-    module2.exports.populate = DotenvModule.populate;
-    module2.exports = DotenvModule;
-  }
-});
-
 // node_modules/puppeteer-core/lib/esm/third_party/rxjs/rxjs.js
 function __extends(d, b) {
   if (typeof b !== "function" && b !== null)
@@ -1088,8 +750,8 @@ function of() {
   var scheduler = popScheduler(args);
   return from(args, scheduler);
 }
-function lastValueFrom(source2, config22) {
-  var hasConfig = typeof config22 === "object";
+function lastValueFrom(source2, config2) {
+  var hasConfig = typeof config2 === "object";
   return new Promise(function(resolve5, reject) {
     var _hasValue = false;
     var _value;
@@ -1103,7 +765,7 @@ function lastValueFrom(source2, config22) {
         if (_hasValue) {
           resolve5(_value);
         } else if (hasConfig) {
-          resolve5(config22.defaultValue);
+          resolve5(config2.defaultValue);
         } else {
           reject(new EmptyError());
         }
@@ -1111,8 +773,8 @@ function lastValueFrom(source2, config22) {
     });
   });
 }
-function firstValueFrom(source2, config22) {
-  var hasConfig = typeof config22 === "object";
+function firstValueFrom(source2, config2) {
+  var hasConfig = typeof config2 === "object";
   return new Promise(function(resolve5, reject) {
     var subscriber = new SafeSubscriber({
       next: function(value) {
@@ -1122,7 +784,7 @@ function firstValueFrom(source2, config22) {
       error: reject,
       complete: function() {
         if (hasConfig) {
-          resolve5(config22.defaultValue);
+          resolve5(config2.defaultValue);
         } else {
           reject(new EmptyError());
         }
@@ -1665,15 +1327,15 @@ function retry(configOrCount) {
   if (configOrCount === void 0) {
     configOrCount = Infinity;
   }
-  var config22;
+  var config2;
   if (configOrCount && typeof configOrCount === "object") {
-    config22 = configOrCount;
+    config2 = configOrCount;
   } else {
-    config22 = {
+    config2 = {
       count: configOrCount
     };
   }
-  var _a4 = config22.count, count = _a4 === void 0 ? Infinity : _a4, delay2 = config22.delay, _b2 = config22.resetOnSuccess, resetOnSuccess = _b2 === void 0 ? false : _b2;
+  var _a4 = config2.count, count = _a4 === void 0 ? Infinity : _a4, delay2 = config2.delay, _b2 = config2.resetOnSuccess, resetOnSuccess = _b2 === void 0 ? false : _b2;
   return count <= 0 ? identity : operate(function(source2, subscriber) {
     var soFar = 0;
     var innerSub;
@@ -44171,22 +43833,22 @@ var require_transfer = __commonJS({
         }
       }
     };
-    function uploadFrom(source2, config3) {
-      const resolver = new TransferResolver(config3.ftp, config3.tracker);
-      const fullCommand = `${config3.command} ${config3.remotePath}`;
-      return config3.ftp.handle(fullCommand, (res, task) => {
+    function uploadFrom(source2, config2) {
+      const resolver = new TransferResolver(config2.ftp, config2.tracker);
+      const fullCommand = `${config2.command} ${config2.remotePath}`;
+      return config2.ftp.handle(fullCommand, (res, task) => {
         if (res instanceof Error) {
           resolver.onError(task, res);
         } else if (res.code === 150 || res.code === 125) {
-          const dataSocket = config3.ftp.dataSocket;
+          const dataSocket = config2.ftp.dataSocket;
           if (!dataSocket) {
             resolver.onError(task, new Error("Upload should begin but no data connection is available."));
             return;
           }
           const canUpload = "getCipher" in dataSocket ? dataSocket.getCipher() !== void 0 : true;
           onConditionOrEvent(canUpload, dataSocket, "secureConnect", () => {
-            config3.ftp.log(`Uploading to ${(0, netUtils_1.describeAddress)(dataSocket)} (${(0, netUtils_1.describeTLS)(dataSocket)})`);
-            resolver.onDataStart(config3.remotePath, config3.type);
+            config2.ftp.log(`Uploading to ${(0, netUtils_1.describeAddress)(dataSocket)} (${(0, netUtils_1.describeTLS)(dataSocket)})`);
+            resolver.onDataStart(config2.remotePath, config2.type);
             (0, stream_1.pipeline)(source2, dataSocket, (err) => {
               if (err) {
                 resolver.onError(task, err);
@@ -44203,22 +43865,22 @@ var require_transfer = __commonJS({
       });
     }
     exports2.uploadFrom = uploadFrom;
-    function downloadTo(destination, config3) {
-      if (!config3.ftp.dataSocket) {
+    function downloadTo(destination, config2) {
+      if (!config2.ftp.dataSocket) {
         throw new Error("Download will be initiated but no data connection is available.");
       }
-      const resolver = new TransferResolver(config3.ftp, config3.tracker);
-      return config3.ftp.handle(config3.command, (res, task) => {
+      const resolver = new TransferResolver(config2.ftp, config2.tracker);
+      return config2.ftp.handle(config2.command, (res, task) => {
         if (res instanceof Error) {
           resolver.onError(task, res);
         } else if (res.code === 150 || res.code === 125) {
-          const dataSocket = config3.ftp.dataSocket;
+          const dataSocket = config2.ftp.dataSocket;
           if (!dataSocket) {
             resolver.onError(task, new Error("Download should begin but no data connection is available."));
             return;
           }
-          config3.ftp.log(`Downloading from ${(0, netUtils_1.describeAddress)(dataSocket)} (${(0, netUtils_1.describeTLS)(dataSocket)})`);
-          resolver.onDataStart(config3.remotePath, config3.type);
+          config2.ftp.log(`Downloading from ${(0, netUtils_1.describeAddress)(dataSocket)} (${(0, netUtils_1.describeTLS)(dataSocket)})`);
+          resolver.onDataStart(config2.remotePath, config2.type);
           (0, stream_1.pipeline)(dataSocket, destination, (err) => {
             if (err) {
               resolver.onError(task, err);
@@ -44227,7 +43889,7 @@ var require_transfer = __commonJS({
             }
           });
         } else if (res.code === 350) {
-          config3.ftp.send("RETR " + config3.remotePath);
+          config2.ftp.send("RETR " + config2.remotePath);
         } else if ((0, parseControlResponse_1.positiveCompletion)(res.code)) {
           resolver.onControlDone(task, res);
         } else if ((0, parseControlResponse_1.positiveIntermediate)(res.code)) {
@@ -48051,7 +47713,7 @@ var require_source_map = __commonJS({
 });
 
 // node_modules/escodegen/package.json
-var require_package2 = __commonJS({
+var require_package = __commonJS({
   "node_modules/escodegen/package.json"(exports2, module2) {
     module2.exports = {
       name: "escodegen",
@@ -50192,7 +49854,7 @@ var require_escodegen = __commonJS({
         semicolons: false
       };
       FORMAT_DEFAULTS = getDefaultOptions().format;
-      exports2.version = require_package2().version;
+      exports2.version = require_package().version;
       exports2.generate = generate;
       exports2.attachComments = estraverse.attachComments;
       exports2.Precedence = updateDeeply({}, Precedence);
@@ -56355,13 +56017,13 @@ var require_esprima = __commonJS({
               return Reader2;
             }();
             var Tokenizer = function() {
-              function Tokenizer2(code, config3) {
+              function Tokenizer2(code, config2) {
                 this.errorHandler = new error_handler_1.ErrorHandler();
-                this.errorHandler.tolerant = config3 ? typeof config3.tolerant === "boolean" && config3.tolerant : false;
+                this.errorHandler.tolerant = config2 ? typeof config2.tolerant === "boolean" && config2.tolerant : false;
                 this.scanner = new scanner_1.Scanner(code, this.errorHandler);
-                this.scanner.trackComment = config3 ? typeof config3.comment === "boolean" && config3.comment : false;
-                this.trackRange = config3 ? typeof config3.range === "boolean" && config3.range : false;
-                this.trackLoc = config3 ? typeof config3.loc === "boolean" && config3.loc : false;
+                this.scanner.trackComment = config2 ? typeof config2.comment === "boolean" && config2.comment : false;
+                this.trackRange = config2 ? typeof config2.range === "boolean" && config2.range : false;
+                this.trackLoc = config2 ? typeof config2.loc === "boolean" && config2.loc : false;
                 this.buffer = [];
                 this.reader = new Reader();
               }
@@ -59937,7 +59599,7 @@ var require_namedTypes = __commonJS({
 });
 
 // node_modules/ast-types/main.js
-var require_main2 = __commonJS({
+var require_main = __commonJS({
   "node_modules/ast-types/main.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -60022,7 +59684,7 @@ var require_degenerator = __commonJS({
     var util_1 = require("util");
     var escodegen_1 = require_escodegen();
     var esprima_1 = require_esprima();
-    var ast_types_1 = require_main2();
+    var ast_types_1 = require_main();
     function degenerator(code, _names) {
       if (!Array.isArray(_names)) {
         throw new TypeError('an array of async function "names" is required');
@@ -69955,23 +69617,23 @@ var require_build3 = __commonJS({
             const configPath = argv3[configKey] || configLookup[configKey];
             if (configPath) {
               try {
-                let config3 = null;
+                let config2 = null;
                 const resolvedConfigPath = mixin3.resolve(mixin3.cwd(), configPath);
                 const resolveConfig = flags.configs[configKey];
                 if (typeof resolveConfig === "function") {
                   try {
-                    config3 = resolveConfig(resolvedConfigPath);
+                    config2 = resolveConfig(resolvedConfigPath);
                   } catch (e) {
-                    config3 = e;
+                    config2 = e;
                   }
-                  if (config3 instanceof Error) {
-                    error = config3;
+                  if (config2 instanceof Error) {
+                    error = config2;
                     return;
                   }
                 } else {
-                  config3 = mixin3.require(resolvedConfigPath);
+                  config2 = mixin3.require(resolvedConfigPath);
                 }
-                setConfigObject(config3);
+                setConfigObject(config2);
               } catch (ex) {
                 if (ex.name === "PermissionDenied")
                   error = ex;
@@ -69981,9 +69643,9 @@ var require_build3 = __commonJS({
             }
           });
         }
-        function setConfigObject(config3, prev) {
-          Object.keys(config3).forEach(function(key) {
-            const value = config3[key];
+        function setConfigObject(config2, prev) {
+          Object.keys(config2).forEach(function(key) {
+            const value = config2[key];
             const fullKey = prev ? prev + "." + key : key;
             if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) {
               setConfigObject(value, fullKey);
@@ -76514,23 +76176,23 @@ var YargsParser = class {
         const configPath = argv3[configKey] || configLookup[configKey];
         if (configPath) {
           try {
-            let config3 = null;
+            let config2 = null;
             const resolvedConfigPath = mixin2.resolve(mixin2.cwd(), configPath);
             const resolveConfig = flags.configs[configKey];
             if (typeof resolveConfig === "function") {
               try {
-                config3 = resolveConfig(resolvedConfigPath);
+                config2 = resolveConfig(resolvedConfigPath);
               } catch (e) {
-                config3 = e;
+                config2 = e;
               }
-              if (config3 instanceof Error) {
-                error = config3;
+              if (config2 instanceof Error) {
+                error = config2;
                 return;
               }
             } else {
-              config3 = mixin2.require(resolvedConfigPath);
+              config2 = mixin2.require(resolvedConfigPath);
             }
-            setConfigObject(config3);
+            setConfigObject(config2);
           } catch (ex) {
             if (ex.name === "PermissionDenied")
               error = ex;
@@ -76540,9 +76202,9 @@ var YargsParser = class {
         }
       });
     }
-    function setConfigObject(config3, prev) {
-      Object.keys(config3).forEach(function(key) {
-        const value = config3[key];
+    function setConfigObject(config2, prev) {
+      Object.keys(config2).forEach(function(key) {
+        const value = config2[key];
         const fullKey = prev ? prev + "." + key : key;
         if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) {
           setConfigObject(value, fullKey);
@@ -77691,11 +77353,11 @@ var CommandInstance = class {
     });
     if (!unparsed.length)
       return;
-    const config3 = Object.assign({}, options.configuration, {
+    const config2 = Object.assign({}, options.configuration, {
       "populate--": false
     });
     const parsed = this.shim.Parser.detailed(unparsed, Object.assign({}, options, {
-      configuration: config3
+      configuration: config2
     }));
     if (parsed.error) {
       yargs.getInternalMethods().getUsageInstance().fail(parsed.error.message, parsed.error);
@@ -78918,31 +78580,31 @@ ${customMsgs.join("\n")}` : "";
 // node_modules/yargs/build/lib/utils/apply-extends.js
 var previouslyVisitedConfigs = [];
 var shim2;
-function applyExtends(config3, cwd, mergeExtends, _shim) {
+function applyExtends(config2, cwd, mergeExtends, _shim) {
   shim2 = _shim;
   let defaultConfig = {};
-  if (Object.prototype.hasOwnProperty.call(config3, "extends")) {
-    if (typeof config3.extends !== "string")
+  if (Object.prototype.hasOwnProperty.call(config2, "extends")) {
+    if (typeof config2.extends !== "string")
       return defaultConfig;
-    const isPath = /\.json|\..*rc$/.test(config3.extends);
+    const isPath = /\.json|\..*rc$/.test(config2.extends);
     let pathToDefault = null;
     if (!isPath) {
       try {
-        pathToDefault = require.resolve(config3.extends);
+        pathToDefault = require.resolve(config2.extends);
       } catch (_err) {
-        return config3;
+        return config2;
       }
     } else {
-      pathToDefault = getPathToDefaultConfig(cwd, config3.extends);
+      pathToDefault = getPathToDefaultConfig(cwd, config2.extends);
     }
     checkForCircularExtends(pathToDefault);
     previouslyVisitedConfigs.push(pathToDefault);
-    defaultConfig = isPath ? JSON.parse(shim2.readFileSync(pathToDefault, "utf8")) : require(config3.extends);
-    delete config3.extends;
+    defaultConfig = isPath ? JSON.parse(shim2.readFileSync(pathToDefault, "utf8")) : require(config2.extends);
+    delete config2.extends;
     defaultConfig = applyExtends(defaultConfig, shim2.path.dirname(pathToDefault), mergeExtends, shim2);
   }
   previouslyVisitedConfigs = [];
-  return mergeExtends ? mergeDeep(defaultConfig, config3) : Object.assign({}, defaultConfig, config3);
+  return mergeExtends ? mergeDeep(defaultConfig, config2) : Object.assign({}, defaultConfig, config2);
 }
 function checkForCircularExtends(cfgPath) {
   if (previouslyVisitedConfigs.indexOf(cfgPath) > -1) {
@@ -78952,17 +78614,17 @@ function checkForCircularExtends(cfgPath) {
 function getPathToDefaultConfig(cwd, pathToExtend) {
   return shim2.path.resolve(cwd, pathToExtend);
 }
-function mergeDeep(config1, config22) {
+function mergeDeep(config1, config2) {
   const target = {};
   function isObject(obj) {
     return obj && typeof obj === "object" && !Array.isArray(obj);
   }
   Object.assign(target, config1);
-  for (const key of Object.keys(config22)) {
-    if (isObject(config22[key]) && isObject(target[key])) {
-      target[key] = mergeDeep(config1[key], config22[key]);
+  for (const key of Object.keys(config2)) {
+    if (isObject(config2[key]) && isObject(target[key])) {
+      target[key] = mergeDeep(config1[key], config2[key]);
     } else {
-      target[key] = config22[key];
+      target[key] = config2[key];
     }
   }
   return target;
@@ -79718,9 +79380,9 @@ var YargsInstance = class {
     }
     return maybePromise;
   }
-  parserConfiguration(config3) {
-    argsert("<object>", [config3], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_parserConfig, config3, "f");
+  parserConfiguration(config2) {
+    argsert("<object>", [config2], arguments.length);
+    __classPrivateFieldSet(this, _YargsInstance_parserConfig, config2, "f");
     return this;
   }
   pkgConf(key, rootPath) {
@@ -79892,9 +79554,9 @@ var YargsInstance = class {
       return this;
     }
   }
-  usageConfiguration(config3) {
-    argsert("<object>", [config3], arguments.length);
-    __classPrivateFieldSet(this, _YargsInstance_usageConfig, config3, "f");
+  usageConfiguration(config2) {
+    argsert("<object>", [config2], arguments.length);
+    __classPrivateFieldSet(this, _YargsInstance_usageConfig, config2, "f");
     return this;
   }
   version(opt, msg, ver) {
@@ -80300,11 +79962,11 @@ var YargsInstance = class {
     __classPrivateFieldGet(this, _YargsInstance_options, "f").__ = __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.__;
     __classPrivateFieldGet(this, _YargsInstance_options, "f").configuration = this[kGetParserConfiguration]();
     const populateDoubleDash = !!__classPrivateFieldGet(this, _YargsInstance_options, "f").configuration["populate--"];
-    const config3 = Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, "f").configuration, {
+    const config2 = Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, "f").configuration, {
       "populate--": true
     });
     const parsed = __classPrivateFieldGet(this, _YargsInstance_shim, "f").Parser.detailed(args, Object.assign({}, __classPrivateFieldGet(this, _YargsInstance_options, "f"), {
-      configuration: { "parse-positional-numbers": false, ...config3 }
+      configuration: { "parse-positional-numbers": false, ...config2 }
     }));
     const argv2 = Object.assign(parsed.argv, __classPrivateFieldGet(this, _YargsInstance_parseContext, "f"));
     let argvPromise = void 0;
@@ -84229,9 +83891,6 @@ var nullableType = ZodNullable.create;
 var preprocessType = ZodEffects.createWithPreprocess;
 var pipelineType = ZodPipeline.create;
 
-// src/setup.ts
-var dotenv = __toESM(require_main(), 1);
-
 // node_modules/puppeteer-core/lib/esm/puppeteer/api/api.js
 init_Browser();
 init_BrowserContext();
@@ -93646,8 +93305,8 @@ var import_progress = __toESM(require_progress(), 1);
 // node_modules/yargs/yargs.mjs
 var import_build = __toESM(require_build5(), 1);
 var { applyExtends: applyExtends2, cjsPlatformShim, Parser: Parser2, processArgv, Yargs: Yargs2 } = import_build.default;
-Yargs2.applyExtends = (config3, cwd, mergeExtends) => {
-  return applyExtends2(config3, cwd, mergeExtends, cjsPlatformShim);
+Yargs2.applyExtends = (config2, cwd, mergeExtends) => {
+  return applyExtends2(config2, cwd, mergeExtends, cjsPlatformShim);
 };
 Yargs2.hideBin = processArgv.hideBin;
 Yargs2.Parser = Parser2;
@@ -94611,16 +94270,17 @@ var {
 var puppeteer_core_default = puppeteer;
 
 // src/setup.ts
-var envFile = process.env.NODE_ENV === "production" ? ".env" : ".env.development";
-dotenv.config({ path: envFile });
-async function setupBrowser() {
+async function setupBrowser({
+  executablePath: executablePath2,
+  userDataDir
+}) {
   const browser = await puppeteer_core_default.launch({
     args: ["--start-maximized", "--enable-save-password-bubble"],
-    executablePath: process.env.EXECUTABLE_PATH,
+    executablePath: executablePath2,
     headless: false,
     defaultViewport: null,
     ignoreDefaultArgs: ["--enable-automation"],
-    userDataDir: process.env.USER_DATA_DIR
+    userDataDir
   });
   const pages = await browser.pages();
   if (pages[0] !== void 0) {
@@ -95642,11 +95302,6 @@ function ensureHttps(url) {
   }
   return url;
 }
-function sleep(ms) {
-  return new Promise((resolve5) => {
-    setTimeout(resolve5, ms);
-  });
-}
 
 // src/azureLogin.ts
 async function loginToAzure({
@@ -95663,17 +95318,23 @@ async function loginToAzure({
     page.goto(ensureHttps(url || AZURE_LOGIN_URL))
   ]);
   spinner.start("Entering email...");
-  await page.waitForSelector('[name="loginfmt"]');
-  await page.type('[name="loginfmt"]', username);
-  await sleep(1e3);
+  const loginElementSelector = '[name="loginfmt"]';
+  await page.waitForSelector(loginElementSelector);
+  await page.type(loginElementSelector, username);
+  await page.evaluate((text) => {
+    document.querySelector(loginElementSelector).value = text;
+  }, username);
   await page.click('[type="submit"]');
   spinner.start("Entering password...");
   await new Promise((resolve5) => {
     setTimeout(resolve5, 1e3);
   });
-  await page.waitForSelector('input[type="password"]', { visible: true });
-  await page.type('input[type="password"]', password);
-  await sleep(1e3);
+  const passwordElementSelector = 'input[type="password"]';
+  await page.waitForSelector(passwordElementSelector, { visible: true });
+  await page.type(passwordElementSelector, password);
+  await page.evaluate((text) => {
+    document.querySelector(passwordElementSelector).value = text;
+  }, password);
   await page.keyboard.press("Enter");
   await page.waitForNavigation();
   await page.waitForSelector('[type="submit"]');
@@ -95718,6 +95379,15 @@ async function loginToDatabricks({
   spinner.succeed(source_default.green("Logged in to Databricks successfully"));
 }
 
+// src/resetChrome.ts
+var import_node_child_process = require("node:child_process");
+var import_promises3 = require("node:fs/promises");
+var resetChrome = async ({ userDataDir }) => {
+  const stdout = (0, import_node_child_process.execSync)("taskkill /IM chrome.exe /F");
+  console.log("Result from killing chrome.exe:", stdout.toString());
+  await (0, import_promises3.rm)(userDataDir, { recursive: true, force: true });
+};
+
 // src/startInputWatcher.ts
 var Input = objectType({
   cloudProvider: enumType(["aws", "azure", "databricks"]),
@@ -95725,12 +95395,19 @@ var Input = objectType({
   url: stringType(),
   username: stringType()
 });
-var handleInput = async (line) => {
+var handleInput = async ({
+  line,
+  userDataDir,
+  executablePath: executablePath2
+}) => {
   try {
     const { cloudProvider, url, password, username } = Input.parse(
       JSON.parse(line)
     );
-    const { browser, page } = await setupBrowser();
+    const { browser, page } = await setupBrowser({
+      executablePath: executablePath2,
+      userDataDir
+    });
     switch (cloudProvider) {
       case "azure":
         await loginToAzure({ url, username, page, password });
@@ -95759,33 +95436,71 @@ var handleInput = async (line) => {
         console.error(source_default.red("Unsupported cloud provider"));
     }
   } catch (error) {
-    console.error(source_default.red(`Error: ${error.message}`));
+    console.error(source_default.red(`Error: "${error.message}" on input ${line}`));
+  }
+};
+var createFileIfNotExists = async (filePath) => {
+  try {
+    await fs6.access(filePath);
+  } catch {
+    const handle = await fs6.open(filePath, "w");
+    await handle.close();
   }
 };
 var startInputWatcher = async ({
   inputFilePath,
-  outputFilePath
+  outputFilePath,
+  executablePath: executablePath2,
+  userDataDir
 }) => {
   const outputFileHandle = await fs6.open(outputFilePath, "a");
-  for await (const event of fs6.watch(inputFilePath)) {
-    if (event.eventType !== "change") {
-      continue;
-    }
+  let lastInput = void 0;
+  await createFileIfNotExists(inputFilePath);
+  const checkInputFile = async () => {
     const fileContent = await fs6.readFile(inputFilePath, { encoding: "utf-8" });
     const lines = fileContent.split(/\r?\n/);
-    const firstLine = lines[0]?.trim();
-    if (firstLine == null) {
+    const newInput = lines[0]?.trim();
+    if (newInput == null || newInput === "") {
+      console.log("No input");
+      return;
+    }
+    if (lastInput != null && newInput === lastInput) {
+      console.log("Input already processed");
+      await outputFileHandle.appendFile(`Done: ${newInput}`);
+      return;
+    }
+    if (lastInput != null) {
+      console.log("Resetting Chrome");
+      await resetChrome({ userDataDir });
+    }
+    await handleInput({ line: newInput, userDataDir, executablePath: executablePath2 });
+    await outputFileHandle.appendFile(`Done: ${newInput}`);
+    lastInput = newInput;
+  };
+  await checkInputFile();
+  console.log("Waiting for input");
+  for await (const event of fs6.watch(inputFilePath)) {
+    if (event.eventType !== "change") {
       continue;
     }
-    await handleInput(firstLine);
-    await outputFileHandle.appendFile(`Done: ${firstLine}`);
+    await checkInputFile();
   }
 };
 
 // src/index.ts
 var argv = yargs_default(process.argv.slice(2)).options({
   inputFilePath: { demandOption: true, type: "string" },
-  outputFilePath: { demandOption: true, type: "string" }
+  outputFilePath: { demandOption: true, type: "string" },
+  userDataDir: {
+    demandOption: true,
+    type: "string",
+    description: "Path to the browser data directory"
+  },
+  executablePath: {
+    demandOption: true,
+    type: "string",
+    description: "Path to the browser executable"
+  }
 }).parseSync();
 void startInputWatcher(argv);
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datacamp/learn-vm-scripts",
-  "version": "0.0.1-rc.9",
+  "version": "0.0.3-rc.0",
   "repository": "git@github.com:datacamp-engineering/learn-vm-scripts.git",
   "description": "Scripts used by VMs in learn.",
   "main": "./dist/index.cjs",
@@ -17,7 +17,8 @@
     "lint": "eslint --ext ts .",
     "deduplicate": "yarn-deduplicate",
     "cli": "node dist/index.cjs",
-    "test": "vitest"
+    "test": "vitest",
+    "prepublish": "yarn build"
   },
   "keywords": [],
   "author": "Content Platform <content-platform@datacamp.com>",