@aiot-nexus/plugin-sdk 1.1.0 → 2.0.0

package/dev-host/main.js

@@ -3,7 +3,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { app, BrowserWindow, ipcMain, protocol } = require("electron");
+const { app, BrowserWindow, ipcMain, protocol, utilityProcess } = require("electron");
 const sdk = require(path.join(__dirname, "..", "dist", "src", "index.js"));
 
 const pluginRendererProtocol = "nexus-plugin";
@@ -15,7 +15,7 @@ const ipcChannels = {
 const pluginPermissions = ["businessLog", "settings", "filesystem", "udp", "serial", "externalProcess", "dialog"];
 const implementedPermissions = new Set(["businessLog", "settings"]);
 const routeGuardPermissions = new Set(["filesystem", "udp", "serial", "dialog"]);
-const handlers = new Map();
+const workerProtocolVersion = 2;
 
 protocol.registerSchemesAsPrivileged([
   {
@@ -44,10 +44,13 @@ app.setName("Nexus Plugin Dev: " + configuration.manifest.pluginId);
 let mainWindow;
 let smokeTimeout;
 let smokeVerificationRunning = false;
+let pluginWorker;
+let workerShutdownStarted = false;
+let workerShutdownComplete = false;
 
-app.whenReady().then(function startDevHost() {
+app.whenReady().then(async function startDevHost() {
   registerPluginRendererProtocol();
-  activatePluginMain();
+  await startPluginWorker();
   registerIpcHandlers();
   createWindow();
 }).catch(failStartup);
@@ -56,6 +59,25 @@ app.on("window-all-closed", function quitAfterWindowClose() {
   app.quit();
 });
 
+app.on("before-quit", function waitForPluginWorkerShutdown(event) {
+  if (!pluginWorker || workerShutdownComplete) {
+    return;
+  }
+  event.preventDefault();
+  if (workerShutdownStarted) {
+    return;
+  }
+  workerShutdownStarted = true;
+  void pluginWorker.shutdown("quit")
+    .catch(function reportWorkerShutdownFailure(error) {
+      process.stderr.write("[nexus-plugin-dev] plugin worker shutdown failed: " + errorMessage(error) + "\n");
+    })
+    .finally(function finishPluginWorkerShutdown() {
+      workerShutdownComplete = true;
+      app.quit();
+    });
+});
+
 function loadConfiguration(args) {
   const packageDirectory = requiredPathArgument(args, "--plugin-package");
   const projectDirectory = requiredPathArgument(args, "--project-directory");
@@ -71,6 +93,7 @@ function loadConfiguration(args) {
   const language = requiredArgument(args, "--language");
   const themeMode = requiredArgument(args, "--theme");
   const hostVersion = requiredArgument(args, "--host-version");
+  const workerInspector = parseWorkerInspector(args);
   if (!isStrictVersion(hostVersion)) {
     throw new Error("--host-version must use X.Y.Z format.");
   }
@@ -90,6 +113,7 @@ function loadConfiguration(args) {
     language,
     themeMode,
     hostVersion,
+    workerInspector,
     openDevTools: !args.includes("--no-devtools"),
     smoke: args.includes("--smoke"),
     devDataDirectory,
@@ -156,114 +180,313 @@ function resolvePluginRendererFile(url) {
   });
 }
 
-function activatePluginMain() {
+async function startPluginWorker() {
   if (!configuration.manifest.mainEntry) {
     return;
   }
-  const mainEntryPath = path.resolve(configuration.packageDirectory, configuration.manifest.mainEntry);
-  const pluginModule = require(mainEntryPath);
-  const activate = typeof pluginModule.activate === "function"
-    ? pluginModule.activate
-    : pluginModule.default && typeof pluginModule.default.activate === "function"
-      ? pluginModule.default.activate
-      : undefined;
-  if (activate) {
-    activate({
-      pluginId: configuration.manifest.pluginId,
-      pluginDirectory: configuration.packageDirectory,
-      manifest: configuration.manifest,
-      host: createHostApi()
-    });
-  }
+  pluginWorker = new PluginWorkerClient(configuration);
+  const ready = await pluginWorker.start();
   process.stdout.write(
     "[nexus-plugin-dev] activated " + configuration.manifest.pluginId
-    + " with " + String(handlers.size) + " renderer operation(s).\n"
+    + " with " + String(ready.operations.length) + " renderer operation(s).\n"
   );
 }
 
-function createHostApi() {
-  const manifest = configuration.manifest;
-  return {
-    hostVersion: configuration.hostVersion,
-    hostApiVersion: sdk.PLUGIN_FRAMEWORK_VERSION,
-    pluginId: manifest.pluginId,
-    pluginDataDirectory: configuration.pluginDataDirectory,
-    hasPermission: function hasPermission(permission) {
-      return manifest.permissions.includes(permission);
-    },
-    registerRendererMethod: function registerRendererMethod(name, handler) {
-      if (!isSafeOperationName(name)) {
-        return fail("InvalidRequest", "Plugin renderer operation name is invalid.", { operation: name });
+class PluginWorkerClient {
+  constructor(workerConfiguration) {
+    this.configuration = workerConfiguration;
+    this.child = undefined;
+    this.pending = new Map();
+    this.startPromise = undefined;
+    this.startResolve = undefined;
+    this.startReject = undefined;
+    this.startTimer = undefined;
+    this.shutdownPromise = undefined;
+    this.shutdownResolve = undefined;
+    this.shutdownTimer = undefined;
+    this.initializationRequestId = undefined;
+    this.requestSequence = 0;
+    this.intentionalStop = false;
+    this.ready = false;
+  }
+
+  start() {
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    const startPromise = new Promise((resolve, reject) => {
+      this.startResolve = resolve;
+      this.startReject = reject;
+    });
+    this.startPromise = startPromise;
+    this.intentionalStop = false;
+    this.ready = false;
+    try {
+      this.child = utilityProcess.fork(path.join(__dirname, "plugin-host.js"), [], {
+        cwd: this.configuration.packageDirectory,
+        serviceName: "nexus-plugin-dev-" + this.configuration.manifest.pluginId,
+        stdio: this.configuration.workerInspector ? "inherit" : "ignore",
+        execArgv: this.configuration.workerInspector ? [this.configuration.workerInspector.execArg] : []
+      });
+      this.child.on("message", (message) => { void this.handleMessage(readWorkerMessage(message)); });
+      this.child.on("exit", (code) => this.handleExit(code));
+      if (!this.configuration.workerInspector || !this.configuration.workerInspector.breakOnStart) {
+        this.startTimer = setTimeout(() => {
+          this.failStart(new Error("Plugin worker activation timed out."));
+          this.kill();
+        }, 15_000);
       }
-      if (typeof handler !== "function") {
-        return fail("InvalidRequest", "Plugin renderer operation handler must be a function.", { operation: name });
+      const initializationRequestId = this.nextRequestId("initialize");
+      this.initializationRequestId = initializationRequestId;
+      this.post({
+        protocolVersion: workerProtocolVersion,
+        type: "initialize",
+        requestId: initializationRequestId,
+        payload: {
+          pluginId: this.configuration.manifest.pluginId,
+          pluginDirectory: this.configuration.packageDirectory,
+          pluginDataDirectory: this.configuration.pluginDataDirectory,
+          manifest: sanitizeJsonValue(this.configuration.manifest),
+          hostVersion: this.configuration.hostVersion,
+          hostApiVersion: sdk.PLUGIN_FRAMEWORK_VERSION
+        }
+      });
+    } catch (error) {
+      this.failStart(error);
+    }
+    return startPromise;
+  }
+
+  invoke(payload) {
+    if (!this.child || !this.ready) {
+      return Promise.resolve(fail("PluginWorkerNotReady", "Plugin worker is not ready."));
+    }
+    const requestId = this.nextRequestId("invoke");
+    return new Promise((resolve) => {
+      this.pending.set(requestId, { kind: "invoke", resolve });
+      try {
+        this.post({ protocolVersion: workerProtocolVersion, type: "invoke", requestId, payload });
+      } catch (error) {
+        this.pending.delete(requestId);
+        resolve(fail("PluginWorkerExited", "Plugin worker request could not be sent.", errorMessage(error)));
       }
-      if (handlers.has(name)) {
-        return fail("InvalidRequest", "Plugin renderer operation is already registered.", { operation: name });
+    });
+  }
+
+  shutdown(reason) {
+    this.intentionalStop = true;
+    if (!this.child) {
+      return Promise.resolve(ok(true));
+    }
+    if (this.shutdownPromise) {
+      return this.shutdownPromise;
+    }
+    const requestId = this.nextRequestId("shutdown");
+    this.shutdownPromise = new Promise((resolve) => {
+      this.shutdownResolve = resolve;
+      this.pending.set(requestId, { kind: "shutdown", resolve });
+      this.shutdownTimer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.shutdownResolve = undefined;
+        this.shutdownPromise = undefined;
+        const result = fail("PluginWorkerShutdownTimeout", "Plugin worker shutdown timed out.");
+        resolve(result);
+        this.kill();
+      }, 5000);
+      try {
+        this.post({ protocolVersion: workerProtocolVersion, type: "shutdown", requestId, payload: { reason: reason || "quit" } });
+      } catch (error) {
+        clearTimeout(this.shutdownTimer);
+        this.shutdownTimer = undefined;
+        this.pending.delete(requestId);
+        this.shutdownPromise = undefined;
+        resolve(fail("PluginWorkerExited", "Plugin worker shutdown could not be sent.", errorMessage(error)));
+        this.kill();
       }
-      handlers.set(name, handler);
-      return ok(true);
-    },
-    getCapabilityStatus: function getCapabilityStatus(permission) {
-      return isPluginPermission(permission)
-        ? ok(createPermissionSummary(permission))
-        : fail("InvalidRequest", "Plugin capability name is invalid.", { permission });
-    },
-    unsupportedCapability: function unsupportedCapability(permission, operation) {
-      return unsupportedCapability(manifest, permission, operation);
-    },
-    log: function log(level, message, exception) {
-      if (!manifest.permissions.includes("businessLog")) {
-        return fail("PluginPermissionDenied", "Plugin does not declare businessLog permission.");
+    });
+    return this.shutdownPromise;
+  }
+
+  async handleMessage(message) {
+    if (!isRecord(message) || message.protocolVersion !== workerProtocolVersion) {
+      this.handleProtocolViolation("Plugin worker sent an invalid RPC message.");
+      return;
+    }
+    if (message.type === "ready") {
+      if (!this.startPromise
+        || this.ready
+        || message.requestId !== this.initializationRequestId
+        || !isRecord(message.payload)
+        || !Array.isArray(message.payload.operations)
+        || !message.payload.operations.every(isSafeOperationName)
+        || new Set(message.payload.operations).size !== message.payload.operations.length
+        || typeof message.payload.activatedAtUtc !== "string"
+        || !message.payload.activatedAtUtc) {
+        this.handleProtocolViolation("Plugin worker ready response did not match initialization.");
+        return;
       }
-      return ok(appendLog(level, "plugin:" + manifest.pluginId, message, exception));
-    },
-    getSettings: function getSettings() {
-      return manifest.permissions.includes("settings")
-        ? ok(loadSettings())
-        : fail("PluginPermissionDenied", "Plugin does not declare settings permission.");
-    },
-    updateSettings: function updateSettings(values) {
-      if (!manifest.permissions.includes("settings")) {
-        return fail("PluginPermissionDenied", "Plugin does not declare settings permission.");
+      clearTimeout(this.startTimer);
+      this.startTimer = undefined;
+      this.initializationRequestId = undefined;
+      this.ready = true;
+      this.startResolve?.(message.payload);
+      this.startResolve = undefined;
+      this.startReject = undefined;
+      this.startPromise = undefined;
+      return;
+    }
+    if (message.type === "hostRequest") {
+      if (!isWorkerRequestId(message.requestId)) {
+        this.handleProtocolViolation("Plugin worker Host API request id is invalid.");
+        return;
       }
-      if (!isRecord(values)) {
-        return fail("InvalidRequest", "Plugin settings values must be an object.");
+      const result = await handlePluginHostRequest(this.configuration, message.payload);
+      try {
+        this.post({ protocolVersion: workerProtocolVersion, type: "hostResult", requestId: message.requestId, result });
+      } catch {
+        // The worker may have exited while a Host API request was running.
       }
-      return ok(saveSettings(values));
-    },
-    filesystem: createUnsupportedCapabilityApi(manifest, "filesystem"),
-    udp: createUnsupportedCapabilityApi(manifest, "udp"),
-    serial: createUnsupportedCapabilityApi(manifest, "serial"),
-    dialog: createUnsupportedCapabilityApi(manifest, "dialog"),
-    externalProcess: createUnsupportedCapabilityApi(manifest, "externalProcess")
-  };
-}
-
-function createUnsupportedCapabilityApi(manifest, permission) {
-  const target = {
-    permission,
-    supportState: permissionSupportState(permission),
-    describe: function describe() {
-      return ok(createPermissionSummary(permission));
-    },
-    unsupported: function unsupported(operation) {
-      return unsupportedCapability(manifest, permission, operation);
+      return;
     }
-  };
-  return new Proxy(target, {
-    get: function get(apiTarget, property) {
-      if (property in apiTarget) {
-        return Reflect.get(apiTarget, property);
+    if (message.type === "result") {
+      if (!isWorkerRequestId(message.requestId) || !isNexusResult(message.result)) {
+        this.handleProtocolViolation("Plugin worker result is invalid.");
+        return;
+      }
+      const pending = this.pending.get(message.requestId);
+      if (!pending) {
+        return;
       }
-      if (typeof property === "symbol" || property === "then") {
-        return undefined;
+      this.pending.delete(message.requestId);
+      if (pending.kind === "shutdown") {
+        clearTimeout(this.shutdownTimer);
+        this.shutdownTimer = undefined;
+        this.shutdownResolve = undefined;
+        this.shutdownPromise = undefined;
+        pending.resolve(message.result);
+        this.kill();
+        return;
       }
-      return function unsupportedOperation() {
-        return unsupportedCapability(manifest, permission, property);
-      };
+      pending.resolve(message.result);
+      return;
     }
-  });
+    if (message.type === "fatal") {
+      const error = new Error(isRecord(message.payload) && typeof message.payload.message === "string" ? message.payload.message : "Plugin worker failed.");
+      if (this.startPromise) {
+        this.failStart(error);
+      } else {
+        process.stderr.write("[nexus-plugin-dev] plugin worker failed: " + error.message + "\n");
+      }
+      this.kill();
+      return;
+    }
+    this.handleProtocolViolation("Plugin worker sent a message in the wrong direction.");
+  }
+
+  handleExit(code) {
+    this.child = undefined;
+    this.ready = false;
+    this.initializationRequestId = undefined;
+    clearTimeout(this.startTimer);
+    this.startTimer = undefined;
+    clearTimeout(this.shutdownTimer);
+    this.shutdownTimer = undefined;
+    this.shutdownPromise = undefined;
+    this.shutdownResolve = undefined;
+    const result = fail("PluginWorkerExited", "Plugin worker process exited.", { code });
+    if (this.startPromise) {
+      this.failStart(new Error(result.error.message));
+    }
+    for (const pending of this.pending.values()) {
+      pending.resolve(result);
+    }
+    this.pending.clear();
+    if (!this.intentionalStop) {
+      process.stderr.write("[nexus-plugin-dev] plugin worker exited with code " + String(code) + ".\n");
+    }
+  }
+
+  failStart(error) {
+    clearTimeout(this.startTimer);
+    this.startTimer = undefined;
+    this.initializationRequestId = undefined;
+    this.startReject?.(error instanceof Error ? error : new Error(String(error)));
+    this.startResolve = undefined;
+    this.startReject = undefined;
+    this.startPromise = undefined;
+  }
+
+  handleProtocolViolation(message) {
+    const error = new Error(message);
+    if (this.startPromise) {
+      this.failStart(error);
+    } else {
+      process.stderr.write("[nexus-plugin-dev] " + message + "\n");
+    }
+    this.kill();
+  }
+
+  post(message) {
+    if (!this.child) {
+      throw new Error("Plugin worker process has exited.");
+    }
+    this.child.postMessage(message);
+  }
+
+  kill() {
+    if (this.child) {
+      this.child.kill();
+    }
+  }
+
+  nextRequestId(kind) {
+    this.requestSequence += 1;
+    return this.configuration.manifest.pluginId + "-" + kind + "-" + String(this.requestSequence);
+  }
+}
+
+function readWorkerMessage(message) {
+  return isRecord(message) && Object.prototype.hasOwnProperty.call(message, "data") ? message.data : message;
+}
+
+async function handlePluginHostRequest(workerConfiguration, request) {
+  if (!isRecord(request) || typeof request.method !== "string") {
+    return fail("InvalidRequest", "Plugin Host API request is invalid.");
+  }
+  const manifest = workerConfiguration.manifest;
+  const params = isRecord(request.params) ? request.params : undefined;
+  if (request.method === "getCapabilityStatus") {
+    return isPluginPermission(params && params.permission)
+      ? ok(createPermissionSummary(params.permission))
+      : fail("InvalidRequest", "Plugin capability name is invalid.");
+  }
+  if (request.method === "unsupportedCapability") {
+    return unsupportedCapability(manifest, params && params.permission, params && params.operation);
+  }
+  if (request.method === "log") {
+    if (!manifest.permissions.includes("businessLog")) {
+      return fail("PluginPermissionDenied", "Plugin does not declare businessLog permission.");
+    }
+    if (!params || (params.level !== "info" && params.level !== "warn" && params.level !== "error") || typeof params.message !== "string" || !params.message.trim()) {
+      return fail("InvalidRequest", "Plugin log request is invalid.");
+    }
+    return ok(appendLog(params.level, "plugin:" + manifest.pluginId, params.message.trim(), typeof params.exception === "string" ? params.exception : undefined));
+  }
+  if (request.method === "getSettings") {
+    return manifest.permissions.includes("settings")
+      ? ok(loadSettings())
+      : fail("PluginPermissionDenied", "Plugin does not declare settings permission.");
+  }
+  if (request.method === "updateSettings") {
+    if (!manifest.permissions.includes("settings")) {
+      return fail("PluginPermissionDenied", "Plugin does not declare settings permission.");
+    }
+    if (!params || !isRecord(params.values)) {
+      return fail("InvalidRequest", "Plugin settings values must be an object.");
+    }
+    return ok(saveSettings(params.values));
+  }
+  return fail("InvalidRequest", "Plugin Host API method is invalid.", { method: request.method });
 }
 
 function unsupportedCapability(manifest, permission, operation) {
@@ -303,12 +526,13 @@ function registerIpcHandlers() {
         clearTimeout(smokeTimeout);
         process.stdout.write("[nexus-plugin-dev] renderer context synchronization smoke passed.\n");
         setTimeout(function exitAfterSmokeSettles() {
-          app.exit(0);
+          app.quit();
         }, 100);
       }).catch(function reportSmokeFailure(error) {
         clearTimeout(smokeTimeout);
         process.stderr.write("[nexus-plugin-dev] renderer context synchronization smoke failed: " + errorMessage(error) + "\n");
-        app.exit(1);
+        process.exitCode = 1;
+        app.quit();
       });
     }
   });
@@ -322,9 +546,8 @@ async function verifyRendererContextSmoke() {
   if (!frame) {
     throw new Error("Plugin renderer frame was not found.");
   }
-  const hostApi = createHostApi();
-  if (hostApi.hostVersion !== configuration.hostVersion
-    || hostApi.hostApiVersion !== sdk.PLUGIN_FRAMEWORK_VERSION
+  if (configuration.manifest.hostApiVersion !== sdk.PLUGIN_FRAMEWORK_VERSION
+    || (configuration.manifest.mainEntry && !pluginWorker)
     || configuration.manifest.minHostVersion === undefined) {
     throw new Error("Development Host API version contract is inconsistent.");
   }
@@ -410,7 +633,7 @@ function createRendererConfiguration() {
   };
 }
 
-function invokeRendererRequest(request) {
+async function invokeRendererRequest(request) {
   if (!isRecord(request) || typeof request.method !== "string") {
     return fail("InvalidRequest", "Plugin renderer request is invalid.");
   }
@@ -450,7 +673,7 @@ function invokeRendererRequest(request) {
   return fail("InvalidRequest", "Plugin renderer request method is invalid.", { method: request.method });
 }
 
-function invokeMain(params) {
+async function invokeMain(params) {
   if (!params || typeof params.operation !== "string") {
     return fail("InvalidRequest", "Plugin renderer invokeMain request requires an operation name.");
   }
@@ -460,40 +683,15 @@ function invokeMain(params) {
   if (!isSafeOperationName(params.operation)) {
     return fail("InvalidRequest", "Plugin renderer operation name is invalid.", { operation: params.operation });
   }
-  const handler = handlers.get(params.operation);
-  if (!handler) {
-    return fail("NotFound", "Plugin renderer operation was not registered.", { operation: params.operation });
+  if (!pluginWorker) {
+    return fail("PluginCapabilityUnsupported", "Plugin mainEntry is not available in this debug target.", { operation: params.operation });
   }
-  try {
-    const value = handler({
-      pluginId: configuration.manifest.pluginId,
-      surface: configuration.surface,
-      contributionId: configuration.contributionId,
-      operation: params.operation,
-      input: isRecord(params.input) ? params.input : undefined
-    });
-    return normalizeRendererOperationResult(value);
-  } catch (error) {
-    process.stderr.write("[nexus-plugin-dev] operation failed: " + params.operation + ": " + errorMessage(error) + "\n");
-    return fail("UnexpectedFailure", "Plugin renderer operation failed.", {
-      operation: params.operation,
-      message: errorMessage(error)
-    });
-  }
-}
-
-function normalizeRendererOperationResult(value) {
-  if (isNexusResult(value)) {
-    if (value.ok) {
-      return ok(sanitizeJsonValue(value.value));
-    }
-    return fail(
-      value.error.code,
-      value.error.message,
-      value.error.details === undefined ? undefined : sanitizeJsonValue(value.error.details)
-    );
-  }
-  return ok(sanitizeJsonValue(value));
+  return pluginWorker.invoke({
+    surface: configuration.surface,
+    contributionId: configuration.contributionId,
+    operation: params.operation,
+    input: isRecord(params.input) ? sanitizeJsonValue(params.input) : undefined
+  });
 }
 
 function createWindow() {
@@ -520,13 +718,13 @@ function createWindow() {
       "[nexus-plugin-dev] load failed: " + String(errorCode) + " " + errorDescription + " " + validatedUrl + "\n"
     );
     if (configuration.smoke && isMainFrame) {
-      app.exit(1);
+      failAndQuit(1);
     }
   });
   mainWindow.webContents.on("render-process-gone", function reportRendererExit(_event, details) {
     process.stderr.write("[nexus-plugin-dev] renderer process exited: " + details.reason + "\n");
     if (configuration.smoke) {
-      app.exit(1);
+      failAndQuit(1);
     }
   });
   mainWindow.on("closed", function clearWindow() {
@@ -541,7 +739,7 @@ function createWindow() {
   if (configuration.smoke) {
     smokeTimeout = setTimeout(function failSmokeTimeout() {
       process.stderr.write("[nexus-plugin-dev] renderer context synchronization smoke timed out.\n");
-      app.exit(1);
+      failAndQuit(1);
     }, 15000);
   }
 }
@@ -652,6 +850,13 @@ function isNexusResult(value) {
     : isRecord(value.error) && typeof value.error.code === "string" && typeof value.error.message === "string";
 }
 
+function isWorkerRequestId(value) {
+  return typeof value === "string"
+    && value.length > 0
+    && value.length <= 128
+    && /^[A-Za-z0-9._:-]+$/.test(value);
+}
+
 function isPluginPermission(value) {
   return typeof value === "string" && pluginPermissions.includes(value);
 }
@@ -750,6 +955,28 @@ function isStrictVersion(value) {
   }));
 }
 
+function parseWorkerInspector(args) {
+  const prefix = "--worker-inspector=";
+  const matches = args.filter(function isWorkerInspectorArgument(value) {
+    return value.startsWith(prefix);
+  });
+  if (matches.length > 1) {
+    throw new Error("--worker-inspector must not be repeated.");
+  }
+  if (matches.length === 0) {
+    return undefined;
+  }
+  const match = /^(inspect|inspect-brk):([0-9]+)$/.exec(matches[0].slice(prefix.length));
+  const port = match ? Number(match[2]) : 0;
+  if (!match || !Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("--worker-inspector must use inspect:<port> or inspect-brk:<port>.");
+  }
+  return {
+    execArg: "--" + match[1] + "=" + String(port),
+    breakOnStart: match[1] === "inspect-brk"
+  };
+}
+
 function requiredArgument(args, name) {
   const prefix = name + "=";
   const argument = args.find(function findArgument(value) {
@@ -776,7 +1003,12 @@ function fail(code, message, details) {
 function failStartup(error) {
   clearTimeout(smokeTimeout);
   process.stderr.write("[nexus-plugin-dev] startup failed: " + errorMessage(error) + "\n");
-  app.exit(1);
+  failAndQuit(1);
+}
+
+function failAndQuit(code) {
+  process.exitCode = code;
+  app.quit();
 }
 
 function errorMessage(error) {