appium-safari-driver 2.2.0 → 3.0.4

package/build/test/functional/desktop-driver-e2e-specs.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 require("source-map-support/register");
 
-var _wd = _interopRequireDefault(require("wd"));
+var _webdriverio = require("webdriverio");
 
 var _ = require("../..");
 
@@ -36,21 +36,24 @@ describe('Desktop SafariDriver', function () {
     }
   });
   beforeEach(async function () {
-    driver = _wd.default.promiseChainRemote(_utils.HOST, _utils.PORT);
-    await driver.init(CAPS);
+    driver = await (0, _webdriverio.remote)({
+      hostname: _utils.HOST,
+      port: _utils.PORT,
+      capabilities: CAPS
+    });
   });
   afterEach(async function () {
     if (driver) {
-      await driver.quit();
+      await driver.deleteSession();
       driver = null;
     }
   });
   it('should start and stop a session', async function () {
-    await driver.get('https://appium.io/');
-    const button = await driver.elementByCss('#downloadLink');
-    await button.text().should.eventually.eql('Download Appium');
+    await driver.url('https://appium.io/');
+    const button = await driver.$('#downloadLink');
+    await button.getText().should.eventually.eql('Download Appium');
   });
 });require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvZnVuY3Rpb25hbC9kZXNrdG9wLWRyaXZlci1lMmUtc3BlY3MuanMiXSwibmFtZXMiOlsiY2hhaSIsInNob3VsZCIsInVzZSIsImNoYWlBc1Byb21pc2VkIiwiQ0FQUyIsImJyb3dzZXJOYW1lIiwicGxhdGZvcm1OYW1lIiwiZGVzY3JpYmUiLCJ0aW1lb3V0IiwiTU9DSEFfVElNRU9VVCIsInNlcnZlciIsImRyaXZlciIsImJlZm9yZSIsIlBPUlQiLCJIT1NUIiwiYWZ0ZXIiLCJjbG9zZSIsImJlZm9yZUVhY2giLCJ3ZCIsInByb21pc2VDaGFpblJlbW90ZSIsImluaXQiLCJhZnRlckVhY2giLCJxdWl0IiwiaXQiLCJnZXQiLCJidXR0b24iLCJlbGVtZW50QnlDc3MiLCJ0ZXh0IiwiZXZlbnR1YWxseSIsImVxbCJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUE7O0FBQ0E7O0FBQ0E7O0FBQ0E7O0FBQ0E7O0FBRUFBLGNBQUtDLE1BQUw7O0FBQ0FELGNBQUtFLEdBQUwsQ0FBU0MsdUJBQVQ7O0FBR0EsTUFBTUMsSUFBSSxHQUFHO0FBQ1hDLEVBQUFBLFdBQVcsRUFBRSxjQURGO0FBRVhDLEVBQUFBLFlBQVksRUFBRTtBQUZILENBQWI7QUFLQUMsUUFBUSxDQUFDLHNCQUFELEVBQXlCLFlBQVk7QUFDM0MsT0FBS0MsT0FBTCxDQUFhQyxvQkFBYjtBQUVBLE1BQUlDLE1BQUo7QUFDQSxNQUFJQyxNQUFKO0FBQ0FDLEVBQUFBLE1BQU0sQ0FBQyxrQkFBa0I7QUFDdkJGLElBQUFBLE1BQU0sR0FBRyxNQUFNLG1CQUFZRyxXQUFaLEVBQWtCQyxXQUFsQixDQUFmO0FBQ0QsR0FGSyxDQUFOO0FBR0FDLEVBQUFBLEtBQUssQ0FBQyxrQkFBa0I7QUFDdEIsUUFBSUwsTUFBSixFQUFZO0FBQ1YsWUFBTUEsTUFBTSxDQUFDTSxLQUFQLEVBQU47QUFDQU4sTUFBQUEsTUFBTSxHQUFHLElBQVQ7QUFDRDtBQUNGLEdBTEksQ0FBTDtBQU1BTyxFQUFBQSxVQUFVLENBQUMsa0JBQWtCO0FBQzNCTixJQUFBQSxNQUFNLEdBQUdPLFlBQUdDLGtCQUFILENBQXNCTCxXQUF0QixFQUE0QkQsV0FBNUIsQ0FBVDtBQUNBLFVBQU1GLE1BQU0sQ0FBQ1MsSUFBUCxDQUFZaEIsSUFBWixDQUFOO0FBQ0QsR0FIUyxDQUFWO0FBSUFpQixFQUFBQSxTQUFTLENBQUMsa0JBQWtCO0FBQzFCLFFBQUlWLE1BQUosRUFBWTtBQUNWLFlBQU1BLE1BQU0sQ0FBQ1csSUFBUCxFQUFOO0FBQ0FYLE1BQUFBLE1BQU0sR0FBRyxJQUFUO0FBQ0Q7QUFDRixHQUxRLENBQVQ7QUFPQVksRUFBQUEsRUFBRSxDQUFDLGlDQUFELEVBQW9DLGtCQUFrQjtBQUN0RCxVQUFNWixNQUFNLENBQUNhLEdBQVAsQ0FBVyxvQkFBWCxDQUFOO0FBQ0EsVUFBTUMsTUFBTSxHQUFHLE1BQU1kLE1BQU0sQ0FBQ2UsWUFBUCxDQUFvQixlQUFwQixDQUFyQjtBQUNBLFVBQU1ELE1BQU0sQ0FBQ0UsSUFBUCxHQUFjMUIsTUFBZCxDQUFxQjJCLFVBQXJCLENBQWdDQyxHQUFoQyxDQUFvQyxpQkFBcEMsQ0FBTjtBQUNELEdBSkMsQ0FBRjtBQUtELENBOUJPLENBQVIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgd2QgZnJvbSAnd2QnO1xuaW1wb3J0IHsgc3RhcnRTZXJ2ZXIgfSBmcm9tICcuLi8uLic7XG5pbXBvcnQgY2hhaUFzUHJvbWlzZWQgZnJvbSAnY2hhaS1hcy1wcm9taXNlZCc7XG5pbXBvcnQgY2hhaSBmcm9tICdjaGFpJztcbmltcG9ydCB7IEhPU1QsIFBPUlQsIE1PQ0hBX1RJTUVPVVQgfSBmcm9tICcuLi91dGlscyc7XG5cbmNoYWkuc2hvdWxkKCk7XG5jaGFpLnVzZShjaGFpQXNQcm9taXNlZCk7XG5cblxuY29uc3QgQ0FQUyA9IHtcbiAgYnJvd3Nlck5hbWU6ICdBcHBpdW1TYWZhcmknLFxuICBwbGF0Zm9ybU5hbWU6ICdtYWMnLFxufTtcblxuZGVzY3JpYmUoJ0Rlc2t0b3AgU2FmYXJpRHJpdmVyJywgZnVuY3Rpb24gKCkge1xuICB0aGlzLnRpbWVvdXQoTU9DSEFfVElNRU9VVCk7XG5cbiAgbGV0IHNlcnZlcjtcbiAgbGV0IGRyaXZlcjtcbiAgYmVmb3JlKGFzeW5jIGZ1bmN0aW9uICgpIHtcbiAgICBzZXJ2ZXIgPSBhd2FpdCBzdGFydFNlcnZlcihQT1JULCBIT1NUKTtcbiAgfSk7XG4gIGFmdGVyKGFzeW5jIGZ1bmN0aW9uICgpIHtcbiAgICBpZiAoc2VydmVyKSB7XG4gICAgICBhd2FpdCBzZXJ2ZXIuY2xvc2UoKTtcbiAgICAgIHNlcnZlciA9IG51bGw7XG4gICAgfVxuICB9KTtcbiAgYmVmb3JlRWFjaChhc3luYyBmdW5jdGlvbiAoKSB7XG4gICAgZHJpdmVyID0gd2QucHJvbWlzZUNoYWluUmVtb3RlKEhPU1QsIFBPUlQpO1xuICAgIGF3YWl0IGRyaXZlci5pbml0KENBUFMpO1xuICB9KTtcbiAgYWZ0ZXJFYWNoKGFzeW5jIGZ1bmN0aW9uICgpIHtcbiAgICBpZiAoZHJpdmVyKSB7XG4gICAgICBhd2FpdCBkcml2ZXIucXVpdCgpO1xuICAgICAgZHJpdmVyID0gbnVsbDtcbiAgICB9XG4gIH0pO1xuXG4gIGl0KCdzaG91bGQgc3RhcnQgYW5kIHN0b3AgYSBzZXNzaW9uJywgYXN5bmMgZnVuY3Rpb24gKCkge1xuICAgIGF3YWl0IGRyaXZlci5nZXQoJ2h0dHBzOi8vYXBwaXVtLmlvLycpO1xuICAgIGNvbnN0IGJ1dHRvbiA9IGF3YWl0IGRyaXZlci5lbGVtZW50QnlDc3MoJyNkb3dubG9hZExpbmsnKTtcbiAgICBhd2FpdCBidXR0b24udGV4dCgpLnNob3VsZC5ldmVudHVhbGx5LmVxbCgnRG93bmxvYWQgQXBwaXVtJyk7XG4gIH0pO1xufSk7XG5cblxuIl0sImZpbGUiOiJ0ZXN0L2Z1bmN0aW9uYWwvZGVza3RvcC1kcml2ZXItZTJlLXNwZWNzLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLy4uIn0=
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/test/functional/mobile-driver-e2e-specs.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 require("source-map-support/register");
 
-var _wd = _interopRequireDefault(require("wd"));
+var _webdriverio = require("webdriverio");
 
 var _ = require("../..");
 
@@ -63,21 +63,24 @@ describe('Mobile SafariDriver', function () {
     }
   });
   beforeEach(async function () {
-    driver = _wd.default.promiseChainRemote(_utils.HOST, _utils.PORT);
-    await driver.init(CAPS);
+    driver = await (0, _webdriverio.remote)({
+      hostname: _utils.HOST,
+      port: _utils.PORT,
+      capabilities: CAPS
+    });
   });
   afterEach(async function () {
     if (driver) {
-      await driver.quit();
+      await driver.deleteSession();
       driver = null;
     }
   });
   it('should start and stop a session', async function () {
-    await driver.get('https://appium.io/');
-    const button = await driver.elementByCss('#downloadLink');
-    await button.text().should.eventually.eql('Download Appium');
+    await driver.url('https://appium.io/');
+    const button = await driver.$('#downloadLink');
+    await button.getText().should.eventually.eql('Download Appium');
   });
 });require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/test/utils.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MOCHA_TIMEOUT = exports.PORT = exports.HOST = void 0;
+exports.PORT = exports.MOCHA_TIMEOUT = exports.HOST = void 0;
 
 require("source-map-support/register");
 

package/gulpfile.js

@@ -1,10 +1,11 @@
 'use strict';
 
 let gulp = require('gulp');
-let boilerplate = require('appium-gulp-plugins').boilerplate.use(gulp);
+let boilerplate = require('@appium/gulp-plugins').boilerplate.use(gulp);
 
 boilerplate({
-  build: 'appium-firefox-driver',
+  build: 'appium-safari-driver',
+  files: ['index.js', 'lib/**/*.js', 'test/**/*.js', '!gulpfile.js'],
   coverage: {
     files: ['./test/unit/**/*-specs.js', '!./test/functional/**'],
     verbose: true

package/index.js

@@ -1,14 +1,17 @@
 import SafariDriver from './lib/driver';
 import { startServer } from './lib/server';
-import yargs from 'yargs';
 import { asyncify } from 'asyncbox';
 
 const DEFAULT_HOST = 'localhost';
 const DEFAULT_PORT = 4797;
 
 async function main () {
-  let port = yargs.argv.port || yargs.argv.p || DEFAULT_PORT;
-  let host = yargs.argv.host || yargs.argv.h || DEFAULT_HOST;
+  const getArgValue = (argName) => {
+    const argIndex = process.argv.indexOf(argName);
+    return argIndex > 0 ? process.argv[argIndex + 1] : null;
+  };
+  const port = parseInt(getArgValue('--port'), 10) || DEFAULT_PORT;
+  const host = getArgValue('--host') || DEFAULT_HOST;
   return await startServer(port, host);
 }
 

package/lib/commands/cookies.js

@@ -0,0 +1,8 @@
+const commands = {};
+
+commands.deleteCookies = async function deleteCookies () {
+  return await this.safari.proxy.command('/cookie', 'DELETE');
+};
+
+export { commands };
+export default commands;

package/lib/commands/find.js

@@ -1,4 +1,4 @@
-import { util } from 'appium-support';
+import { util } from '@appium/support';
 
 
 const commands = {};

package/lib/commands/index.js

@@ -1,9 +1,13 @@
 import findCmds from './find';
+import cookieCmds from './cookies';
+import recordScreenCommands from './record-screen';
 
 const commands = {};
 Object.assign(
   commands,
   findCmds,
+  cookieCmds,
+  recordScreenCommands,
   // add other command types here
 );
 

package/lib/commands/record-screen.js

@@ -0,0 +1,310 @@
+import _ from 'lodash';
+import { util, fs, net, tempDir } from '@appium/support';
+import { waitForCondition } from 'asyncbox';
+import log from '../logger';
+import Simctl from 'node-simctl';
+
+
+const commands = {};
+
+const STARTUP_INTERVAL_MS = 300;
+const STARTUP_TIMEOUT_MS = 10 * 1000;
+const DEFAULT_TIME_LIMIT_MS = 60 * 10 * 1000; // 10 minutes
+const PROCESS_SHUTDOWN_TIMEOUT_MS = 10 * 1000;
+const DEFAULT_EXT = '.mp4';
+
+
+async function uploadRecordedMedia (localFile, remotePath = null, uploadOptions = {}) {
+  if (_.isEmpty(remotePath)) {
+    const {size} = await fs.stat(localFile);
+    log.debug(`The size of the resulting screen recording is ${util.toReadableSizeString(size)}`);
+    return (await util.toInMemoryBase64(localFile)).toString();
+  }
+
+  const {user, pass, method, headers, fileFieldName, formFields} = uploadOptions;
+  const options = {
+    method: method || 'PUT',
+    headers,
+    fileFieldName,
+    formFields,
+  };
+  if (user && pass) {
+    options.auth = {user, pass};
+  }
+  await net.uploadFile(localFile, remotePath, options);
+  return '';
+}
+
+const VIDEO_FILES = new Set();
+process.on('exit', () => {
+  for (const videoFile of VIDEO_FILES) {
+    try {
+      fs.rimrafSync(videoFile);
+    } catch (ign) {}
+  }
+});
+
+class ScreenRecorder {
+  constructor (udid, videoPath, opts = {}) {
+    this._process = null;
+    this._udid = udid;
+    this._videoPath = videoPath;
+    this._codec = opts.codec;
+    this._display = opts.display;
+    this._mask = opts.mask;
+    this._timeLimitMs = opts.timeLimit > 0 ? opts.timeLimit * 1000 : DEFAULT_TIME_LIMIT_MS;
+    this._timer = null;
+  }
+
+  async getVideoPath () {
+    if (await fs.exists(this._videoPath)) {
+      VIDEO_FILES.add(this._videoPath);
+      return this._videoPath;
+    }
+    return '';
+  }
+
+  get isRunning () {
+    return !!(this._process?.isRunning);
+  }
+
+  async _enforceTermination () {
+    if (this.isRunning) {
+      log.debug('Force-stopping the currently running video recording');
+      try {
+        await this._process.stop('SIGKILL');
+      } catch (ign) {}
+    }
+    this._process = null;
+    const videoPath = await this.getVideoPath();
+    if (videoPath) {
+      await fs.rimraf(videoPath);
+      VIDEO_FILES.delete(videoPath);
+    }
+    return '';
+  }
+
+  async start () {
+    const args = [
+      this._udid, 'recordVideo'
+    ];
+    if (this._display) {
+      args.push('--display', this._display);
+    }
+    if (this._codec) {
+      args.push('--codec', this._codec);
+    }
+    if (this._mask) {
+      args.push('--mask', this._mask);
+    }
+    args.push('--force', this._videoPath);
+    this._process = await new Simctl().exec('io', {
+      args,
+      asynchronous: true,
+    });
+    log.debug(`Starting video recording with arguments: ${util.quote(args)}`);
+    this._process.on('output', (stdout, stderr) => {
+      const line = _.trim(stdout || stderr);
+      if (line) {
+        log.debug(`[recordVideo@${this._udid.substring(0, 8)}] ${line}`);
+      }
+    });
+    this._process.once('exit', async (code, signal) => {
+      this._process = null;
+      if (code === 0) {
+        log.debug('Screen recording exited without errors');
+      } else {
+        await this._enforceTermination();
+        log.warn(`Screen recording exited with error code ${code}, signal ${signal}`);
+      }
+    });
+    await this._process.start(0);
+    try {
+      await waitForCondition(async () => {
+        if (!this.isRunning) {
+          throw new Error();
+        }
+        return !!(await this.getVideoPath());
+      }, {
+        waitMs: STARTUP_TIMEOUT_MS,
+        intervalMs: STARTUP_INTERVAL_MS,
+      });
+    } catch (e) {
+      await this._enforceTermination();
+      log.errorAndThrow(`The expected screen record file '${this._videoPath}' does not exist after ${STARTUP_TIMEOUT_MS}ms. ` +
+        `Check the server log for more details`);
+    }
+    this._timer = setTimeout(async () => {
+      if (this.isRunning) {
+        try {
+          await this.stop();
+        } catch (e) {
+          log.error(e);
+        }
+      }
+    }, this._timeLimitMs);
+    log.info(`The video recording has started. Will timeout in ${this._timeLimitMs}ms`);
+  }
+
+  async stop (force = false) {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = null;
+    }
+
+    if (force) {
+      return await this._enforceTermination();
+    }
+
+    if (!this.isRunning) {
+      log.debug('Screen recording is not running. Returning the recently recorded video');
+      return await this.getVideoPath();
+    }
+
+    try {
+      await this._process.stop('SIGINT', PROCESS_SHUTDOWN_TIMEOUT_MS);
+    } catch (e) {
+      await this._enforceTermination();
+      throw new Error(`Screen recording has failed to stop after ${PROCESS_SHUTDOWN_TIMEOUT_MS}ms`);
+    }
+
+    return await this.getVideoPath();
+  }
+}
+
+async function extractSimulatorUdid (caps) {
+  if (caps['safari:useSimulator'] === false) {
+    return null;
+  }
+
+  const allDevices = _.flatMap(_.values(await new Simctl().getDevices(null, 'iOS')));
+  for (const {name, udid, state, sdk} of allDevices) {
+    if (state !== 'Booted') {
+      continue;
+    }
+
+    if (_.toLower(caps['safari:deviceUDID']) === _.toLower(udid)) {
+      return udid;
+    }
+    if (_.toLower(caps['safari:deviceName']) === _.toLower(name) &&
+      (caps['safari:platformVersion'] && caps['safari:platformVersion'] === sdk
+        || !caps['safari:platformVersion'])) {
+      return udid;
+    }
+  }
+
+  return null;
+}
+
+
+/**
+ * @typedef {Object} StartRecordingOptions
+ *
+ * @property {?string} codec [hevc] - Specifies the codec type: "h264" or "hevc"
+ * @property {?string} display [internal] - Supports "internal" or "external". Default is "internal"
+ * @property {?string} mask - For non-rectangular displays, handle the mask by policy:
+ * - ignored: The mask is ignored and the unmasked framebuffer is saved.
+ * - alpha: Not supported, but retained for compatibility; the mask is rendered black.
+ * - black: The mask is rendered black.
+ * @property {string|number} timeLimit [600] - The maximum recording time, in seconds. The default
+ * value is 600 seconds (10 minutes).
+ * @property {boolean} forceRestart [true] - Whether to ignore the call if a screen recording is currently running
+ * (`false`) or to start a new recording immediately and terminate the existing one if running (`true`).
+ */
+
+/**
+ * Record the Simulator's display in background while the automated test is running.
+ * This method uses `xcrun simctl io recordVideo` helper under the hood.
+ * Check the output of `xcrun simctl io` command for more details.
+ *
+ * @param {?StartRecordingOptions} options - The available options.
+ * @throws {Error} If screen recording has failed to start or is not supported for the destination device.
+ */
+commands.startRecordingScreen = async function startRecordingScreen (options = {}) {
+  const {
+    timeLimit,
+    codec,
+    display,
+    mask,
+    forceRestart = true,
+  } = options;
+  if (this._screenRecorder?.isRunning) {
+    log.info('The screen recording is already running');
+    if (!forceRestart) {
+      log.info('Doing nothing');
+      return;
+    }
+    log.info('Forcing the active screen recording to stop');
+    await this._screenRecorder.stop(true);
+  }
+  this._screenRecorder = null;
+
+  const udid = await extractSimulatorUdid(this.caps);
+  if (!udid) {
+    throw new Error('Cannot determine Simulator UDID to record the video from. ' +
+      'Double check your session capabilities');
+  }
+
+  const videoPath = await tempDir.path({
+    prefix: util.uuidV4().substring(0, 8),
+    suffix: DEFAULT_EXT,
+  });
+  this._screenRecorder = new ScreenRecorder(udid, videoPath, {
+    timeLimit: parseInt(timeLimit, 10),
+    codec,
+    display,
+    mask,
+  });
+  try {
+    await this._screenRecorder.start();
+  } catch (e) {
+    this._screenRecorder = null;
+    throw e;
+  }
+};
+
+/**
+ * @typedef {Object} StopRecordingOptions
+ *
+ * @property {?string} remotePath - The path to the remote location, where the resulting video should be uploaded.
+ * The following protocols are supported: http/https, ftp.
+ * Null or empty string value (the default setting) means the content of resulting
+ * file should be encoded as Base64 and passed as the endpoint response value.
+ * An exception will be thrown if the generated media file is too big to
+ * fit into the available process memory.
+ * @property {?string} user - The name of the user for the remote authentication.
+ * @property {?string} pass - The password for the remote authentication.
+ * @property {?string} method - The http multipart upload method name. The 'PUT' one is used by default.
+ * @property {?Object} headers - Additional headers mapping for multipart http(s) uploads
+ * @property {?string} fileFieldName [file] - The name of the form field, where the file content BLOB should be stored for
+ *                                            http(s) uploads
+ * @property {?Object|Array<Pair>} formFields - Additional form fields for multipart http(s) uploads
+ */
+
+/**
+ * Stop recording the screen.
+ * If no screen recording has been started before then the method returns an empty string.
+ *
+ * @param {?StopRecordingOptions} options - The available options.
+ * @returns {string} Base64-encoded content of the recorded media file if 'remotePath'
+ * parameter is falsy or an empty string.
+ * @throws {Error} If there was an error while getting the name of a media file
+ * or the file content cannot be uploaded to the remote location
+ * or screen recording is not supported on the device under test.
+ */
+commands.stopRecordingScreen = async function stopRecordingScreen (options = {}) {
+  if (!this._screenRecorder) {
+    log.info('No screen recording has been started. Doing nothing');
+    return '';
+  }
+
+  log.debug('Retrieving the resulting video data');
+  const videoPath = await this._screenRecorder.stop();
+  if (!videoPath) {
+    log.info('No video data is found. Returning an empty string');
+    return '';
+  }
+  return await uploadRecordedMedia(videoPath, options.remotePath, options);
+};
+
+export default commands;

package/lib/driver.js

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import { BaseDriver } from 'appium-base-driver';
+import { BaseDriver } from '@appium/base-driver';
 import log from './logger';
 import SafariDriverServer from './safari';
 import { desiredCapConstraints } from './desired-caps';
@@ -11,6 +11,8 @@ const NO_PROXY = [
   ['POST', new RegExp('^/session/[^/]+/appium')],
   ['POST', new RegExp('^/session/[^/]+/element/[^/]+/elements?$')],
   ['POST', new RegExp('^/session/[^/]+/elements?$')],
+
+  ['DELETE', new RegExp('^/session/[^/]+/cookie$')],
 ];
 
 class SafariDriver extends BaseDriver {
@@ -38,6 +40,7 @@ class SafariDriver extends BaseDriver {
     this.safari = null;
     this.proxyReqRes = null;
     this.isProxyActive = false;
+    this._screenRecorder = null;
   }
 
   proxyActive () {
@@ -68,7 +71,8 @@ class SafariDriver extends BaseDriver {
 
   async deleteSession () {
     log.info('Ending Safari session');
-    await this.safari.stop();
+    await this._screenRecorder?.stop(true);
+    await this.safari?.stop();
     this.resetState();
 
     await super.deleteSession();

package/lib/logger.js

@@ -1,4 +1,4 @@
-import { logger } from 'appium-support';
+import { logger } from '@appium/support';
 
 const log = logger.getLogger('Safari');
 

package/lib/safari.js

@@ -1,7 +1,7 @@
 import os from 'os';
 import path from 'path';
-import { JWProxy, errors } from 'appium-base-driver';
-import { fs, logger, util } from 'appium-support';
+import { JWProxy, errors } from '@appium/base-driver';
+import { fs, logger, util } from '@appium/support';
 import { SubProcess } from 'teen_process';
 import { waitForCondition } from 'asyncbox';
 import { findAPortNotInUse } from 'portscanner';

package/lib/server.js

@@ -1,5 +1,7 @@
 import log from './logger';
-import { server as baseServer, routeConfiguringFunction as makeRouter } from 'appium-base-driver';
+import {
+  server as baseServer, routeConfiguringFunction as makeRouter
+} from '@appium/base-driver';
 import SafariDriver from './driver';
 
 async function startServer (port, address) {