@openfn/ws-worker 0.8.1 → 1.1.0

package/dist/start.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -6,6 +8,110 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw new Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+
+// package.json
+var package_exports = {};
+__export(package_exports, {
+  author: () => author,
+  bin: () => bin,
+  default: () => package_default,
+  dependencies: () => dependencies,
+  description: () => description,
+  devDependencies: () => devDependencies,
+  files: () => files,
+  license: () => license,
+  main: () => main,
+  name: () => name,
+  scripts: () => scripts,
+  type: () => type,
+  version: () => version
+});
+var name, version, description, main, type, scripts, bin, author, license, dependencies, devDependencies, files, package_default;
+var init_package = __esm({
+  "package.json"() {
+    name = "@openfn/ws-worker";
+    version = "1.1.0";
+    description = "A Websocket Worker to connect Lightning to a Runtime Engine";
+    main = "dist/index.js";
+    type = "module";
+    scripts = {
+      test: "pnpm ava --serial",
+      "test:types": "pnpm tsc --noEmit --project tsconfig.json",
+      build: "tsup --config tsup.config.js",
+      "build:watch": "pnpm build --watch",
+      start: "ts-node-esm --transpile-only src/start.ts",
+      "start:prod": "node dist/start.js",
+      "start:watch": "nodemon -e ts,js --watch ../runtime-manager/dist --watch ./src --exec 'pnpm start'",
+      pack: "pnpm pack --pack-destination ../../dist"
+    };
+    bin = {
+      worker: "dist/start.js"
+    };
+    author = "Open Function Group <admin@openfn.org>";
+    license = "ISC";
+    dependencies = {
+      "@koa/router": "^12.0.0",
+      "@openfn/engine-multi": "workspace:*",
+      "@openfn/lexicon": "workspace:^",
+      "@openfn/logger": "workspace:*",
+      "@openfn/runtime": "workspace:*",
+      "@types/koa-logger": "^3.1.2",
+      "@types/ws": "^8.5.6",
+      "fast-safe-stringify": "^2.1.1",
+      figures: "^5.0.0",
+      "human-id": "^4.1.0",
+      jose: "^4.14.6",
+      koa: "^2.13.4",
+      "koa-bodyparser": "^4.4.0",
+      "koa-logger": "^3.2.1",
+      phoenix: "1.7.10",
+      ws: "^8.14.1"
+    };
+    devDependencies = {
+      "@openfn/lightning-mock": "workspace:*",
+      "@types/koa": "^2.13.5",
+      "@types/koa-bodyparser": "^4.3.10",
+      "@types/koa__router": "^12.0.1",
+      "@types/node": "^18.15.3",
+      "@types/nodemon": "1.19.3",
+      "@types/phoenix": "^1.6.2",
+      "@types/yargs": "^17.0.12",
+      ava: "5.1.0",
+      nodemon: "3.0.1",
+      "ts-node": "^10.9.1",
+      tslib: "^2.4.0",
+      tsup: "^6.2.3",
+      typescript: "^4.6.4",
+      yargs: "^17.6.2"
+    };
+    files = [
+      "dist",
+      "README.md",
+      "CHANGELOG.md"
+    ];
+    package_default = {
+      name,
+      version,
+      description,
+      main,
+      type,
+      scripts,
+      bin,
+      author,
+      license,
+      dependencies,
+      devDependencies,
+      files
+    };
+  }
+});
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/lib/platform-shims/esm.mjs
 import { notStrictEqual, strictEqual } from "assert";
@@ -1167,26 +1273,26 @@ var YargsParser = class {
         return defaultForType(guessType2(key));
       }
     }
-    function defaultForType(type) {
+    function defaultForType(type2) {
       const def = {
         [DefaultValuesForTypeKey.BOOLEAN]: true,
         [DefaultValuesForTypeKey.STRING]: "",
         [DefaultValuesForTypeKey.NUMBER]: void 0,
         [DefaultValuesForTypeKey.ARRAY]: []
       };
-      return def[type];
+      return def[type2];
     }
     function guessType2(key) {
-      let type = DefaultValuesForTypeKey.BOOLEAN;
+      let type2 = DefaultValuesForTypeKey.BOOLEAN;
       if (checkAllAliases(key, flags.strings))
-        type = DefaultValuesForTypeKey.STRING;
+        type2 = DefaultValuesForTypeKey.STRING;
       else if (checkAllAliases(key, flags.numbers))
-        type = DefaultValuesForTypeKey.NUMBER;
+        type2 = DefaultValuesForTypeKey.NUMBER;
       else if (checkAllAliases(key, flags.bools))
-        type = DefaultValuesForTypeKey.BOOLEAN;
+        type2 = DefaultValuesForTypeKey.BOOLEAN;
       else if (checkAllAliases(key, flags.arrays))
-        type = DefaultValuesForTypeKey.ARRAY;
-      return type;
+        type2 = DefaultValuesForTypeKey.ARRAY;
+      return type2;
     }
     function isUndefined(num) {
       return num === void 0;
@@ -1560,7 +1666,7 @@ var esm_default = {
   process: {
     argv: () => process.argv,
     cwd: process.cwd,
-    emitWarning: (warning, type) => process.emitWarning(warning, type),
+    emitWarning: (warning, type2) => process.emitWarning(warning, type2),
     execPath: () => process.execPath,
     exit: process.exit,
     nextTick: process.nextTick,
@@ -1658,7 +1764,7 @@ function argsert(arg1, arg2, arg3) {
     parsed.demanded.forEach((demanded) => {
       const arg = args2.shift();
       const observedType = guessType(arg);
-      const matchingTypes = demanded.cmd.filter((type) => type === observedType || type === "*");
+      const matchingTypes = demanded.cmd.filter((type2) => type2 === observedType || type2 === "*");
       if (matchingTypes.length === 0)
         argumentTypeError(observedType, demanded.cmd, position);
       position += 1;
@@ -1668,7 +1774,7 @@ function argsert(arg1, arg2, arg3) {
         return;
       const arg = args2.shift();
       const observedType = guessType(arg);
-      const matchingTypes = optional.cmd.filter((type) => type === observedType || type === "*");
+      const matchingTypes = optional.cmd.filter((type2) => type2 === observedType || type2 === "*");
       if (matchingTypes.length === 0)
         argumentTypeError(observedType, optional.cmd, position);
       position += 1;
@@ -1790,8 +1896,8 @@ function isFunction(arg) {
 function whichModule(exported) {
   if (typeof __require === "undefined")
     return null;
-  for (let i = 0, files = Object.keys(__require.cache), mod; i < files.length; i++) {
-    mod = __require.cache[files[i]];
+  for (let i = 0, files2 = Object.keys(__require.cache), mod; i < files2.length; i++) {
+    mod = __require.cache[files2[i]];
     if (mod.exports === exported)
       return mod;
   }
@@ -1831,7 +1937,7 @@ var CommandInstance = class {
     };
     this.shim.requireDirectory({ require: req, filename: callerFile }, dir, opts);
   }
-  addHandler(cmd, description, builder, handler, commandMiddleware, deprecated) {
+  addHandler(cmd, description2, builder, handler, commandMiddleware, deprecated) {
     let aliases = [];
     const middlewares = commandMiddlewareFactory(commandMiddleware);
     handler = handler || (() => {
@@ -1851,7 +1957,7 @@ var CommandInstance = class {
       this.addHandler(command2, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
       return;
     } else if (isCommandBuilderDefinition(builder)) {
-      this.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
+      this.addHandler([cmd].concat(aliases), description2, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
       return;
     }
     if (typeof cmd === "string") {
@@ -1875,12 +1981,12 @@ var CommandInstance = class {
       aliases.forEach((alias) => {
         this.aliasMap[alias] = parsedCommand.cmd;
       });
-      if (description !== false) {
-        this.usage.command(cmd, description, isDefault, aliases, deprecated);
+      if (description2 !== false) {
+        this.usage.command(cmd, description2, isDefault, aliases, deprecated);
       }
       this.handlers[parsedCommand.cmd] = {
         original: cmd,
-        description,
+        description: description2,
         handler,
         builder: builder || {},
         middlewares,
@@ -2139,8 +2245,8 @@ var CommandInstance = class {
   commandFromFilename(filename) {
     return this.shim.path.basename(filename, this.shim.path.extname(filename));
   }
-  extractDesc({ describe, description, desc }) {
-    for (const test of [describe, description, desc]) {
+  extractDesc({ describe, description: description2, desc }) {
+    for (const test of [describe, description2, desc]) {
       if (typeof test === "string" || test === false)
         return test;
       assertNotStrictEqual(test, true, this.shim);
@@ -2281,14 +2387,14 @@ function usage(yargs, shim3) {
   };
   let usages = [];
   let usageDisabled = false;
-  self.usage = (msg, description) => {
+  self.usage = (msg, description2) => {
     if (msg === null) {
       usageDisabled = true;
       usages = [];
       return self;
     }
     usageDisabled = false;
-    usages.push([msg, description || ""]);
+    usages.push([msg, description2 || ""]);
     return self;
   };
   self.getUsage = () => {
@@ -2301,18 +2407,18 @@ function usage(yargs, shim3) {
     return __("Positionals:");
   };
   let examples = [];
-  self.example = (cmd, description) => {
-    examples.push([cmd, description || ""]);
+  self.example = (cmd, description2) => {
+    examples.push([cmd, description2 || ""]);
   };
   let commands = [];
-  self.command = function command2(cmd, description, isDefault, aliases, deprecated = false) {
+  self.command = function command2(cmd, description2, isDefault, aliases, deprecated = false) {
     if (isDefault) {
       commands = commands.map((cmdArray) => {
         cmdArray[2] = false;
         return cmdArray;
       });
     }
-    commands.push([cmd, description || "", isDefault, aliases, deprecated]);
+    commands.push([cmd, description2 || "", isDefault, aliases, deprecated]);
   };
   self.getCommands = () => commands;
   let descriptions = {};
@@ -2485,25 +2591,25 @@ function usage(yargs, shim3) {
       normalizedKeys.forEach((key) => {
         const kswitch = switches[key];
         let desc = descriptions[key] || "";
-        let type = null;
+        let type2 = null;
         if (desc.includes(deferY18nLookupPrefix))
           desc = __(desc.substring(deferY18nLookupPrefix.length));
         if (options.boolean.includes(key))
-          type = `[${__("boolean")}]`;
+          type2 = `[${__("boolean")}]`;
         if (options.count.includes(key))
-          type = `[${__("count")}]`;
+          type2 = `[${__("count")}]`;
         if (options.string.includes(key))
-          type = `[${__("string")}]`;
+          type2 = `[${__("string")}]`;
         if (options.normalize.includes(key))
-          type = `[${__("string")}]`;
+          type2 = `[${__("string")}]`;
         if (options.array.includes(key))
-          type = `[${__("array")}]`;
+          type2 = `[${__("array")}]`;
         if (options.number.includes(key))
-          type = `[${__("number")}]`;
+          type2 = `[${__("number")}]`;
         const deprecatedExtra = (deprecated) => typeof deprecated === "string" ? `[${__("deprecated: %s", deprecated)}]` : `[${__("deprecated")}]`;
         const extra = [
           key in deprecatedOptions ? deprecatedExtra(deprecatedOptions[key]) : null,
-          type,
+          type2,
           key in demandedOptions ? `[${__("required")}]` : null,
           options.choices && options.choices[key] ? `[${__("choices:")} ${self.stringifiedValues(options.choices[key])}]` : null,
           defaultString(options.default[key], options.defaultDescription[key])
@@ -2622,8 +2728,8 @@ function usage(yargs, shim3) {
     emit(self.help());
   };
   self.functionDescription = (fn) => {
-    const description = fn.name ? shim3.Parser.decamelize(fn.name, "-") : __("generated-value");
-    return ["(", description, ")"].join("");
+    const description2 = fn.name ? shim3.Parser.decamelize(fn.name, "-") : __("generated-value");
+    return ["(", description2, ")"].join("");
   };
   self.stringifiedValues = function stringifiedValues(values, separator) {
     let string = "";
@@ -2666,16 +2772,16 @@ function usage(yargs, shim3) {
       return maxWidth2;
     }
   }
-  let version = null;
+  let version2 = null;
   self.version = (ver) => {
-    version = ver;
+    version2 = ver;
   };
   self.showVersion = (level) => {
     const logger2 = yargs.getInternalMethods().getLoggerInstance();
     if (!level)
       level = "error";
     const emit = typeof level === "function" ? level : logger2[level];
-    emit(version);
+    emit(version2);
   };
   self.reset = function reset(localLookup) {
     failMessage = null;
@@ -2979,10 +3085,10 @@ var Completion = class {
   }
   generateCompletionScript($0, cmd) {
     let script = this.zshShell ? completionZshTemplate : completionShTemplate;
-    const name = this.shim.path.basename($0);
+    const name2 = this.shim.path.basename($0);
     if ($0.match(/\.js$/))
       $0 = `./${$0}`;
-    script = script.replace(/{{app_name}}/g, name);
+    script = script.replace(/{{app_name}}/g, name2);
     script = script.replace(/{{completion_command}}/g, cmd);
     return script.replace(/{{app_path}}/g, $0);
   }
@@ -3663,13 +3769,13 @@ var YargsInstance = class {
       __classPrivateFieldGet(this, _YargsInstance_completion, "f").registerFunction(fn);
     return this;
   }
-  command(cmd, description, builder, handler, middlewares, deprecated) {
-    argsert("<string|array|object> [string|boolean] [function|object] [function] [array] [boolean|string]", [cmd, description, builder, handler, middlewares, deprecated], arguments.length);
-    __classPrivateFieldGet(this, _YargsInstance_command, "f").addHandler(cmd, description, builder, handler, middlewares, deprecated);
+  command(cmd, description2, builder, handler, middlewares, deprecated) {
+    argsert("<string|array|object> [string|boolean] [function|object] [function] [array] [boolean|string]", [cmd, description2, builder, handler, middlewares, deprecated], arguments.length);
+    __classPrivateFieldGet(this, _YargsInstance_command, "f").addHandler(cmd, description2, builder, handler, middlewares, deprecated);
     return this;
   }
-  commands(cmd, description, builder, handler, middlewares, deprecated) {
-    return this.command(cmd, description, builder, handler, middlewares, deprecated);
+  commands(cmd, description2, builder, handler, middlewares, deprecated) {
+    return this.command(cmd, description2, builder, handler, middlewares, deprecated);
   }
   commandDir(dir, opts) {
     argsert("<string> [object]", [dir, opts], arguments.length);
@@ -3754,10 +3860,10 @@ var YargsInstance = class {
     __classPrivateFieldGet(this, _YargsInstance_options, "f").deprecatedOptions[option] = message;
     return this;
   }
-  describe(keys, description) {
-    argsert("<object|string|array> [string]", [keys, description], arguments.length);
+  describe(keys, description2) {
+    argsert("<object|string|array> [string]", [keys, description2], arguments.length);
     this[kSetKey](keys, true);
-    __classPrivateFieldGet(this, _YargsInstance_usage, "f").describe(keys, description);
+    __classPrivateFieldGet(this, _YargsInstance_usage, "f").describe(keys, description2);
     return this;
   }
   detectLocale(detect) {
@@ -3781,12 +3887,12 @@ var YargsInstance = class {
   epilog(msg) {
     return this.epilogue(msg);
   }
-  example(cmd, description) {
-    argsert("<string|array> [string]", [cmd, description], arguments.length);
+  example(cmd, description2) {
+    argsert("<string|array> [string]", [cmd, description2], arguments.length);
     if (Array.isArray(cmd)) {
       cmd.forEach((exampleParams) => this.example(...exampleParams));
     } else {
-      __classPrivateFieldGet(this, _YargsInstance_usage, "f").example(cmd, description);
+      __classPrivateFieldGet(this, _YargsInstance_usage, "f").example(cmd, description2);
     }
     return this;
   }
@@ -4271,12 +4377,12 @@ var YargsInstance = class {
     __classPrivateFieldGet(this, _YargsInstance_shim, "f").y18n.updateLocale(obj);
     return this;
   }
-  usage(msg, description, builder, handler) {
-    argsert("<string|null|undefined> [string|boolean] [function|object] [function]", [msg, description, builder, handler], arguments.length);
-    if (description !== void 0) {
+  usage(msg, description2, builder, handler) {
+    argsert("<string|null|undefined> [string|boolean] [function|object] [function]", [msg, description2, builder, handler], arguments.length);
+    if (description2 !== void 0) {
       assertNotStrictEqual(msg, null, __classPrivateFieldGet(this, _YargsInstance_shim, "f"));
       if ((msg || "").match(/^\$0( |$)/)) {
-        return this.command(msg, description, builder, handler);
+        return this.command(msg, description2, builder, handler);
       } else {
         throw new YError(".usage() description must start with $0 if being used as alias for .command()");
       }
@@ -4367,9 +4473,9 @@ var YargsInstance = class {
     });
     delete __classPrivateFieldGet(this, _YargsInstance_usage, "f").getDescriptions()[optionKey];
   }
-  [kEmitWarning](warning, type, deduplicationId) {
+  [kEmitWarning](warning, type2, deduplicationId) {
     if (!__classPrivateFieldGet(this, _YargsInstance_emittedWarnings, "f")[deduplicationId]) {
-      __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.emitWarning(warning, type);
+      __classPrivateFieldGet(this, _YargsInstance_shim, "f").process.emitWarning(warning, type2);
       __classPrivateFieldGet(this, _YargsInstance_emittedWarnings, "f")[deduplicationId] = true;
     }
   }
@@ -4461,24 +4567,24 @@ var YargsInstance = class {
     __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath] = obj || {};
     return __classPrivateFieldGet(this, _YargsInstance_pkgs, "f")[npath];
   }
-  [kPopulateParserHintArray](type, keys) {
+  [kPopulateParserHintArray](type2, keys) {
     keys = [].concat(keys);
     keys.forEach((key) => {
       key = this[kSanitizeKey](key);
-      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type].push(key);
+      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type2].push(key);
     });
   }
-  [kPopulateParserHintSingleValueDictionary](builder, type, key, value) {
-    this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => {
-      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] = value2;
+  [kPopulateParserHintSingleValueDictionary](builder, type2, key, value) {
+    this[kPopulateParserHintDictionary](builder, type2, key, value, (type3, key2, value2) => {
+      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type3][key2] = value2;
     });
   }
-  [kPopulateParserHintArrayDictionary](builder, type, key, value) {
-    this[kPopulateParserHintDictionary](builder, type, key, value, (type2, key2, value2) => {
-      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] = (__classPrivateFieldGet(this, _YargsInstance_options, "f")[type2][key2] || []).concat(value2);
+  [kPopulateParserHintArrayDictionary](builder, type2, key, value) {
+    this[kPopulateParserHintDictionary](builder, type2, key, value, (type3, key2, value2) => {
+      __classPrivateFieldGet(this, _YargsInstance_options, "f")[type3][key2] = (__classPrivateFieldGet(this, _YargsInstance_options, "f")[type3][key2] || []).concat(value2);
     });
   }
-  [kPopulateParserHintDictionary](builder, type, key, value, singleKeyHandler) {
+  [kPopulateParserHintDictionary](builder, type2, key, value, singleKeyHandler) {
     if (Array.isArray(key)) {
       key.forEach((k) => {
         builder(k, value);
@@ -4488,7 +4594,7 @@ var YargsInstance = class {
         builder(k, key[k]);
       }
     } else {
-      singleKeyHandler(type, this[kSanitizeKey](key), value);
+      singleKeyHandler(type2, this[kSanitizeKey](key), value);
     }
   }
   [kSanitizeKey](key) {
@@ -4899,24 +5005,26 @@ async function createMock() {
   const activeWorkflows = {};
   const bus = new EventEmitter();
   const listeners = {};
-  const dispatch = (type, args2) => {
+  const dispatch = (type2, args2) => {
     if (args2.workflowId) {
-      listeners[args2.workflowId]?.[type]?.(args2);
+      listeners[args2.workflowId]?.[type2]?.(args2);
     }
-    bus.emit(type, args2);
+    bus.emit(type2, args2);
   };
   const on = (event, fn) => bus.on(event, fn);
   const once = (event, fn) => bus.once(event, fn);
   const listen = (planId, events) => {
     listeners[planId] = events;
   };
-  const execute2 = async (xplan, options = {
+  const execute2 = async (xplan, input, options = {
     resolvers: resolvers_default
   }) => {
-    const { id, jobs } = xplan;
+    const { id } = xplan;
+    const { steps } = xplan.workflow;
     activeWorkflows[id] = true;
     const threadId = crypto.randomUUID();
-    for (const job of jobs) {
+    for (const step of steps) {
+      const job = step;
       if (typeof job.configuration === "string") {
         job.configuration = await options.resolvers?.credential?.(
           job.configuration
@@ -4934,6 +5042,7 @@ async function createMock() {
           level: "info",
           json: true,
           message: JSON.stringify(args2),
+          name: "JOB",
           time: Date.now()
         });
       }
@@ -4944,8 +5053,8 @@ async function createMock() {
       ...options,
       globals: helpers,
       callbacks: {
-        notify: (name, payload) => {
-          dispatch(name, {
+        notify: (name2, payload) => {
+          dispatch(name2, {
             workflowId: id,
             threadId,
             ...payload
@@ -4956,7 +5065,7 @@ async function createMock() {
     setTimeout(async () => {
       dispatch("workflow-start", { workflowId: id, threadId });
       try {
-        await run(xplan, void 0, opts);
+        await run(xplan, input, opts);
         dispatch("workflow-complete", { workflowId: id, threadId });
       } catch (e) {
         dispatch("workflow-error", {
@@ -4999,8 +5108,8 @@ import { createMockLogger as createMockLogger2 } from "@openfn/logger";
 // src/events.ts
 var CLAIM = "claim";
 var GET_PLAN = "fetch:plan";
-var GET_CREDENTIAL = "fetch:credential";
 var GET_DATACLIP = "fetch:dataclip";
+var GET_CREDENTIAL = "fetch:credential";
 var RUN_START = "run:start";
 var RUN_COMPLETE = "run:complete";
 var RUN_LOG = "run:log";
@@ -5024,6 +5133,7 @@ var destroy = async (app, logger2) => {
       await waitForRuns(app, logger2);
       await app.engine.destroy();
       app.socket?.disconnect();
+      logger2.info("Server closed....");
       resolve5();
     })
   ]);
@@ -5048,6 +5158,7 @@ var waitForRuns = (app, logger2) => new Promise((resolve5) => {
     log();
     app.events.on(INTERNAL_RUN_COMPLETE, onRunComplete);
   } else {
+    logger2.debug("No active rns detected");
     resolve5();
   }
 });
@@ -5095,10 +5206,22 @@ var tryWithBackoff = (fn, opts = {}) => {
 var try_with_backoff_default = tryWithBackoff;
 
 // src/api/claim.ts
+import crypto2 from "node:crypto";
+import * as jose from "jose";
 import { createMockLogger } from "@openfn/logger";
 var mockLogger = createMockLogger();
-var claim = (app, logger2 = mockLogger, maxWorkers = 5) => {
+var verifyToken = async (token, publicKey) => {
+  const key = crypto2.createPublicKey(publicKey);
+  const { payload } = await jose.jwtVerify(token, key, {
+    issuer: "Lightning"
+  });
+  if (payload) {
+    return true;
+  }
+};
+var claim = (app, logger2 = mockLogger, options = {}) => {
   return new Promise((resolve5, reject) => {
+    const { maxWorkers = 5 } = options;
     const activeWorkers = Object.keys(app.workflows).length;
     if (activeWorkers >= maxWorkers) {
       return reject(new Error("Server at capacity"));
@@ -5112,7 +5235,21 @@ var claim = (app, logger2 = mockLogger, maxWorkers = 5) => {
       if (!runs?.length) {
         return reject(new Error("No runs returned"));
       }
-      runs.forEach((run2) => {
+      runs.forEach(async (run2) => {
+        if (app.options?.runPublicKey) {
+          try {
+            await verifyToken(run2.token, app.options.runPublicKey);
+            logger2.debug("verified run token for", run2.id);
+          } catch (e) {
+            logger2.error("Error validating run token");
+            logger2.error(e);
+            reject();
+            app.destroy();
+            return;
+          }
+        } else {
+          logger2.debug("skipping run token validation for", run2.id);
+        }
         logger2.debug("starting run", run2.id);
         app.execute(run2);
         resolve5();
@@ -5133,10 +5270,15 @@ var startWorkloop = (app, logger2, minBackoff2, maxBackoff2, maxWorkers) => {
   let cancelled = false;
   const workLoop = () => {
     if (!cancelled) {
-      promise = try_with_backoff_default(() => claim_default(app, logger2, maxWorkers), {
-        min: minBackoff2,
-        max: maxBackoff2
-      });
+      promise = try_with_backoff_default(
+        () => claim_default(app, logger2, {
+          maxWorkers
+        }),
+        {
+          min: minBackoff2,
+          max: maxBackoff2
+        }
+      );
       promise.then(() => {
         if (!cancelled) {
           setTimeout(workLoop, minBackoff2);
@@ -5154,8 +5296,8 @@ var startWorkloop = (app, logger2, minBackoff2, maxBackoff2, maxWorkers) => {
 };
 var workloop_default = startWorkloop;
 
-// src/util/convert-run.ts
-import crypto2 from "node:crypto";
+// src/util/convert-lightning-plan.ts
+import crypto3 from "node:crypto";
 var conditions = {
   on_job_success: (upstreamId) => `Boolean(!state?.errors?.["${upstreamId}"] ?? true)`,
   on_job_failure: (upstreamId) => `Boolean(state?.errors && state.errors["${upstreamId}"])`,
@@ -5175,19 +5317,30 @@ var mapTriggerEdgeCondition = (edge) => {
     return true;
   return condition;
 };
-var mapOptions = (options) => {
-  return options;
-};
-var convert_run_default = (run2) => {
-  const options = run2.options || {};
+var convert_lightning_plan_default = (run2) => {
+  const runtimeOpts = {};
+  const engineOpts = {};
+  if (run2.options) {
+    if (run2.options.runTimeoutMs) {
+      engineOpts.runTimeoutMs = run2.options.runTimeoutMs;
+    }
+    if (run2.options.sanitize) {
+      engineOpts.sanitize = run2.options.sanitize;
+    }
+    if (run2.options.hasOwnProperty("output_dataclips")) {
+      engineOpts.outputDataclips = run2.options.output_dataclips;
+    }
+  }
   const plan = {
-    id: run2.id
+    id: run2.id,
+    options: runtimeOpts
   };
+  let initialState;
   if (run2.dataclip_id) {
-    plan.initialState = run2.dataclip_id;
+    initialState = run2.dataclip_id;
   }
   if (run2.starting_node_id) {
-    plan.start = run2.starting_node_id;
+    runtimeOpts.start = run2.starting_node_id;
   }
   const nodes = {};
   const edges = run2.edges ?? [];
@@ -5199,27 +5352,33 @@ var convert_run_default = (run2) => {
       };
       const connectedEdges = edges.filter((e) => e.source_trigger_id === id);
       if (connectedEdges.length) {
-        nodes[id].next = connectedEdges.reduce((obj, edge) => {
-          if (edge.enabled !== false) {
-            obj[edge.target_job_id] = mapTriggerEdgeCondition(edge);
-          }
-          return obj;
-        }, {});
+        nodes[id].next = connectedEdges.reduce(
+          (obj, edge) => {
+            if (edge.enabled !== false) {
+              obj[edge.target_job_id] = mapTriggerEdgeCondition(edge);
+            }
+            return obj;
+          },
+          {}
+        );
       } else {
       }
     });
   }
   if (run2.jobs?.length) {
-    run2.jobs.forEach((job) => {
-      const id = job.id || crypto2.randomUUID();
-      nodes[id] = {
+    run2.jobs.forEach((step) => {
+      const id = step.id || crypto3.randomUUID();
+      const job = {
         id,
-        configuration: job.credential || job.credential_id,
-        expression: job.body,
-        adaptor: job.adaptor
+        configuration: step.credential || step.credential_id,
+        expression: step.body,
+        adaptor: step.adaptor
       };
-      if (job.state) {
-        nodes[id].state = job.state;
+      if (step.name) {
+        job.name = step.name;
+      }
+      if (step.state) {
+        job.state = step.state;
       }
       const next = edges.filter((e) => e.source_job_id === id).reduce((obj, edge) => {
         const newEdge = {};
@@ -5234,21 +5393,32 @@ var convert_run_default = (run2) => {
         return obj;
       }, {});
       if (Object.keys(next).length) {
-        nodes[id].next = next;
+        job.next = next;
       }
+      nodes[id] = job;
     });
   }
-  plan.jobs = Object.values(nodes);
+  plan.workflow = {
+    steps: Object.values(nodes)
+  };
+  if (run2.name) {
+    plan.workflow.name = run2.name;
+  }
   return {
     plan,
-    options: mapOptions(options)
+    options: engineOpts,
+    input: initialState || {}
   };
 };
 
 // src/util/get-with-reply.ts
-var get_with_reply_default = (channel, event, payload) => new Promise((resolve5) => {
+var get_with_reply_default = (channel, event, payload) => new Promise((resolve5, reject) => {
   channel.push(event, payload).receive("ok", (evt) => {
     resolve5(evt);
+  }).receive("error", (e) => {
+    reject(e);
+  }).receive("timeout", (e) => {
+    reject(e);
   });
 });
 
@@ -5262,19 +5432,20 @@ var stringify_default = (obj) => stringify(obj, (_key, value) => {
 });
 
 // src/util/create-run-state.ts
-var create_run_state_default = (plan, options = {}) => {
+var create_run_state_default = (plan, input) => {
   const state = {
-    plan,
     lastDataclipId: "",
     dataclips: {},
     inputDataclips: {},
     reasons: {},
-    options
+    plan,
+    input
   };
-  if (typeof plan.initialState === "string") {
-    let startNode = plan.jobs[0];
-    if (plan.start) {
-      startNode = plan.jobs.find(({ id }) => id === plan.start);
+  if (typeof input === "string") {
+    const jobs = plan.workflow.steps;
+    let startNode = jobs[0];
+    if (plan.options.start) {
+      startNode = jobs.find(({ id }) => id === plan.options.start);
     }
     const initialRuns = [];
     if (!startNode.expression) {
@@ -5283,7 +5454,7 @@ var create_run_state_default = (plan, options = {}) => {
       initialRuns.push(startNode.id);
     }
     initialRuns.forEach((id) => {
-      state.inputDataclips[id] = plan.initialState;
+      state.inputDataclips[id] = input;
     });
   } else {
   }
@@ -5317,8 +5488,59 @@ var createThrottler = () => {
 };
 var throttle_default = createThrottler;
 
+// src/events/run-start.ts
+import { timestamp } from "@openfn/logger";
+
+// src/util/versions.ts
+import { mainSymbols } from "figures";
+var { triangleRightSmall: t } = mainSymbols;
+var versions_default = (versions) => {
+  let longest = "worker".length;
+  for (const v in versions) {
+    longest = Math.max(v.length, longest);
+  }
+  const { node, worker, compiler, runtime, engine, ...adaptors } = versions;
+  const prefix = (str2) => `    ${t} ${str2.padEnd(longest + 4, " ")}`;
+  let str = `Versions:
+${prefix("node.js")}${versions.node || "unknown"}
+${prefix("worker")}${versions.worker || "unknown"}`;
+  if (Object.keys(adaptors).length) {
+    let allAdaptors = Object.keys(adaptors);
+    str += "\n" + allAdaptors.sort().map(
+      (adaptorName) => `${prefix(adaptorName)}${adaptors[adaptorName].sort().join(", ")}`
+    ).join("\n");
+  }
+  return str;
+};
+
+// src/events/run-start.ts
+init_package();
+async function onRunStart(context, event) {
+  const { channel, state } = context;
+  const time = (timestamp() - BigInt(1e7)).toString();
+  const versionLogContext = {
+    ...context,
+    state: {
+      ...state,
+      activeStep: state.activeStep
+    }
+  };
+  const versions = {
+    worker: package_default.version,
+    ...event.versions
+  };
+  await sendEvent(channel, RUN_START, { versions });
+  const versionMessage = versions_default(versions);
+  await onJobLog(versionLogContext, {
+    time,
+    message: [versionMessage],
+    level: "info",
+    name: "VER"
+  });
+}
+
 // src/events/step-complete.ts
-import crypto3 from "node:crypto";
+import crypto4 from "node:crypto";
 
 // src/api/reasons.ts
 var calculateJobExitReason = (jobId, state = { data: {} }, error) => {
@@ -5344,7 +5566,7 @@ var isLeafNode = (state, job) => {
 };
 var calculateRunExitReason = (state) => {
   if (state.plan && state.reasons) {
-    const leafJobReasons = state.plan.jobs.filter((job) => isLeafNode(state, job)).map(({ id }) => state.reasons[id]);
+    const leafJobReasons = state.plan.workflow.steps.filter((job) => isLeafNode(state, job)).map(({ id }) => state.reasons[id]);
     const fail = leafJobReasons.find((r) => r && r.reason === "fail");
     if (fail) {
       return fail;
@@ -5354,8 +5576,8 @@ var calculateRunExitReason = (state) => {
 };
 
 // src/events/step-complete.ts
-function onStepComplete({ channel, state }, event, error) {
-  const dataclipId = crypto3.randomUUID();
+function onStepComplete({ channel, state, options }, event, error) {
+  const dataclipId = crypto4.randomUUID();
   const step_id = state.activeStep;
   const job_id = state.activeJob;
   if (!state.dataclips) {
@@ -5379,7 +5601,6 @@ function onStepComplete({ channel, state }, event, error) {
     step_id,
     job_id,
     output_dataclip_id: dataclipId,
-    output_dataclip: stringify_default(outputState),
     reason,
     error_message,
     error_type,
@@ -5387,137 +5608,24 @@ function onStepComplete({ channel, state }, event, error) {
     duration: event.duration,
     thread_id: event.threadId
   };
+  if (!options || options.outputDataclips !== false) {
+    evt.output_dataclip = stringify_default(outputState);
+  }
   return sendEvent(channel, STEP_COMPLETE, evt);
 }
 
 // src/events/step-start.ts
-import crypto4 from "node:crypto";
-import { timestamp } from "@openfn/logger";
-
-// package.json
-var package_default = {
-  name: "@openfn/ws-worker",
-  version: "0.8.1",
-  description: "A Websocket Worker to connect Lightning to a Runtime Engine",
-  main: "dist/index.js",
-  type: "module",
-  scripts: {
-    test: "pnpm ava --serial",
-    "test:types": "pnpm tsc --noEmit --project tsconfig.json",
-    build: "tsup --config tsup.config.js",
-    "build:watch": "pnpm build --watch",
-    start: "ts-node-esm --transpile-only src/start.ts",
-    "start:prod": "node dist/start.js",
-    "start:watch": "nodemon -e ts,js --watch ../runtime-manager/dist --watch ./src --exec 'pnpm start'",
-    pack: "pnpm pack --pack-destination ../../dist"
-  },
-  bin: {
-    worker: "dist/start.js"
-  },
-  author: "Open Function Group <admin@openfn.org>",
-  license: "ISC",
-  dependencies: {
-    "@koa/router": "^12.0.0",
-    "@openfn/engine-multi": "workspace:*",
-    "@openfn/logger": "workspace:*",
-    "@openfn/runtime": "workspace:*",
-    "@types/koa-logger": "^3.1.2",
-    "@types/ws": "^8.5.6",
-    "fast-safe-stringify": "^2.1.1",
-    figures: "^5.0.0",
-    "human-id": "^4.1.0",
-    jose: "^4.14.6",
-    koa: "^2.13.4",
-    "koa-bodyparser": "^4.4.0",
-    "koa-logger": "^3.2.1",
-    phoenix: "^1.7.7",
-    ws: "^8.14.1"
-  },
-  devDependencies: {
-    "@openfn/lightning-mock": "workspace:*",
-    "@types/koa": "^2.13.5",
-    "@types/koa-bodyparser": "^4.3.10",
-    "@types/koa__router": "^12.0.1",
-    "@types/node": "^18.15.3",
-    "@types/nodemon": "1.19.3",
-    "@types/phoenix": "^1.6.2",
-    "@types/yargs": "^17.0.12",
-    ava: "5.1.0",
-    nodemon: "3.0.1",
-    "ts-node": "^10.9.1",
-    tslib: "^2.4.0",
-    tsup: "^6.2.3",
-    typescript: "^4.6.4",
-    yargs: "^17.6.2"
-  },
-  files: [
-    "dist",
-    "README.md",
-    "CHANGELOG.md"
-  ]
-};
-
-// src/util/versions.ts
-import { mainSymbols } from "figures";
-var { triangleRightSmall: t } = mainSymbols;
-var versions_default = (stepId, versions, adaptor) => {
-  let longest = "compiler".length;
-  for (const v in versions) {
-    longest = Math.max(v.length, longest);
-  }
-  const { node, compiler, engine, worker, runtime, ...adaptors } = versions;
-  const prefix = (str2) => `    ${t} ${str2.padEnd(longest + 4, " ")}`;
-  let str = `Versions for step ${stepId}:
-${prefix("node.js")}${versions.node || "unknown"}
-${prefix("worker")}${versions.worker || "unknown"}
-${prefix("engine")}${versions.engine || "unknown"}`;
-  if (Object.keys(adaptors).length) {
-    let allAdaptors = Object.keys(adaptors);
-    if (adaptor) {
-      allAdaptors = allAdaptors.filter((name) => adaptor.startsWith(name));
-    }
-    str += "\n" + allAdaptors.sort().map((adaptorName) => `${prefix(adaptorName)}${adaptors[adaptorName]}`).join("\n");
-  }
-  return str;
-};
-
-// src/events/step-start.ts
+import crypto5 from "node:crypto";
 async function onStepStart(context, event) {
-  const time = (timestamp() - BigInt(1e7)).toString();
   const { channel, state } = context;
-  state.activeStep = crypto4.randomUUID();
+  state.activeStep = crypto5.randomUUID();
   state.activeJob = event.jobId;
-  const job = state.plan.jobs.find(({ id }) => id === event.jobId);
   const input_dataclip_id = state.inputDataclips[event.jobId];
-  const versions = {
-    worker: package_default.version,
-    ...event.versions
-  };
-  const versionLogContext = {
-    ...context,
-    state: {
-      ...state,
-      activeStep: state.activeStep
-    }
-  };
   await sendEvent(channel, STEP_START, {
     step_id: state.activeStep,
     job_id: state.activeJob,
-    input_dataclip_id,
-    versions
-  });
-  const versionMessage = versions_default(
-    versionLogContext.state.activeStep,
-    versions,
-    job?.adaptor
-  );
-  await onJobLog(versionLogContext, {
-    time,
-    message: [versionMessage],
-    level: "info",
-    name: "VER"
+    input_dataclip_id
   });
-  return;
 }
 
 // src/util/log-final-reason.ts
@@ -5565,7 +5673,7 @@ async function onRunError(context, event) {
     });
     onFinish({ reason });
   } catch (e) {
-    logger2.error("ERROR in workflow-error handler:", e.message);
+    logger2.error("ERROR in run-error handler:", e.message);
     logger2.error(e);
     onFinish({});
   }
@@ -5580,11 +5688,18 @@ var eventMap = {
   "workflow-log": RUN_LOG,
   "workflow-complete": RUN_COMPLETE
 };
-function execute(channel, engine, logger2, plan, options = {}, onFinish = (_result) => {
+function execute(channel, engine, logger2, plan, input, options = {}, onFinish = (_result) => {
 }) {
   logger2.info("executing ", plan.id);
-  const state = create_run_state_default(plan, options);
-  const context = { channel, state, logger: logger2, engine, onFinish };
+  const state = create_run_state_default(plan, input);
+  const context = {
+    channel,
+    state,
+    logger: logger2,
+    engine,
+    options,
+    onFinish
+  };
   const throttle = throttle_default();
   const addEvent = (eventName, handler) => {
     const wrappedFn = async (event) => {
@@ -5605,7 +5720,7 @@ function execute(channel, engine, logger2, plan, options = {}, onFinish = (_resu
   };
   const listeners = Object.assign(
     {},
-    addEvent("workflow-start", throttle(onWorkflowStart)),
+    addEvent("workflow-start", throttle(onRunStart)),
     addEvent("job-start", throttle(onStepStart)),
     addEvent("job-complete", throttle(onStepComplete)),
     addEvent("job-error", throttle(onJobError)),
@@ -5617,17 +5732,24 @@ function execute(channel, engine, logger2, plan, options = {}, onFinish = (_resu
   const resolvers = {
     credential: (id) => loadCredential(channel, id)
   };
-  Promise.resolve().then(async () => {
-    if (typeof plan.initialState === "string") {
-      logger2.debug("loading dataclip", plan.initialState);
-      plan.initialState = await loadDataclip(channel, plan.initialState);
-      logger2.success("dataclip loaded");
-      logger2.debug(plan.initialState);
-    }
-    return plan;
-  }).then(() => {
+  setTimeout(async () => {
+    let loadedInput = input;
+    if (typeof input === "string") {
+      logger2.debug("loading dataclip", input);
+      try {
+        loadedInput = await loadDataclip(channel, input);
+        logger2.success("dataclip loaded");
+      } catch (e) {
+        return onRunError(context, {
+          workflowId: plan.id,
+          message: `Failed to load dataclip ${input}${e.message ? `: ${e.message}` : ""}`,
+          type: "DataClipError",
+          severity: "exception"
+        });
+      }
+    }
     try {
-      engine.execute(plan, { resolvers, ...options });
+      engine.execute(plan, loadedInput, { resolvers, ...options });
     } catch (e) {
       onRunError(context, {
         workflowId: plan.id,
@@ -5652,9 +5774,6 @@ function onJobError(context, event) {
     return onStepComplete(context, event, event.error);
   }
 }
-function onWorkflowStart({ channel }, _event) {
-  return sendEvent(channel, RUN_START);
-}
 function onJobLog({ channel, state }, event) {
   const timeInMicroseconds = BigInt(event.time) / BigInt(1e3);
   const log = {
@@ -5696,9 +5815,9 @@ var joinRunChannel = (socket, token, runId, logger2) => {
       if (!didReceiveOk) {
         didReceiveOk = true;
         logger2.success(`connected to ${channelName}`, e);
-        const { plan, options } = await loadRun(channel);
+        const { plan, options, input } = await loadRun(channel);
         logger2.debug("converted run as execution plan:", plan);
-        resolve5({ channel, plan, options });
+        resolve5({ channel, plan, options, input });
       }
     }).receive("error", (err) => {
       logger2.error(`error connecting to ${channelName}`, err);
@@ -5709,16 +5828,17 @@ var joinRunChannel = (socket, token, runId, logger2) => {
 var run_default = joinRunChannel;
 async function loadRun(channel) {
   const runBody = await get_with_reply_default(channel, GET_PLAN);
-  return convert_run_default(runBody);
+  return convert_lightning_plan_default(runBody);
 }
 
 // src/channels/worker-queue.ts
 import EventEmitter2 from "node:events";
 import { Socket as PhxSocket } from "phoenix";
 import { WebSocket } from "ws";
+import { API_VERSION } from "@openfn/lexicon/lightning";
 
 // src/util/worker-token.ts
-import * as jose from "jose";
+import * as jose2 from "jose";
 var alg = "HS256";
 var generateWorkerToken = async (secret, workerId, logger2) => {
   if (!secret) {
@@ -5733,7 +5853,7 @@ var generateWorkerToken = async (secret, workerId, logger2) => {
   const claims = {
     worker_id: workerId
   };
-  const jwt = await new jose.SignJWT(claims).setProtectedHeader({ alg }).setIssuedAt().setIssuer("urn:example:issuer").setAudience("urn:example:audience").sign(encodedSecret);
+  const jwt = await new jose2.SignJWT(claims).setProtectedHeader({ alg }).setIssuedAt().setIssuer("urn:openfn:worker").sign(encodedSecret);
   return jwt;
 };
 var worker_token_default = generateWorkerToken;
@@ -5741,9 +5861,15 @@ var worker_token_default = generateWorkerToken;
 // src/channels/worker-queue.ts
 var connectToWorkerQueue = (endpoint, serverId, secret, logger2, SocketConstructor = PhxSocket) => {
   const events = new EventEmitter2();
-  worker_token_default(secret, serverId, logger2).then((token) => {
+  worker_token_default(secret, serverId, logger2).then(async (token) => {
+    const pkg = await Promise.resolve().then(() => (init_package(), package_exports));
+    const params = {
+      token,
+      api_version: API_VERSION,
+      worker_version: pkg.default.version
+    };
     const socket = new SocketConstructor(endpoint, {
-      params: { token },
+      params,
       transport: WebSocket
     });
     let didOpen = false;
@@ -5782,6 +5908,9 @@ var MAX_BACKOFF = 1e3 * 30;
 function connect(app, logger2, options = {}) {
   logger2.debug("Connecting to Lightning at", options.lightning);
   const onConnect = ({ socket, channel }) => {
+    if (app.destroyed) {
+      return;
+    }
     logger2.success("Connected to Lightning at", options.lightning);
     app.socket = socket;
     app.queueChannel = channel;
@@ -5816,6 +5945,9 @@ function connect(app, logger2, options = {}) {
     }
   };
   const onError = (e) => {
+    if (app.destroyed) {
+      return;
+    }
     logger2.error(
       "CRITICAL ERROR: could not connect to lightning at",
       options.lightning
@@ -5845,13 +5977,15 @@ function createServer(engine, options = {}) {
   process.send?.("READY");
   router.get("/livez", healthcheck_default);
   router.get("/", healthcheck_default);
+  app.options = options || {};
   app.execute = async ({ id, token }) => {
     if (app.socket) {
       app.workflows[id] = true;
       const {
         channel: runChannel,
         plan,
-        options: options2
+        options: options2,
+        input
       } = await run_default(app.socket, token, id, logger2);
       const onFinish = () => {
         delete app.workflows[id];
@@ -5863,6 +5997,7 @@ function createServer(engine, options = {}) {
         engine,
         logger2,
         plan,
+        input,
         options2,
         onFinish
       );
@@ -5873,7 +6008,9 @@ function createServer(engine, options = {}) {
   };
   router.post("/claim", async (ctx) => {
     logger2.info("triggering claim from POST request");
-    return claim_default(app, logger2, options.maxWorkflows).then(() => {
+    return claim_default(app, logger2, {
+      maxWorkers: options.maxWorkflows
+    }).then(() => {
       logger2.info("claim complete: 1 run claimed");
       ctx.body = "complete";
       ctx.status = 200;
@@ -5912,6 +6049,7 @@ var server_default = createServer;
 var {
   WORKER_BACKOFF,
   WORKER_CAPACITY,
+  WORKER_LIGHTNING_PUBLIC_KEY,
   WORKER_LIGHTNING_SERVICE_URL,
   WORKER_LOG_LEVEL,
   WORKER_MAX_RUN_DURATION_SECONDS,
@@ -5938,6 +6076,9 @@ var args = yargs_default(hideBin(process.argv)).command("server", "Start a ws-wo
   alias: "s",
   description: "Worker secret. (comes from WORKER_SECRET by default). Env: WORKER_SECRET",
   default: WORKER_SECRET
+}).option("lightning-public-key", {
+  description: "Base64-encoded public key. Used to verify run tokens. Env: WORKER_LIGHTNING_PUBLIC_KEY",
+  default: WORKER_LIGHTNING_PUBLIC_KEY
 }).option("log", {
   description: "Set the log level for stdout (default to info, set to debug for verbose output). Env: WORKER_LOG_LEVEL",
   default: WORKER_LOG_LEVEL || "debug",
@@ -5996,7 +6137,21 @@ function engineReady(engine) {
     },
     maxWorkflows: args.capacity
   };
-  const { logger: _l, secret: _s, ...humanOptions } = workerOptions;
+  if (args.lightningPublicKey) {
+    logger.info(
+      "Lightning public key found: run tokens from Lightning will be verified by this worker"
+    );
+    workerOptions.runPublicKey = Buffer.from(
+      args.lightningPublicKey,
+      "base64"
+    ).toString();
+  }
+  const {
+    logger: _l,
+    secret: _s,
+    runPublicKey,
+    ...humanOptions
+  } = workerOptions;
   logger.debug("Worker options:", humanOptions);
   server_default(engine, workerOptions);
 }