UrgentcareCLI 0.1.0 → 0.1.1

data/node_modules/selenium-webdriver/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "selenium-webdriver",
+  "version": "4.0.0-beta.3",
+  "description": "The official WebDriver JavaScript bindings from the Selenium project",
+  "license": "Apache-2.0",
+  "keywords": [
+    "automation",
+    "selenium",
+    "testing",
+    "webdriver",
+    "webdriverjs"
+  ],
+  "homepage": "https://github.com/SeleniumHQ/selenium/tree/trunk/javascript/node/selenium-webdriver#readme",
+  "bugs": {
+    "url": "https://github.com/SeleniumHQ/selenium/issues"
+  },
+  "main": "./index",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SeleniumHQ/selenium.git"
+  },
+  "engines": {
+    "node": ">= 10.15.0"
+  },
+  "dependencies": {
+    "jszip": "^3.5.0",
+    "rimraf": "^2.7.1",
+    "tmp": "^0.2.1",
+    "ws": "^7.3.1"
+  },
+  "devDependencies": {
+    "eslint": "^7.15.0",
+    "eslint-config-prettier": "^7.0.0",
+    "eslint-plugin-no-only-tests": "^2.4.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^3.2.0",
+    "express": "^4.17.1",
+    "jasmine": "^3.6.1",
+    "mocha": "^8.1.0",
+    "multer": "^1.4.2",
+    "prettier": "^2.2.1",
+    "serve-index": "^1.9.1",
+    "sinon": "^7.5.0"
+  },
+  "scripts": {
+    "lint": "eslint --ignore-pattern node_modules --ignore-pattern generator --ext js lib/http.js \"**/*.js\"",
+    "test": "npm run lint && mocha -t 600000 --recursive test",
+    "test-jasmine": "jasmine JASMINE_CONFIG_PATH=jasmine.json"
+  },
+  "mocha": {
+    "recursive": true,
+    "timeout": 600000
+  }
+}

data/node_modules/selenium-webdriver/proxy.js

@@ -0,0 +1,32 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+/**
+ * @fileoverview Proxy module alias.
+ *
+ *     var webdriver = require('selenium-webdriver'),
+ *         proxy = require('selenium-webdriver/proxy');
+ *
+ *     var driver = new webdriver.Builder()
+ *         .withCapabilities(webdriver.Capabilities.chrome())
+ *         .setProxy(proxy.manual({http: 'host:1234'}))
+ *         .build();
+ */
+
+'use strict'
+
+module.exports = require('./lib/proxy')

data/node_modules/selenium-webdriver/remote/index.js

@@ -0,0 +1,624 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const url = require('url')
+
+const httpUtil = require('../http/util')
+const io = require('../io')
+const exec = require('../io/exec')
+const { Zip } = require('../io/zip')
+const cmd = require('../lib/command')
+const input = require('../lib/input')
+const net = require('../net')
+const portprober = require('../net/portprober')
+
+/**
+ * @typedef {(string|!Array<string|number|!stream.Stream|null|undefined>)}
+ */
+var StdIoOptions // eslint-disable-line
+
+/**
+ * @typedef {(string|!IThenable<string>)}
+ */
+var CommandLineFlag // eslint-disable-line
+
+/**
+ * A record object that defines the configuration options for a DriverService
+ * instance.
+ *
+ * @record
+ */
+function ServiceOptions() {}
+
+/**
+ * Whether the service should only be accessed on this host's loopback address.
+ *
+ * @type {(boolean|undefined)}
+ */
+ServiceOptions.prototype.loopback
+
+/**
+ * The host name to access the server on. If this option is specified, the
+ * {@link #loopback} option will be ignored.
+ *
+ * @type {(string|undefined)}
+ */
+ServiceOptions.prototype.hostname
+
+/**
+ * The port to start the server on (must be > 0). If the port is provided as a
+ * promise, the service will wait for the promise to resolve before starting.
+ *
+ * @type {(number|!IThenable<number>)}
+ */
+ServiceOptions.prototype.port
+
+/**
+ * The arguments to pass to the service. If a promise is provided, the service
+ * will wait for it to resolve before starting.
+ *
+ * @type {!(Array<CommandLineFlag>|IThenable<!Array<CommandLineFlag>>)}
+ */
+ServiceOptions.prototype.args
+
+/**
+ * The base path on the server for the WebDriver wire protocol (e.g. '/wd/hub').
+ * Defaults to '/'.
+ *
+ * @type {(string|undefined|null)}
+ */
+ServiceOptions.prototype.path
+
+/**
+ * The environment variables that should be visible to the server process.
+ * Defaults to inheriting the current process's environment.
+ *
+ * @type {(Object<string, string>|undefined)}
+ */
+ServiceOptions.prototype.env
+
+/**
+ * IO configuration for the spawned server process. For more information, refer
+ * to the documentation of `child_process.spawn`.
+ *
+ * @type {(StdIoOptions|undefined)}
+ * @see https://nodejs.org/dist/latest-v4.x/docs/api/child_process.html#child_process_options_stdio
+ */
+ServiceOptions.prototype.stdio
+
+/**
+ * Manages the life and death of a native executable WebDriver server.
+ *
+ * It is expected that the driver server implements the
+ * https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol.
+ * Furthermore, the managed server should support multiple concurrent sessions,
+ * so that this class may be reused for multiple clients.
+ */
+class DriverService {
+  /**
+   * @param {string} executable Path to the executable to run.
+   * @param {!ServiceOptions} options Configuration options for the service.
+   */
+  constructor(executable, options) {
+    /** @private {string} */
+    this.executable_ = executable
+
+    /** @private {boolean} */
+    this.loopbackOnly_ = !!options.loopback
+
+    /** @private {(string|undefined)} */
+    this.hostname_ = options.hostname
+
+    /** @private {(number|!IThenable<number>)} */
+    this.port_ = options.port
+
+    /**
+     * @private {!(Array<CommandLineFlag>|
+     *             IThenable<!Array<CommandLineFlag>>)}
+     */
+    this.args_ = options.args
+
+    /** @private {string} */
+    this.path_ = options.path || '/'
+
+    /** @private {!Object<string, string>} */
+    this.env_ = options.env || process.env
+
+    /**
+     * @private {(string|!Array<string|number|!stream.Stream|null|undefined>)}
+     */
+    this.stdio_ = options.stdio || 'ignore'
+
+    /**
+     * A promise for the managed subprocess, or null if the server has not been
+     * started yet. This promise will never be rejected.
+     * @private {Promise<!exec.Command>}
+     */
+    this.command_ = null
+
+    /**
+     * Promise that resolves to the server's address or null if the server has
+     * not been started. This promise will be rejected if the server terminates
+     * before it starts accepting WebDriver requests.
+     * @private {Promise<string>}
+     */
+    this.address_ = null
+  }
+
+  /**
+   * @return {!Promise<string>} A promise that resolves to the server's address.
+   * @throws {Error} If the server has not been started.
+   */
+  address() {
+    if (this.address_) {
+      return this.address_
+    }
+    throw Error('Server has not been started.')
+  }
+
+  /**
+   * Returns whether the underlying process is still running. This does not take
+   * into account whether the process is in the process of shutting down.
+   * @return {boolean} Whether the underlying service process is running.
+   */
+  isRunning() {
+    return !!this.address_
+  }
+
+  /**
+   * Starts the server if it is not already running.
+   * @param {number=} opt_timeoutMs How long to wait, in milliseconds, for the
+   *     server to start accepting requests. Defaults to 30 seconds.
+   * @return {!Promise<string>} A promise that will resolve to the server's base
+   *     URL when it has started accepting requests. If the timeout expires
+   *     before the server has started, the promise will be rejected.
+   */
+  start(opt_timeoutMs) {
+    if (this.address_) {
+      return this.address_
+    }
+
+    var timeout = opt_timeoutMs || DriverService.DEFAULT_START_TIMEOUT_MS
+    var self = this
+
+    let resolveCommand
+    this.command_ = new Promise((resolve) => (resolveCommand = resolve))
+
+    this.address_ = new Promise((resolveAddress, rejectAddress) => {
+      resolveAddress(
+        Promise.resolve(this.port_).then((port) => {
+          if (port <= 0) {
+            throw Error('Port must be > 0: ' + port)
+          }
+
+          return resolveCommandLineFlags(this.args_).then((args) => {
+            const command = exec(self.executable_, {
+              args: args,
+              env: self.env_,
+              stdio: self.stdio_,
+            })
+
+            resolveCommand(command)
+
+            const earlyTermination = command.result().then(function (result) {
+              const error =
+                result.code == null
+                  ? Error('Server was killed with ' + result.signal)
+                  : Error('Server terminated early with status ' + result.code)
+              rejectAddress(error)
+              self.address_ = null
+              self.command_ = null
+              throw error
+            })
+
+            let hostname = self.hostname_
+            if (!hostname) {
+              hostname =
+                (!self.loopbackOnly_ && net.getAddress()) ||
+                net.getLoopbackAddress()
+            }
+
+            var serverUrl = url.format({
+              protocol: 'http',
+              hostname: hostname,
+              port: port + '',
+              pathname: self.path_,
+            })
+
+            return new Promise((fulfill, reject) => {
+              let cancelToken = earlyTermination.catch((e) =>
+                reject(Error(e.message))
+              )
+
+              httpUtil.waitForServer(serverUrl, timeout, cancelToken).then(
+                (_) => fulfill(serverUrl),
+                (err) => {
+                  if (err instanceof httpUtil.CancellationError) {
+                    fulfill(serverUrl)
+                  } else {
+                    reject(err)
+                  }
+                }
+              )
+            })
+          })
+        })
+      )
+    })
+
+    return this.address_
+  }
+
+  /**
+   * Stops the service if it is not currently running. This function will kill
+   * the server immediately. To synchronize with the active control flow, use
+   * {@link #stop()}.
+   * @return {!Promise} A promise that will be resolved when the server has been
+   *     stopped.
+   */
+  kill() {
+    if (!this.address_ || !this.command_) {
+      return Promise.resolve() // Not currently running.
+    }
+    let cmd = this.command_
+    this.address_ = null
+    this.command_ = null
+    return cmd.then((c) => c.kill('SIGTERM'))
+  }
+}
+
+/**
+ * @param {!(Array<CommandLineFlag>|IThenable<!Array<CommandLineFlag>>)} args
+ * @return {!Promise<!Array<string>>}
+ */
+function resolveCommandLineFlags(args) {
+  // Resolve the outer array, then the individual flags.
+  return Promise.resolve(args).then(
+    /** !Array<CommandLineFlag> */ (args) => Promise.all(args)
+  )
+}
+
+/**
+ * The default amount of time, in milliseconds, to wait for the server to
+ * start.
+ * @const {number}
+ */
+DriverService.DEFAULT_START_TIMEOUT_MS = 30 * 1000
+
+/**
+ * Creates {@link DriverService} objects that manage a WebDriver server in a
+ * child process.
+ */
+DriverService.Builder = class {
+  /**
+   * @param {string} exe Path to the executable to use. This executable must
+   *     accept the `--port` flag for defining the port to start the server on.
+   * @throws {Error} If the provided executable path does not exist.
+   */
+  constructor(exe) {
+    if (!fs.existsSync(exe)) {
+      throw Error(`The specified executable path does not exist: ${exe}`)
+    }
+
+    /** @private @const {string} */
+    this.exe_ = exe
+
+    /** @private {!ServiceOptions} */
+    this.options_ = {
+      args: [],
+      port: 0,
+      env: null,
+      stdio: 'ignore',
+    }
+  }
+
+  /**
+   * Define additional command line arguments to use when starting the server.
+   *
+   * @param {...CommandLineFlag} var_args The arguments to include.
+   * @return {!THIS} A self reference.
+   * @this {THIS}
+   * @template THIS
+   */
+  addArguments(...arguments_) {
+    this.options_.args = this.options_.args.concat(arguments_)
+    return this
+  }
+
+  /**
+   * Sets the host name to access the server on. If specified, the
+   * {@linkplain #setLoopback() loopback} setting will be ignored.
+   *
+   * @param {string} hostname
+   * @return {!DriverService.Builder} A self reference.
+   */
+  setHostname(hostname) {
+    this.options_.hostname = hostname
+    return this
+  }
+
+  /**
+   * Sets whether the service should be accessed at this host's loopback
+   * address.
+   *
+   * @param {boolean} loopback
+   * @return {!DriverService.Builder} A self reference.
+   */
+  setLoopback(loopback) {
+    this.options_.loopback = loopback
+    return this
+  }
+
+  /**
+   * Sets the base path for WebDriver REST commands (e.g. "/wd/hub").
+   * By default, the driver will accept commands relative to "/".
+   *
+   * @param {?string} basePath The base path to use, or `null` to use the
+   *     default.
+   * @return {!DriverService.Builder} A self reference.
+   */
+  setPath(basePath) {
+    this.options_.path = basePath
+    return this
+  }
+
+  /**
+   * Sets the port to start the server on.
+   *
+   * @param {number} port The port to use, or 0 for any free port.
+   * @return {!DriverService.Builder} A self reference.
+   * @throws {Error} If an invalid port is specified.
+   */
+  setPort(port) {
+    if (port < 0) {
+      throw Error(`port must be >= 0: ${port}`)
+    }
+    this.options_.port = port
+    return this
+  }
+
+  /**
+   * Defines the environment to start the server under. This setting will be
+   * inherited by every browser session started by the server. By default, the
+   * server will inherit the enviroment of the current process.
+   *
+   * @param {(Map<string, string>|Object<string, string>|null)} env The desired
+   *     environment to use, or `null` if the server should inherit the
+   *     current environment.
+   * @return {!DriverService.Builder} A self reference.
+   */
+  setEnvironment(env) {
+    if (env instanceof Map) {
+      let tmp = {}
+      env.forEach((value, key) => (tmp[key] = value))
+      env = tmp
+    }
+    this.options_.env = env
+    return this
+  }
+
+  /**
+   * IO configuration for the spawned server process. For more information,
+   * refer to the documentation of `child_process.spawn`.
+   *
+   * @param {StdIoOptions} config The desired IO configuration.
+   * @return {!DriverService.Builder} A self reference.
+   * @see https://nodejs.org/dist/latest-v4.x/docs/api/child_process.html#child_process_options_stdio
+   */
+  setStdio(config) {
+    this.options_.stdio = config
+    return this
+  }
+
+  /**
+   * Creates a new DriverService using this instance's current configuration.
+   *
+   * @return {!DriverService} A new driver service.
+   */
+  build() {
+    let port = this.options_.port || portprober.findFreePort()
+    let args = Promise.resolve(port).then((port) => {
+      return this.options_.args.concat('--port=' + port)
+    })
+
+    let options =
+      /** @type {!ServiceOptions} */
+      (Object.assign({}, this.options_, { args, port }))
+    return new DriverService(this.exe_, options)
+  }
+}
+
+/**
+ * Manages the life and death of the
+ * <a href="http://selenium-release.storage.googleapis.com/index.html">
+ * standalone Selenium server</a>.
+ */
+class SeleniumServer extends DriverService {
+  /**
+   * @param {string} jar Path to the Selenium server jar.
+   * @param {SeleniumServer.Options=} opt_options Configuration options for the
+   *     server.
+   * @throws {Error} If the path to the Selenium jar is not specified or if an
+   *     invalid port is specified.
+   */
+  constructor(jar, opt_options) {
+    if (!jar) {
+      throw Error('Path to the Selenium jar not specified')
+    }
+
+    var options = opt_options || {}
+
+    if (options.port < 0) {
+      throw Error('Port must be >= 0: ' + options.port)
+    }
+
+    let port = options.port || portprober.findFreePort()
+    let args = Promise.all([
+      port,
+      options.jvmArgs || [],
+      options.args || [],
+    ]).then((resolved) => {
+      let port = resolved[0]
+      let jvmArgs = resolved[1]
+      let args = resolved[2]
+      return jvmArgs.concat('-jar', jar, '-port', port).concat(args)
+    })
+
+    let java = 'java'
+    if (process.env['JAVA_HOME']) {
+      java = path.join(process.env['JAVA_HOME'], 'bin/java')
+    }
+
+    super(java, {
+      loopback: options.loopback,
+      port: port,
+      args: args,
+      path: '/wd/hub',
+      env: options.env,
+      stdio: options.stdio,
+    })
+  }
+}
+
+/**
+ * A record object describing configuration options for a {@link SeleniumServer}
+ * instance.
+ *
+ * @record
+ */
+SeleniumServer.Options = class {
+  constructor() {
+    /**
+     * Whether the server should only be accessible on this host's loopback
+     * address.
+     *
+     * @type {(boolean|undefined)}
+     */
+    this.loopback
+
+    /**
+     * The port to start the server on (must be > 0). If the port is provided as
+     * a promise, the service will wait for the promise to resolve before
+     * starting.
+     *
+     * @type {(number|!IThenable<number>)}
+     */
+    this.port
+
+    /**
+     * The arguments to pass to the service. If a promise is provided,
+     * the service will wait for it to resolve before starting.
+     *
+     * @type {!(Array<string>|IThenable<!Array<string>>)}
+     */
+    this.args
+
+    /**
+     * The arguments to pass to the JVM. If a promise is provided,
+     * the service will wait for it to resolve before starting.
+     *
+     * @type {(!Array<string>|!IThenable<!Array<string>>|undefined)}
+     */
+    this.jvmArgs
+
+    /**
+     * The environment variables that should be visible to the server
+     * process. Defaults to inheriting the current process's environment.
+     *
+     * @type {(!Object<string, string>|undefined)}
+     */
+    this.env
+
+    /**
+     * IO configuration for the spawned server process. If unspecified, IO will
+     * be ignored.
+     *
+     * @type {(string|!Array<string|number|!stream.Stream|null|undefined>|
+     *         undefined)}
+     * @see <https://nodejs.org/dist/latest-v8.x/docs/api/child_process.html#child_process_options_stdio>
+     */
+    this.stdio
+  }
+}
+
+/**
+ * A {@link webdriver.FileDetector} that may be used when running
+ * against a remote
+ * [Selenium server](http://selenium-release.storage.googleapis.com/index.html).
+ *
+ * When a file path on the local machine running this script is entered with
+ * {@link webdriver.WebElement#sendKeys WebElement#sendKeys}, this file detector
+ * will transfer the specified file to the Selenium server's host; the sendKeys
+ * command will be updated to use the transfered file's path.
+ *
+ * __Note:__ This class depends on a non-standard command supported on the
+ * Java Selenium server. The file detector will fail if used with a server that
+ * only supports standard WebDriver commands (such as the ChromeDriver).
+ *
+ * @final
+ */
+class FileDetector extends input.FileDetector {
+  /**
+   * Prepares a `file` for use with the remote browser. If the provided path
+   * does not reference a normal file (i.e. it does not exist or is a
+   * directory), then the promise returned by this method will be resolved with
+   * the original file path. Otherwise, this method will upload the file to the
+   * remote server, which will return the file's path on the remote system so
+   * it may be referenced in subsequent commands.
+   *
+   * @override
+   */
+  handleFile(driver, file) {
+    return io.stat(file).then(
+      function (stats) {
+        if (stats.isDirectory()) {
+          return file // Not a valid file, return original input.
+        }
+
+        let zip = new Zip()
+        return zip
+          .addFile(file)
+          .then(() => zip.toBuffer())
+          .then((buf) => buf.toString('base64'))
+          .then((encodedZip) => {
+            let command = new cmd.Command(cmd.Name.UPLOAD_FILE).setParameter(
+              'file',
+              encodedZip
+            )
+            return driver.execute(command)
+          })
+      },
+      function (err) {
+        if (err.code === 'ENOENT') {
+          return file // Not a file; return original input.
+        }
+        throw err
+      }
+    )
+  }
+}
+
+// PUBLIC API
+
+exports.DriverService = DriverService
+exports.FileDetector = FileDetector
+exports.SeleniumServer = SeleniumServer
+exports.ServiceOptions = ServiceOptions // Exported for API docs.