@openfn/ws-worker 0.8.1 → 1.1.0

package/dist/index.js

@@ -1,3 +1,110 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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
+    };
+  }
+});
+
 // src/server.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
 import Koa from "koa";
@@ -10,8 +117,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";
@@ -35,6 +142,7 @@ var destroy = async (app, logger) => {
       await waitForRuns(app, logger);
       await app.engine.destroy();
       app.socket?.disconnect();
+      logger.info("Server closed....");
       resolve();
     })
   ]);
@@ -59,6 +167,7 @@ var waitForRuns = (app, logger) => new Promise((resolve) => {
     log();
     app.events.on(INTERNAL_RUN_COMPLETE, onRunComplete);
   } else {
+    logger.debug("No active rns detected");
     resolve();
   }
 });
@@ -106,10 +215,22 @@ var tryWithBackoff = (fn, opts = {}) => {
 var try_with_backoff_default = tryWithBackoff;
 
 // src/api/claim.ts
+import crypto from "node:crypto";
+import * as jose from "jose";
 import { createMockLogger } from "@openfn/logger";
 var mockLogger = createMockLogger();
-var claim = (app, logger = mockLogger, maxWorkers = 5) => {
+var verifyToken = async (token, publicKey) => {
+  const key = crypto.createPublicKey(publicKey);
+  const { payload } = await jose.jwtVerify(token, key, {
+    issuer: "Lightning"
+  });
+  if (payload) {
+    return true;
+  }
+};
+var claim = (app, logger = mockLogger, options = {}) => {
   return new Promise((resolve, reject) => {
+    const { maxWorkers = 5 } = options;
     const activeWorkers = Object.keys(app.workflows).length;
     if (activeWorkers >= maxWorkers) {
       return reject(new Error("Server at capacity"));
@@ -123,7 +244,21 @@ var claim = (app, logger = mockLogger, maxWorkers = 5) => {
       if (!runs?.length) {
         return reject(new Error("No runs returned"));
       }
-      runs.forEach((run) => {
+      runs.forEach(async (run) => {
+        if (app.options?.runPublicKey) {
+          try {
+            await verifyToken(run.token, app.options.runPublicKey);
+            logger.debug("verified run token for", run.id);
+          } catch (e) {
+            logger.error("Error validating run token");
+            logger.error(e);
+            reject();
+            app.destroy();
+            return;
+          }
+        } else {
+          logger.debug("skipping run token validation for", run.id);
+        }
         logger.debug("starting run", run.id);
         app.execute(run);
         resolve();
@@ -144,10 +279,15 @@ var startWorkloop = (app, logger, minBackoff, maxBackoff, maxWorkers) => {
   let cancelled = false;
   const workLoop = () => {
     if (!cancelled) {
-      promise = try_with_backoff_default(() => claim_default(app, logger, maxWorkers), {
-        min: minBackoff,
-        max: maxBackoff
-      });
+      promise = try_with_backoff_default(
+        () => claim_default(app, logger, {
+          maxWorkers
+        }),
+        {
+          min: minBackoff,
+          max: maxBackoff
+        }
+      );
       promise.then(() => {
         if (!cancelled) {
           setTimeout(workLoop, minBackoff);
@@ -165,8 +305,8 @@ var startWorkloop = (app, logger, minBackoff, maxBackoff, maxWorkers) => {
 };
 var workloop_default = startWorkloop;
 
-// src/util/convert-run.ts
-import crypto from "node:crypto";
+// src/util/convert-lightning-plan.ts
+import crypto2 from "node:crypto";
 var conditions = {
   on_job_success: (upstreamId) => `Boolean(!state?.errors?.["${upstreamId}"] ?? true)`,
   on_job_failure: (upstreamId) => `Boolean(state?.errors && state.errors["${upstreamId}"])`,
@@ -186,19 +326,30 @@ var mapTriggerEdgeCondition = (edge) => {
     return true;
   return condition;
 };
-var mapOptions = (options) => {
-  return options;
-};
-var convert_run_default = (run) => {
-  const options = run.options || {};
+var convert_lightning_plan_default = (run) => {
+  const runtimeOpts = {};
+  const engineOpts = {};
+  if (run.options) {
+    if (run.options.runTimeoutMs) {
+      engineOpts.runTimeoutMs = run.options.runTimeoutMs;
+    }
+    if (run.options.sanitize) {
+      engineOpts.sanitize = run.options.sanitize;
+    }
+    if (run.options.hasOwnProperty("output_dataclips")) {
+      engineOpts.outputDataclips = run.options.output_dataclips;
+    }
+  }
   const plan = {
-    id: run.id
+    id: run.id,
+    options: runtimeOpts
   };
+  let initialState;
   if (run.dataclip_id) {
-    plan.initialState = run.dataclip_id;
+    initialState = run.dataclip_id;
   }
   if (run.starting_node_id) {
-    plan.start = run.starting_node_id;
+    runtimeOpts.start = run.starting_node_id;
   }
   const nodes = {};
   const edges = run.edges ?? [];
@@ -210,27 +361,33 @@ var convert_run_default = (run) => {
       };
       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 (run.jobs?.length) {
-    run.jobs.forEach((job) => {
-      const id = job.id || crypto.randomUUID();
-      nodes[id] = {
+    run.jobs.forEach((step) => {
+      const id = step.id || crypto2.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 = {};
@@ -245,21 +402,32 @@ var convert_run_default = (run) => {
         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 (run.name) {
+    plan.workflow.name = run.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((resolve) => {
+var get_with_reply_default = (channel, event, payload) => new Promise((resolve, reject) => {
   channel.push(event, payload).receive("ok", (evt) => {
     resolve(evt);
+  }).receive("error", (e) => {
+    reject(e);
+  }).receive("timeout", (e) => {
+    reject(e);
   });
 });
 
@@ -273,19 +441,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) {
@@ -294,7 +463,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 {
   }
@@ -328,8 +497,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 crypto2 from "node:crypto";
+import crypto3 from "node:crypto";
 
 // src/api/reasons.ts
 var calculateJobExitReason = (jobId, state = { data: {} }, error) => {
@@ -355,7 +575,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;
@@ -365,8 +585,8 @@ var calculateRunExitReason = (state) => {
 };
 
 // src/events/step-complete.ts
-function onStepComplete({ channel, state }, event, error) {
-  const dataclipId = crypto2.randomUUID();
+function onStepComplete({ channel, state, options }, event, error) {
+  const dataclipId = crypto3.randomUUID();
   const step_id = state.activeStep;
   const job_id = state.activeJob;
   if (!state.dataclips) {
@@ -390,7 +610,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,
@@ -398,137 +617,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 crypto3 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 crypto4 from "node:crypto";
 async function onStepStart(context, event) {
-  const time = (timestamp() - BigInt(1e7)).toString();
   const { channel, state } = context;
-  state.activeStep = crypto3.randomUUID();
+  state.activeStep = crypto4.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
+    input_dataclip_id
   });
-  const versionMessage = versions_default(
-    versionLogContext.state.activeStep,
-    versions,
-    job?.adaptor
-  );
-  await onJobLog(versionLogContext, {
-    time,
-    message: [versionMessage],
-    level: "info",
-    name: "VER"
-  });
-  return;
 }
 
 // src/util/log-final-reason.ts
@@ -576,7 +682,7 @@ async function onRunError(context, event) {
     });
     onFinish({ reason });
   } catch (e) {
-    logger.error("ERROR in workflow-error handler:", e.message);
+    logger.error("ERROR in run-error handler:", e.message);
     logger.error(e);
     onFinish({});
   }
@@ -591,11 +697,18 @@ var eventMap = {
   "workflow-log": RUN_LOG,
   "workflow-complete": RUN_COMPLETE
 };
-function execute(channel, engine, logger, plan, options = {}, onFinish = (_result) => {
+function execute(channel, engine, logger, plan, input, options = {}, onFinish = (_result) => {
 }) {
   logger.info("executing ", plan.id);
-  const state = create_run_state_default(plan, options);
-  const context = { channel, state, logger, engine, onFinish };
+  const state = create_run_state_default(plan, input);
+  const context = {
+    channel,
+    state,
+    logger,
+    engine,
+    options,
+    onFinish
+  };
   const throttle = throttle_default();
   const addEvent = (eventName, handler) => {
     const wrappedFn = async (event) => {
@@ -616,7 +729,7 @@ function execute(channel, engine, logger, plan, options = {}, onFinish = (_resul
   };
   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)),
@@ -628,17 +741,24 @@ function execute(channel, engine, logger, plan, options = {}, onFinish = (_resul
   const resolvers = {
     credential: (id) => loadCredential(channel, id)
   };
-  Promise.resolve().then(async () => {
-    if (typeof plan.initialState === "string") {
-      logger.debug("loading dataclip", plan.initialState);
-      plan.initialState = await loadDataclip(channel, plan.initialState);
-      logger.success("dataclip loaded");
-      logger.debug(plan.initialState);
+  setTimeout(async () => {
+    let loadedInput = input;
+    if (typeof input === "string") {
+      logger.debug("loading dataclip", input);
+      try {
+        loadedInput = await loadDataclip(channel, input);
+        logger.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"
+        });
+      }
     }
-    return plan;
-  }).then(() => {
     try {
-      engine.execute(plan, { resolvers, ...options });
+      engine.execute(plan, loadedInput, { resolvers, ...options });
     } catch (e) {
       onRunError(context, {
         workflowId: plan.id,
@@ -663,9 +783,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 = {
@@ -707,9 +824,9 @@ var joinRunChannel = (socket, token, runId, logger) => {
       if (!didReceiveOk) {
         didReceiveOk = true;
         logger.success(`connected to ${channelName}`, e);
-        const { plan, options } = await loadRun(channel);
+        const { plan, options, input } = await loadRun(channel);
         logger.debug("converted run as execution plan:", plan);
-        resolve({ channel, plan, options });
+        resolve({ channel, plan, options, input });
       }
     }).receive("error", (err) => {
       logger.error(`error connecting to ${channelName}`, err);
@@ -720,16 +837,17 @@ var joinRunChannel = (socket, token, runId, logger) => {
 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 EventEmitter 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, logger) => {
   if (!secret) {
@@ -744,7 +862,7 @@ var generateWorkerToken = async (secret, workerId, logger) => {
   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;
@@ -752,9 +870,15 @@ var worker_token_default = generateWorkerToken;
 // src/channels/worker-queue.ts
 var connectToWorkerQueue = (endpoint, serverId, secret, logger, SocketConstructor = PhxSocket) => {
   const events = new EventEmitter();
-  worker_token_default(secret, serverId, logger).then((token) => {
+  worker_token_default(secret, serverId, logger).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;
@@ -793,6 +917,9 @@ var MAX_BACKOFF = 1e3 * 30;
 function connect(app, logger, options = {}) {
   logger.debug("Connecting to Lightning at", options.lightning);
   const onConnect = ({ socket, channel }) => {
+    if (app.destroyed) {
+      return;
+    }
     logger.success("Connected to Lightning at", options.lightning);
     app.socket = socket;
     app.queueChannel = channel;
@@ -827,6 +954,9 @@ function connect(app, logger, options = {}) {
     }
   };
   const onError = (e) => {
+    if (app.destroyed) {
+      return;
+    }
     logger.error(
       "CRITICAL ERROR: could not connect to lightning at",
       options.lightning
@@ -856,13 +986,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, logger);
       const onFinish = () => {
         delete app.workflows[id];
@@ -874,6 +1006,7 @@ function createServer(engine, options = {}) {
         engine,
         logger,
         plan,
+        input,
         options2,
         onFinish
       );
@@ -884,7 +1017,9 @@ function createServer(engine, options = {}) {
   };
   router.post("/claim", async (ctx) => {
     logger.info("triggering claim from POST request");
-    return claim_default(app, logger, options.maxWorkflows).then(() => {
+    return claim_default(app, logger, {
+      maxWorkers: options.maxWorkflows
+    }).then(() => {
       logger.info("claim complete: 1 run claimed");
       ctx.body = "complete";
       ctx.status = 200;