@appium/base-driver 10.5.2 → 10.7.0

package/lib/express/server.ts

@@ -1,10 +1,8 @@
-import _ from 'lodash';
-import path from 'node:path';
 import express from 'express';
 import type {Express, RequestHandler} from 'express';
 import http from 'node:http';
 import type {Server as HttpServer} from 'node:http';
-import favicon from 'serve-favicon';
+import {createRequire} from 'node:module';
 import bodyParser from 'body-parser';
 import methodOverride from 'method-override';
 import {log} from './logger';
@@ -20,21 +18,15 @@ import {
   catch404Handler,
   handleLogContext,
 } from './middleware';
-import {
-  guineaPig,
-  guineaPigScrollable,
-  guineaPigAppBanner,
-  welcome,
-  STATIC_DIR,
-} from './static';
-import {produceError, produceCrash} from './crash';
+// Import env helper directly — not from the test-pages barrel — so Express handlers and
+// fixture code stay unloaded unless APPIUM_ENABLE_LEGACY_TEST_PAGES is set.
+import {isLegacyTestPagesEnabled} from '../test-pages/env';
 import {
   addWebSocketHandler,
   removeWebSocketHandler,
   removeAllWebSocketHandlers,
   getWebSocketHandlers,
 } from './websocket';
-import B from 'bluebird';
 import {DEFAULT_BASE_PATH} from '../constants';
 import {fs, timing} from '@appium/support';
 import type {
@@ -55,10 +47,7 @@ export interface RouteConfiguringFunctionOpts {
 }
 
 /** A function which configures routes */
-export type RouteConfiguringFunction = (
-  app: Express,
-  opts?: RouteConfiguringFunctionOpts
-) => void;
+export type RouteConfiguringFunction = (app: Express, opts?: RouteConfiguringFunctionOpts) => void;
 
 /** Options for {@linkcode server} */
 export interface ServerOpts {
@@ -85,6 +74,12 @@ export interface ConfigureServerOpts {
   useLegacyUpgradeHandler?: boolean;
 }
 
+/** @internal */
+export interface ConfigureServerInternalOpts extends ConfigureServerOpts {
+  /** @deprecated Appium 4 */
+  registerTestPages?: (app: Express, opts: {basePath: string}) => void;
+}
+
 /** Options for {@linkcode configureHttp} */
 export interface ConfigureHttpOpts {
   httpServer: HttpServer;
@@ -123,51 +118,57 @@ export async function server(opts: ServerOpts): Promise<AppiumServer> {
   const app = express();
   const httpServer = await createServer(app, cliArgs);
 
-  return await new B<AppiumServer>(async (resolve, reject) => {
-    // we put an async function as the promise constructor because we want some things to happen in
-    // serial (application of plugin updates, for example). But we still need to use a promise here
-    // because some elements of server start failure only happen in httpServer listeners. So the
-    // way we resolve it is to use an async function here but to wrap all the inner logic in
-    // try/catch so any errors can be passed to reject.
-    try {
-      const appiumServer = configureHttp({
-        httpServer,
-        reject,
-        keepAliveTimeout,
-        gracefulShutdownTimeout: cliArgs.shutdownTimeout,
-      });
-      const useLegacyUpgradeHandler = !hasShouldUpgradeCallback(httpServer);
-      configureServer({
-        app,
-        addRoutes: routeConfiguringFunction,
-        allowCors,
-        basePath,
-        extraMethodMap,
-        webSocketsMapping: appiumServer.webSocketsMapping,
-        useLegacyUpgradeHandler,
-      });
-      // allow extensions to update the app and http server objects
-      for (const updater of serverUpdaters) {
-        await updater(app, appiumServer, cliArgs);
-      }
-
-      // once all configurations and updaters have been applied, make sure to set up a catchall
-      // handler so that anything unknown 404s. But do this after everything else since we don't
-      // want to block extensions' ability to add routes if they want.
-      app.all('/*all', catch404Handler);
-
-      await startServer({
-        httpServer,
-        hostname,
-        port,
-        keepAliveTimeout,
-        requestTimeout,
-      });
+  return await new Promise<AppiumServer>((resolve, reject) => {
+    // we use a promise here because some elements of server start failure only happen in
+    // httpServer listeners. The async IIFE runs setup serially (e.g. plugin updates) while
+    // configureHttp can still reject via the listener registered below.
+    void (async () => {
+      try {
+        const appiumServer = configureHttp({
+          httpServer,
+          reject,
+          keepAliveTimeout,
+          gracefulShutdownTimeout: cliArgs.shutdownTimeout,
+        });
+        const useLegacyUpgradeHandler = !hasShouldUpgradeCallback(httpServer);
+        let registerTestPages: ConfigureServerInternalOpts['registerTestPages'];
+        if (isLegacyTestPagesEnabled()) {
+          const require = createRequire(__filename);
+          registerTestPages = require('../test-pages').registerTestPages;
+        }
+        configureServer({
+          app,
+          addRoutes: routeConfiguringFunction,
+          allowCors,
+          basePath,
+          extraMethodMap,
+          webSocketsMapping: appiumServer.webSocketsMapping,
+          useLegacyUpgradeHandler,
+          registerTestPages,
+        } as ConfigureServerInternalOpts);
+        // allow extensions to update the app and http server objects
+        for (const updater of serverUpdaters) {
+          await updater(app, appiumServer, cliArgs);
+        }
 
-      resolve(appiumServer);
-    } catch (err) {
-      reject(err);
-    }
+        // once all configurations and updaters have been applied, make sure to set up a catchall
+        // handler so that anything unknown 404s. But do this after everything else since we don't
+        // want to block extensions' ability to add routes if they want.
+        app.all('/*all', catch404Handler);
+
+        await startServer({
+          httpServer,
+          hostname,
+          port,
+          keepAliveTimeout,
+          requestTimeout,
+        });
+
+        resolve(appiumServer);
+      } catch (err) {
+        reject(err);
+      }
+    })();
   });
 }
 
@@ -176,27 +177,25 @@ export async function server(opts: ServerOpts): Promise<AppiumServer> {
  *
  * @param opts - Configuration options
  */
-export function configureServer({
-  app,
-  addRoutes,
-  allowCors = true,
-  basePath = DEFAULT_BASE_PATH,
-  extraMethodMap = {},
-  webSocketsMapping = {},
-  useLegacyUpgradeHandler = true,
-}: ConfigureServerOpts): void {
-  basePath = normalizeBasePath(basePath);
+export function configureServer(opts: ConfigureServerOpts): void {
+  const {
+    app,
+    addRoutes,
+    allowCors = true,
+    basePath: rawBasePath = DEFAULT_BASE_PATH,
+    extraMethodMap = {},
+    webSocketsMapping = {},
+    useLegacyUpgradeHandler = true,
+  } = opts;
+  const {registerTestPages} = opts as ConfigureServerInternalOpts;
+  const basePath = normalizeBasePath(rawBasePath);
 
   app.use(endLogFormatter);
   app.use(handleLogContext);
 
-  // set up static assets
-  app.use(favicon(path.resolve(STATIC_DIR, 'favicon.ico')));
-  app.use(express.static(STATIC_DIR));
-
-  // crash routes, for testing
-  app.use(`${basePath}/produce_error`, produceError);
-  app.use(`${basePath}/crash`, produceCrash);
+  if (registerTestPages) {
+    registerTestPages(app, {basePath});
+  }
 
   // Only use legacy Express middleware for WebSocket upgrades if shouldUpgradeCallback is not available.
   // When shouldUpgradeCallback is available, upgrades are handled directly on the HTTP server
@@ -222,12 +221,6 @@ export function configureServer({
   app.use(startLogFormatter);
 
   addRoutes(app, {basePath, extraMethodMap});
-
-  // dynamic routes for testing, etc.
-  app.all('/welcome', welcome);
-  app.all('/test/guinea-pig', guineaPig);
-  app.all('/test/guinea-pig-scrollable', guineaPigScrollable);
-  app.all('/test/guinea-pig-app-banner', guineaPigAppBanner);
 }
 
 /**
@@ -237,7 +230,7 @@ export function configureServer({
  * @returns Normalized base path
  */
 export function normalizeBasePath(basePath: string): string {
-  if (!_.isString(basePath)) {
+  if (typeof basePath !== 'string') {
     throw new Error(`Invalid path prefix ${basePath}`);
   }
 
@@ -253,42 +246,35 @@ export function normalizeBasePath(basePath: string): string {
   return basePath;
 }
 
-async function createServer(
-  app: Express,
-  cliArgs?: Partial<ServerArgs>
-): Promise<HttpServer> {
+async function createServer(app: Express, cliArgs?: Partial<ServerArgs>): Promise<HttpServer> {
   const {sslCertificatePath, sslKeyPath} = cliArgs ?? {};
   if (!sslCertificatePath && !sslKeyPath) {
     return http.createServer(app);
   }
   if (!sslCertificatePath || !sslKeyPath) {
-    throw new Error(
-      `Both certificate path and key path must be provided to enable TLS`
-    );
+    throw new Error(`Both certificate path and key path must be provided to enable TLS`);
   }
 
   const certKey = [sslCertificatePath, sslKeyPath];
-  const zipped = _.zip(
-    await B.all(certKey.map((p) => fs.exists(p))),
-    ['certificate', 'key'],
-    certKey
-  ) as [boolean, string, string][];
-  for (const [exists, desc, p] of zipped) {
+  const [certExists, keyExists] = await Promise.all(certKey.map((p) => fs.exists(p)));
+  for (const [exists, desc, p] of [
+    [certExists, 'certificate', sslCertificatePath],
+    [keyExists, 'key', sslKeyPath],
+  ]) {
     if (!exists) {
-      throw new Error(
-        `The provided SSL ${desc} at '${p}' does not exist or is not accessible`
-      );
+      throw new Error(`The provided SSL ${desc} at '${p}' does not exist or is not accessible`);
     }
   }
-  const [cert, key] = await B.all(
-    certKey.map((p) => fs.readFile(p, 'utf8'))
-  ) as [string, string];
+  const [cert, key] = (await Promise.all(certKey.map((p) => fs.readFile(p, 'utf8')))) as [
+    string,
+    string,
+  ];
   log.debug('Enabling TLS/SPDY on the server using the provided certificate');
 
   const spdy = require('spdy') as {
     createServer: (
       options: {cert: string; key: string; spdy: {plain: boolean; ssl: boolean}},
-      requestListener: RequestHandler
+      requestListener: RequestHandler,
     ) => HttpServer;
   };
   return spdy.createServer(
@@ -300,7 +286,7 @@ async function createServer(
         ssl: true,
       },
     },
-    app
+    app,
   );
 }
 
@@ -332,8 +318,10 @@ function configureHttp({
   // See: https://github.com/nodejs/node/pull/59824
   if (hasShouldUpgradeCallback(httpServer)) {
     // shouldUpgradeCallback only returns a boolean to indicate if the upgrade should proceed
-    (appiumServer as unknown as {shouldUpgradeCallback?: (req: http.IncomingMessage) => boolean}).shouldUpgradeCallback = (req) =>
-      _.toLower(req.headers?.upgrade) === 'websocket';
+    (
+      appiumServer as unknown as {shouldUpgradeCallback?: (req: http.IncomingMessage) => boolean}
+    ).shouldUpgradeCallback = (req) =>
+      String(req.headers?.upgrade ?? '').toLowerCase() === 'websocket';
     appiumServer.on('upgrade', (req, socket, head) => {
       if (!tryHandleWebSocketUpgrade(req, socket, head, appiumServer.webSocketsMapping)) {
         socket.destroy();
@@ -343,9 +331,11 @@ function configureHttp({
 
   // http.Server.close() only stops new connections, but we need to wait until
   // all connections are closed and the `close` event is emitted
-  const originalClose = appiumServer.close.bind(appiumServer);
+  const originalClose = appiumServer.close.bind(appiumServer) as (
+    callback?: (err?: Error | null) => void,
+  ) => void;
   appiumServer.close = async () =>
-    await new B<void>((_resolve, _reject) => {
+    await new Promise<void>((_resolve, _reject) => {
       log.info('Closing Appium HTTP server');
       const timer = new timing.Timer().start();
       const onTimeout = setTimeout(() => {
@@ -353,7 +343,7 @@ function configureHttp({
           log.info(
             `Not all active connections have been closed within ${gracefulShutdownTimeout}ms. ` +
               `This timeout might be customized by the --shutdown-timeout command line ` +
-              `argument. Closing the server anyway.`
+              `argument. Closing the server anyway.`,
           );
         }
         process.exit(process.exitCode ?? 0);
@@ -361,13 +351,13 @@ function configureHttp({
       const onClose = () => {
         log.info(
           `Appium HTTP server has been successfully closed after ` +
-            `${timer.getDuration().asMilliSeconds.toFixed(0)}ms`
+            `${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
         );
         clearTimeout(onTimeout);
         _resolve();
       };
       httpServer.once('close', onClose);
-      originalClose((err?: Error) => {
+      originalClose((err?: Error | null) => {
         if (err) {
           clearTimeout(onTimeout);
           httpServer.removeListener('close', onClose);
@@ -379,14 +369,13 @@ function configureHttp({
   appiumServer.once('error', (err: NodeJS.ErrnoException) => {
     if (err.code === 'EADDRNOTAVAIL') {
       log.error(
-        'Could not start REST http interface listener. ' +
-          'Requested address is not available.'
+        'Could not start REST http interface listener. ' + 'Requested address is not available.',
       );
     } else {
       log.error(
         'Could not start REST http interface listener. The requested ' +
           'port may already be in use. Please make sure there is no ' +
-          'other instance of this server running already.'
+          'other instance of this server running already.',
       );
     }
     reject(err);
@@ -405,12 +394,21 @@ async function startServer({
   requestTimeout,
 }: StartServerOpts): Promise<void> {
   // If the hostname is omitted, the server will accept connections on any IP address
-  const start = B.promisify(httpServer.listen, {
-    context: httpServer,
-  }) as (port: number, hostname?: string) => B<HttpServer>;
-  const startPromise = start(port, hostname);
+  const startPromise = new Promise<void>((resolve, reject) => {
+    const onError = (err: Error) => {
+      httpServer.removeListener('listening', onListening);
+      reject(err);
+    };
+    const onListening = () => {
+      httpServer.removeListener('error', onError);
+      resolve();
+    };
+    httpServer.once('error', onError);
+    httpServer.once('listening', onListening);
+    httpServer.listen(port, hostname);
+  });
   httpServer.keepAliveTimeout = keepAliveTimeout;
-  if (_.isInteger(requestTimeout)) {
+  if (Number.isInteger(requestTimeout)) {
     httpServer.requestTimeout = Number(requestTimeout);
   }
   // headers timeout must be greater than keepAliveTimeout

package/lib/express/websocket.ts

@@ -1,5 +1,4 @@
-import _ from 'lodash';
-import B from 'bluebird';
+import {util} from '@appium/support';
 import type {AppiumServer, WSServer} from '@appium/types';
 
 export const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
@@ -11,7 +10,7 @@ export const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
 export async function addWebSocketHandler(
   this: AppiumServer,
   handlerPathname: string,
-  handlerServer: WSServer
+  handlerServer: WSServer,
 ): Promise<void> {
   this.webSocketsMapping[handlerPathname] = handlerServer;
 }
@@ -22,16 +21,16 @@ export async function addWebSocketHandler(
  */
 export async function getWebSocketHandlers(
   this: AppiumServer,
-  keysFilter: string | null = null
+  keysFilter: string | null = null,
 ): Promise<Record<string, WSServer>> {
-  return _.toPairs(this.webSocketsMapping).reduce<Record<string, WSServer>>(
+  return Object.entries(this.webSocketsMapping).reduce<Record<string, WSServer>>(
     (acc, [pathname, wsServer]) => {
-      if (!_.isString(keysFilter) || pathname.includes(keysFilter)) {
+      if (typeof keysFilter !== 'string' || pathname.includes(keysFilter)) {
         acc[pathname] = wsServer;
       }
       return acc;
     },
-    {}
+    {},
   );
 }
 
@@ -41,7 +40,7 @@ export async function getWebSocketHandlers(
  */
 export async function removeWebSocketHandler(
   this: AppiumServer,
-  handlerPathname: string
+  handlerPathname: string,
 ): Promise<boolean> {
   const wsServer = this.webSocketsMapping?.[handlerPathname];
   if (!wsServer) {
@@ -67,15 +66,12 @@ export async function removeWebSocketHandler(
  * @see AppiumServerExtension.removeAllWebSocketHandlers
  */
 export async function removeAllWebSocketHandlers(this: AppiumServer): Promise<boolean> {
-  if (_.isEmpty(this.webSocketsMapping)) {
+  if (util.isEmpty(this.webSocketsMapping)) {
     return false;
   }
 
-  return _.some(
-    await B.all(
-      _.keys(this.webSocketsMapping).map((pathname) =>
-        this.removeWebSocketHandler(pathname)
-      )
-    )
+  const results = await Promise.all(
+    Object.keys(this.webSocketsMapping).map((pathname) => this.removeWebSocketHandler(pathname)),
   );
+  return results.some(Boolean);
 }

package/lib/helpers/capabilities.ts

@@ -1,28 +1,28 @@
 import type {Constraints, W3CCapabilities, Capabilities, AppiumLogger} from '@appium/types';
-import _ from 'lodash';
+import {util} from '@appium/support';
 
 /**
  * Determine whether the given argument is valid
  * W3C capabilities instance.
  */
 export function isW3cCaps(caps: unknown): caps is W3CCapabilities<Constraints> {
-  if (!_.isPlainObject(caps)) {
+  if (!util.isPlainObject(caps)) {
     return false;
   }
 
   const c = caps as Record<string, unknown>;
   const isFirstMatchValid = () =>
-    _.isArray(c.firstMatch) &&
-    !_.isEmpty(c.firstMatch) &&
-    _.every(c.firstMatch, _.isPlainObject);
-  const isAlwaysMatchValid = () => _.isPlainObject(c.alwaysMatch);
-  if (_.has(c, 'firstMatch') && _.has(c, 'alwaysMatch')) {
+    Array.isArray(c.firstMatch) &&
+    !util.isEmpty(c.firstMatch) &&
+    c.firstMatch.every((item) => util.isPlainObject(item));
+  const isAlwaysMatchValid = () => util.isPlainObject(c.alwaysMatch);
+  if (Object.hasOwn(c, 'firstMatch') && Object.hasOwn(c, 'alwaysMatch')) {
     return isFirstMatchValid() && isAlwaysMatchValid();
   }
-  if (_.has(c, 'firstMatch')) {
+  if (Object.hasOwn(c, 'firstMatch')) {
     return isFirstMatchValid();
   }
-  if (_.has(c, 'alwaysMatch')) {
+  if (Object.hasOwn(c, 'alwaysMatch')) {
     return isAlwaysMatchValid();
   }
   return false;
@@ -34,18 +34,21 @@ export function isW3cCaps(caps: unknown): caps is W3CCapabilities<Constraints> {
 export function fixCaps<C extends Constraints>(
   oldCaps: Record<string, unknown>,
   desiredCapConstraints: C,
-  log: AppiumLogger
+  log: AppiumLogger,
 ): Capabilities<C> {
-  const caps = _.clone(oldCaps) as Record<string, unknown>;
+  const caps = {...oldCaps} as Record<string, unknown>;
 
-  const logCastWarning = (prefix: string) => log.warn(`${prefix}. This may cause unexpected behavior`);
+  const logCastWarning = (prefix: string) =>
+    log.warn(`${prefix}. This may cause unexpected behavior`);
 
   // boolean capabilities can be passed in as strings 'false' and 'true'
   // which we want to translate into boolean values
-  const booleanCaps = _.keys(_.pickBy(desiredCapConstraints, (k) => k.isBoolean === true));
+  const booleanCaps = Object.keys(desiredCapConstraints).filter(
+    (key) => desiredCapConstraints[key as keyof C]?.isBoolean === true,
+  );
   for (const cap of booleanCaps) {
     const value = oldCaps[cap];
-    if (!_.isString(value)) {
+    if (typeof value !== 'string') {
       continue;
     }
 
@@ -59,10 +62,12 @@ export function fixCaps<C extends Constraints>(
   }
 
   // int capabilities are often sent in as strings by frameworks
-  const intCaps = _.keys(_.pickBy(desiredCapConstraints, (k) => k.isNumber === true));
+  const intCaps = Object.keys(desiredCapConstraints).filter(
+    (key) => desiredCapConstraints[key as keyof C]?.isNumber === true,
+  );
   for (const cap of intCaps) {
     const value = oldCaps[cap];
-    if (!_.isString(value)) {
+    if (typeof value !== 'string') {
       continue;
     }
 

package/lib/helpers/extension-command-name.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {Constraints, Driver, DriverClass} from '@appium/types';
 import type {BaseDriver} from '../basedriver/driver';
 
@@ -11,12 +11,12 @@ import type {BaseDriver} from '../basedriver/driver';
  */
 export function resolveExecuteExtensionName<C extends Constraints>(
   this: BaseDriver<C>,
-  commandName: string
+  commandName: string,
 ): string {
   const Driver = this.constructor as DriverClass<Driver<C>>;
   const methodMap = Driver.executeMethodMap;
 
-  if (methodMap && _.isPlainObject(methodMap) && commandName in methodMap) {
+  if (methodMap && util.isPlainObject(methodMap) && commandName in methodMap) {
     const command = methodMap[commandName]?.command;
     if (typeof command === 'string') {
       return command;

package/lib/helpers/levenshtein-match.ts

@@ -1,6 +1,5 @@
 import type {StringRecord} from '@appium/types';
 import {distance} from 'fastest-levenshtein';
-import _ from 'lodash';
 
 /**
  * Inclusive maximum Levenshtein edit distance for offering a "did you mean" hint.
@@ -30,24 +29,31 @@ export function rankLevenshteinCandidates(
 
   const matchesMap: StringRecord<string[]> = candidates
     .map((name) => [distance(target, name), name] as const)
-    .reduce((acc, [dist, name]) => {
-      const key = String(dist);
-      if (key in acc) {
-        acc[key].push(name);
-      } else {
-        acc[key] = [name];
-      }
-      return acc;
-    }, {});
-  const sortedDistanceKeys = _.keys(matchesMap).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
-  const sorted = _.flatten(
-    sortedDistanceKeys.map((k) => (matchesMap[k] ?? []).sort()),
+    .reduce(
+      (acc, [dist, name]) => {
+        const key = String(dist);
+        if (key in acc) {
+          acc[key].push(name);
+        } else {
+          acc[key] = [name];
+        }
+        return acc;
+      },
+      {} as StringRecord<string[]>,
+    );
+  const sortedDistanceKeys = Object.keys(matchesMap).sort(
+    (a, b) => parseInt(a, 10) - parseInt(b, 10),
   );
+  const sorted = sortedDistanceKeys.flatMap((k) => (matchesMap[k] ?? []).sort());
 
   const best = sorted[0];
   const firstDistanceKey = sortedDistanceKeys[0];
   const minDist = firstDistanceKey !== undefined ? parseInt(firstDistanceKey, 10) : NaN;
-  const suggestion = maxEditDistance >= 0 && best !== undefined && !Number.isNaN(minDist) && minDist <= maxEditDistance
+  const suggestion =
+    maxEditDistance >= 0 &&
+    best !== undefined &&
+    !Number.isNaN(minDist) &&
+    minDist <= maxEditDistance
       ? best
       : undefined;
   return {sorted, suggestion};

package/lib/index.js

@@ -1,19 +1,9 @@
-import B from 'bluebird';
-
-try {
-  B.config({
-    cancellation: true,
-  });
-} catch {
-  // sometimes during testing this somehow gets required twice and results in an error about
-  // cancellation not being able to be enabled after promise has been configured
-}
-
 // BaseDriver exports
 export {ExtensionCore} from './basedriver/extension-core';
 import {BaseDriver} from './basedriver/driver';
 export {DriverCore} from './basedriver/core';
 export {DeviceSettings} from './basedriver/device-settings';
+export {AppiumIpc} from './basedriver/ipc';
 
 export {BaseDriver};
 export default BaseDriver;
@@ -24,7 +14,8 @@ export * from './protocol';
 export {errorFromMJSONWPStatusCode as errorFromCode} from './protocol';
 
 // Express exports
-export {STATIC_DIR} from './express/static';
+/** @deprecated Removed in Appium 4. Use hard-copied test fixtures in driver CI instead. */
+export {TEST_FIXTURES_DIR as STATIC_DIR} from './test-pages';
 export {server, normalizeBasePath} from './express/server';
 
 // jsonwp-proxy exports