@mark1russell7/harness 0.6.0 → 0.8.0

package/image/mongo/Dockerfile

@@ -0,0 +1,11 @@
+# The harness's MongoDB client: the driver mongodb 7.7.0 on Node 24.21.0. It runs as a container
+# in the client's network namespace, as the harness's own TCP client does, and prints the same JSON
+# lines, with the driver's own events beside them. The same image sends a planned step-down.
+# lab.ts stages the build context: this folder, under harness/image/mongo. The lockfile is
+# npm-lock.json here, because npm leaves each package-lock.json out of a published tarball.
+FROM node:24.21.0-alpine@sha256:ebfe2f90462722a7a4de65e91990e97fe0d401c70e0e762c5b53302f905ec1c1
+WORKDIR /opt/harness/mongo
+COPY harness/image/mongo/package.json ./
+COPY harness/image/mongo/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/mongo/client-mongo.mjs harness/image/mongo/stepdown-mongo.mjs ./

package/image/mongo/client-mongo.mjs

@@ -0,0 +1,273 @@
+// client-mongo HOST PORT --mode idle|inflight|stream [--hosts H:P,H:P] [--set NAME] [--op write|read-long]
+//              [--interval-ms N] [--max-s N] [--go PATH] [--w majority|1] [--before] [--options JSON]
+//
+// The client of a MongoDB cell: the driver mongodb 7.7.0 on Node 24.21.0, against a replica set.
+// Each event is a JSON line with `ev` and `t`, the time on CLOCK_MONOTONIC in nanoseconds
+// (process.hrtime, which libuv reads from it). The prober stamps the records of the kernel on the
+// same clock, and the injector stamps each fault on it.
+//
+// The lines:
+// - start: the version of the driver and of Node, the mode and the options.
+// - clocks: the wall clock in ms beside the monotonic clock, each second. The log of mongod is on
+//   the wall clock, and these lines put it on the monotonic clock.
+// - socket, socket-end, socket-error: each socket of the driver by its role (monitor, rtt, pool),
+//   with its local address. The role comes from the stack of the call that makes the socket.
+// - connected: the first socket of the pool. The TCP client of the harness names its own socket so.
+// - sdam: each heartbeat, each change of the description of a server, and each change of the topology.
+// - cmap: each event of a connection pool, and each clear with its interruption of connections in use.
+// - command: each try of an operation, with its server. A retry is a second try with the same number.
+// - connecting: the start of the selection of the first server.
+// - ready: the reply to the first write once the monitor streams (idle, inflight), or the
+//   connection of the client (stream).
+// - sent, ack, fail: each operation by its sequence number, with its server or its error and labels.
+// - data, error: the end of the operation in flight, as the TCP client of the harness tells it.
+//   In idle mode, an error of the socket of the first pool connection is an error line too.
+// - done, deadline: the end of the client.
+//
+// The modes: idle sends one write, then holds the connections until --max-s. inflight sends one
+// write, waits for the file --go, sends one more operation into the fault, and holds the
+// connections after its end. stream sends a write each --interval-ms after the reply before, until
+// --max-s or SIGTERM. --before starts the client into a fault that holds already: its first
+// selection meets it.
+
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import net from "node:net";
+
+const now = () => process.hrtime.bigint();
+const emit = (ev, fields = {}, at = now()) => process.stdout.write(`${JSON.stringify({ ev, t: Number(at), ...fields })}\n`);
+
+const argv = process.argv.slice(2);
+const flag = (name) => {
+  const at = argv.indexOf(name);
+  return at === -1 ? undefined : argv[at + 1];
+};
+const [host, port] = argv;
+const mode = flag("--mode");
+if (host === undefined || port === undefined || !["idle", "inflight", "stream"].includes(mode)) {
+  emit("fail", { why: "client-mongo HOST PORT --mode idle|inflight|stream" });
+  process.exit(1);
+}
+const first = `${host}:${port}`;
+const hosts = [first, ...(flag("--hosts") ?? "").split(",").filter((each) => each !== "" && each !== first)];
+const set = flag("--set") ?? "rs0";
+const op = flag("--op") ?? "write";
+const interval = Number(flag("--interval-ms") ?? 50);
+const max = Number(flag("--max-s") ?? 120) * 1000;
+const go = flag("--go") ?? "/tmp/go";
+const w = flag("--w") === "1" ? 1 : "majority";
+const before = argv.includes("--before");
+const options = JSON.parse(flag("--options") ?? "{}");
+
+// ---- the two clocks: the wall clock of a log line of mongod goes onto the monotonic clock by them
+const clocks = () => {
+  const t = now();
+  emit("clocks", { real: Date.now() }, t);
+};
+clocks();
+setInterval(clocks, 1000).unref();
+
+// ---- each socket of the driver, by its role: the stack of the call that makes it names the caller
+const roleOf = (stack) => {
+  if (/measureRoundTripTime/.test(stack)) return "rtt";
+  if (/sdam[\\/]monitor\.js/.test(stack)) return "monitor";
+  if (/cmap[\\/]connection_pool\.js/.test(stack)) return "pool";
+  return "other";
+};
+let connected = null;
+const createConnection = net.createConnection;
+Error.stackTraceLimit = 50;
+net.createConnection = function (...args) {
+  const role = roleOf(new Error().stack ?? "");
+  const socket = createConnection.apply(this, args);
+  const server = `${args[0]?.host}:${args[0]?.port}`;
+  socket.once("connect", () => {
+    const local = `${socket.localAddress}:${socket.localPort}`;
+    emit("socket", { role, server, local });
+    if (role === "pool" && connected === null) {
+      connected = local;
+      emit("connected", { local });
+    }
+    socket.once("close", (hadError) => emit("socket-end", { role, server, local, error: hadError }));
+  });
+  socket.once("error", (error) => {
+    const local = socket.localPort === undefined ? null : `${socket.localAddress}:${socket.localPort}`;
+    const errno = error.code ?? error.errno ?? null;
+    emit("socket-error", { role, server, local, errno, message: error.message });
+    // the socket of the client in idle mode: its error is the detection, as for the TCP client
+    if (mode === "idle" && local !== null && local === connected) emit("error", { errno });
+  });
+  return socket;
+};
+
+// the driver loads after the patch, thus each of its sockets goes through it
+const { MongoClient } = await import("mongodb");
+const version = JSON.parse(readFileSync(new URL("./node_modules/mongodb/package.json", import.meta.url), "utf8")).version;
+
+const bootId = () => {
+  try {
+    return readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+  } catch {
+    return null;
+  }
+};
+emit("start", { boot_id: bootId(), client: "mongodb", driver: version, node: process.versions.node, mode, op, w, hosts, options });
+
+const uri = `mongodb://${hosts.join(",")}/?replicaSet=${set}`;
+const client = new MongoClient(uri, { ...options, writeConcern: { w }, monitorCommands: true });
+
+// ---- the driver's own events, each stamped as the driver emits it
+const failure = (error) =>
+  error === undefined || error === null
+    ? null
+    : { name: error.name, code: error.code ?? null, labels: [...(error.errorLabelSet ?? [])], message: error.message };
+const describe = (d) =>
+  d === undefined ? null : { type: d.type, setName: d.setName ?? null, electionId: d.electionId?.toHexString?.() ?? null, error: failure(d.error) };
+/** This promise resolves at the first awaited hello of a monitor: the stream of the monitor has begun. */
+let streamed = () => undefined;
+const streaming = new Promise((resolve) => {
+  streamed = resolve;
+});
+client.on("serverHeartbeatStarted", (e) => {
+  emit("sdam", { event: "heartbeat-started", address: e.connectionId, awaited: e.awaited });
+  if (e.awaited) streamed();
+});
+client.on("serverHeartbeatSucceeded", (e) =>
+  emit("sdam", { event: "heartbeat-succeeded", address: e.connectionId, awaited: e.awaited, duration: e.duration, primary: e.reply?.isWritablePrimary ?? null }),
+);
+client.on("serverHeartbeatFailed", (e) =>
+  emit("sdam", { event: "heartbeat-failed", address: e.connectionId, awaited: e.awaited, duration: e.duration, failure: failure(e.failure) }),
+);
+client.on("serverDescriptionChanged", (e) =>
+  emit("sdam", { event: "server-changed", address: e.address, previous: describe(e.previousDescription), next: describe(e.newDescription) }),
+);
+client.on("topologyDescriptionChanged", (e) => {
+  const primary = [...e.newDescription.servers.values()].find((d) => d.type === "RSPrimary")?.address ?? null;
+  emit("sdam", { event: "topology-changed", type: e.newDescription.type, primary });
+});
+client.on("serverOpening", (e) => emit("sdam", { event: "server-opening", address: e.address }));
+client.on("serverClosed", (e) => emit("sdam", { event: "server-closed", address: e.address }));
+for (const [event, name] of [
+  ["connectionPoolCreated", "pool-created"],
+  ["connectionPoolReady", "pool-ready"],
+  ["connectionPoolClosed", "pool-closed"],
+  ["connectionCreated", "created"],
+  ["connectionReady", "connection-ready"],
+  ["connectionCheckOutStarted", "checkout-started"],
+  ["connectionCheckedOut", "checked-out"],
+  ["connectionCheckedIn", "checked-in"],
+]) {
+  client.on(event, (e) => emit("cmap", { event: name, address: e.address, connectionId: e.connectionId ?? null }));
+}
+client.on("connectionPoolCleared", (e) => emit("cmap", { event: "pool-cleared", address: e.address, interruptInUseConnections: e.interruptInUseConnections ?? false }));
+client.on("connectionClosed", (e) => emit("cmap", { event: "closed", address: e.address, connectionId: e.connectionId, reason: e.reason, failure: failure(e.error) }));
+client.on("connectionCheckOutFailed", (e) => emit("cmap", { event: "checkout-failed", address: e.address, reason: e.reason, failure: failure(e.error) }));
+
+/** This function gives the sequence number of an operation from its comment. */
+const numberOf = (command) => {
+  const match = /^[wr]:(\d+)$/.exec(String(command?.comment ?? ""));
+  return match === null ? null : Number(match[1]);
+};
+const started = new Map();
+/** This map holds the server of the last try of each operation that succeeded, by its sequence number. */
+const lastServer = new Map();
+client.on("commandStarted", (e) => {
+  const n = numberOf(e.command);
+  if (n === null) return;
+  started.set(e.requestId, n);
+  emit("command", { event: "started", name: e.commandName, n, address: e.address, connectionId: e.connectionId, requestId: e.requestId });
+});
+client.on("commandSucceeded", (e) => {
+  if (!started.has(e.requestId)) return;
+  const n = started.get(e.requestId);
+  started.delete(e.requestId);
+  lastServer.set(n, e.address);
+  emit("command", { event: "succeeded", name: e.commandName, n, address: e.address, requestId: e.requestId, duration: e.duration });
+});
+client.on("commandFailed", (e) => {
+  if (!started.has(e.requestId)) return;
+  const n = started.get(e.requestId);
+  started.delete(e.requestId);
+  emit("command", { event: "failed", name: e.commandName, n, address: e.address, requestId: e.requestId, duration: e.duration, failure: failure(e.failure) });
+});
+
+// ---- the end of the client
+let stopped = false;
+const stop = (code = 0) => {
+  if (stopped) return;
+  stopped = true;
+  emit("done");
+  client.close().finally(() => setTimeout(() => process.exit(code), 50));
+};
+process.on("SIGTERM", () => stop(0));
+setTimeout(() => {
+  emit("deadline");
+  stop(0);
+}, max);
+
+const collection = client.db("cells").collection("w");
+// the writes of one client: each run starts its numbers at 1, and the field `run` keeps them apart
+const run = randomUUID();
+
+/**
+ * This function sends operation n: a write of its sequence number, or the read of the long
+ * document. Its stamp is before the call. It gives null for a reply, or the error.
+ */
+const operate = async (n) => {
+  const at = now();
+  const kind = op === "read-long" && mode === "inflight" && n > 1 ? "read" : "write";
+  const reply = kind === "read" ? collection.findOne({ _id: "long" }, { comment: `r:${n}` }) : collection.insertOne({ n, run }, { comment: `w:${n}` });
+  emit("sent", { n, kind }, at);
+  try {
+    const answer = await reply;
+    emit("ack", { n, kind, at: lastServer.get(n) ?? null, bytes: kind === "read" ? JSON.stringify(answer ?? {}).length : 0 });
+    return null;
+  } catch (error) {
+    emit("fail", { n, kind, ...failure(error) });
+    return error;
+  }
+};
+
+emit("connecting", { hosts });
+try {
+  await client.connect();
+} catch (error) {
+  emit("fail", { why: "connect", ...failure(error) });
+  emit("error", { errno: error.name, message: error.message });
+  stop(before ? 0 : 1);
+}
+if (stopped) await new Promise(() => undefined);
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+if (mode === "stream") {
+  emit("ready", { at: first });
+  for (let n = 1; !stopped; n += 1) {
+    await operate(n);
+    await sleep(interval);
+  }
+} else {
+  // the first write makes the connection of the pool. Its reply is the last data before the fault
+  const failed = await operate(1);
+  if (failed !== null) {
+    emit("error", { errno: failed.name, message: failed.message });
+    stop(1);
+  } else {
+    // the monitor sends its first awaited hello minHeartbeatFrequencyMS after its first check. A
+    // fault before that hello meets the start of the stream, not the stream that a cell measures
+    const awaited = await Promise.race([streaming.then(() => true), sleep(5000).then(() => false)]);
+    emit("ready", { reply: "ack", streaming: awaited });
+    if (mode === "inflight") {
+      await new Promise((resolve) => {
+        const wait = setInterval(() => {
+          if (!existsSync(go)) return;
+          clearInterval(wait);
+          resolve();
+        }, 2);
+      });
+      const error = await operate(2);
+      if (error === null) emit("data", { n: 1 });
+      else emit("error", { errno: error.name, message: error.message });
+    }
+  }
+}

package/image/mongo/npm-lock.json

@@ -0,0 +1,163 @@
+{
+  "name": "loom-harness-mongo-client",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "loom-harness-mongo-client",
+      "dependencies": {
+        "mongodb": "7.7.0"
+      }
+    },
+    "node_modules/@mongodb-js/saslprep": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@mongodb-js/saslprep/-/saslprep-1.6.1.tgz",
+      "integrity": "sha512-D4CQtk9IwjCLAvCf1xvHEod3960q8XMUzfmdRU9qjUNlHnesGuTOvJcOTaPm9koZ1caUKA2aTbszZiAkcmSgmg==",
+      "license": "MIT",
+      "dependencies": {
+        "sparse-bitfield": "^3.0.3"
+      }
+    },
+    "node_modules/@types/webidl-conversions": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/@types/webidl-conversions/-/webidl-conversions-7.0.3.tgz",
+      "integrity": "sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/whatwg-url": {
+      "version": "13.0.0",
+      "resolved": "https://registry.npmjs.org/@types/whatwg-url/-/whatwg-url-13.0.0.tgz",
+      "integrity": "sha512-N8WXpbE6Wgri7KUSvrmQcqrMllKZ9uxkYWMt+mCSGwNc0Hsw9VQTW7ApqI4XNrx6/SaM2QQJCzMPDEXE058s+Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/webidl-conversions": "*"
+      }
+    },
+    "node_modules/bson": {
+      "version": "7.3.3",
+      "resolved": "https://registry.npmjs.org/bson/-/bson-7.3.3.tgz",
+      "integrity": "sha512-oz3LwE3qGEhTCSyhzQRLY3Bj1NLOsjFMf6tcmY5J8M+3R7EVcmoBfSHWvjUK3yXCLDUsGpIuB3aQL4nDZ1EV/g==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/memory-pager": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/memory-pager/-/memory-pager-1.5.0.tgz",
+      "integrity": "sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==",
+      "license": "MIT"
+    },
+    "node_modules/mongodb": {
+      "version": "7.7.0",
+      "resolved": "https://registry.npmjs.org/mongodb/-/mongodb-7.7.0.tgz",
+      "integrity": "sha512-XG1xXEqyouAV8GCb3PuRaujofeXKpAJAPvXYWZgHl6Dz4QHSJ1nRLl0+GpqaLTwKvC0RFE9truOur34RNFY1nw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@mongodb-js/saslprep": "^1.5.0",
+        "bson": "^7.3.2",
+        "mongodb-connection-string-url": "^7.0.2"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@aws-sdk/credential-providers": "^3.806.0",
+        "@mongodb-js/zstd": "^7.0.0",
+        "gcp-metadata": "^7.0.1",
+        "kerberos": "^7.0.0",
+        "mongodb-client-encryption": "^7.2.0",
+        "snappy": "^7.3.2",
+        "socks": "^2.8.6"
+      },
+      "peerDependenciesMeta": {
+        "@aws-sdk/credential-providers": {
+          "optional": true
+        },
+        "@mongodb-js/zstd": {
+          "optional": true
+        },
+        "gcp-metadata": {
+          "optional": true
+        },
+        "kerberos": {
+          "optional": true
+        },
+        "mongodb-client-encryption": {
+          "optional": true
+        },
+        "snappy": {
+          "optional": true
+        },
+        "socks": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/mongodb-connection-string-url": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/mongodb-connection-string-url/-/mongodb-connection-string-url-7.0.2.tgz",
+      "integrity": "sha512-ZoS07RoFqpKYQwAk59qmrx8+jJHNHU30UjlU96QktiGn1ltvDr+vCznLX5DiUBLEpMAHatHNWV1nM/74ul66kA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/whatwg-url": "^13.0.0",
+        "whatwg-url": "^14.1.0"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/sparse-bitfield": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/sparse-bitfield/-/sparse-bitfield-3.0.3.tgz",
+      "integrity": "sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ==",
+      "license": "MIT",
+      "dependencies": {
+        "memory-pager": "^1.0.2"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",
+      "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
+      "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "14.2.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
+      "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^5.1.0",
+        "webidl-conversions": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}

package/image/mongo/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "loom-harness-mongo-client",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "mongodb": "7.7.0"
+  }
+}

package/image/mongo/stepdown-mongo.mjs

@@ -0,0 +1,37 @@
+// stepdown-mongo HOST:PORT STEP_DOWN_SECS CATCH_UP_SECS
+//
+// A planned step-down of a replica set: replSetStepDown to its primary, as a client sends it. The
+// script connects to the member and pings it first. Then it stamps t0 on CLOCK_MONOTONIC and sends
+// the command. It stamps t1 on the next turn of the event loop after the driver starts the command,
+// when the driver wrote it. Its last line is the stamps, as the injector prints them.
+
+import { MongoClient } from "mongodb";
+
+const now = () => Number(process.hrtime.bigint());
+const [address, stepDownSecs = "60", catchUpSecs = "10"] = process.argv.slice(2);
+const client = new MongoClient(`mongodb://${address}/?directConnection=true`, { serverSelectionTimeoutMS: 10000, monitorCommands: true });
+let written = null;
+const sent = new Promise((resolve) => {
+  client.on("commandStarted", (event) => {
+    if (event.commandName === "replSetStepDown") setImmediate(() => resolve(now()));
+  });
+});
+try {
+  await client.connect();
+  const admin = client.db("admin");
+  await admin.command({ ping: 1 });
+  const t0 = now();
+  const reply = admin.command({ replSetStepDown: Number(stepDownSecs), secondaryCatchUpPeriodSecs: Number(catchUpSecs) });
+  written = await sent;
+  let ok = false;
+  let error = null;
+  try {
+    ok = (await reply).ok === 1;
+  } catch (failure) {
+    // a primary that steps down closes its connections: the reply can be a network error
+    error = failure.message;
+  }
+  process.stdout.write(`${JSON.stringify({ action: "step-down", t0, t1: written, replied: now(), ok, error })}\n`);
+} finally {
+  await client.close().catch(() => undefined);
+}

package/image/procedures/Dockerfile

@@ -0,0 +1,13 @@
+# The procedures image of the harness: @procedures/client 0.3.0 and ws 8.22.0 on Node 24.21.0. Its WebSocket
+# client runs as a container in the client's network namespace, as the harness's own TCP client
+# does, and prints the same JSON lines (client-ws.mjs). A target runs the same image with the
+# script of the procedures server (server-ws.mjs), thus the client and the server share one
+# release of the package. The digest of the image and an npm lockfile pin them.
+# lab.ts stages the build context: this folder, under harness/image/procedures. The lockfile is
+# npm-lock.json here, because npm leaves each package-lock.json out of a published tarball.
+FROM node:24.21.0-alpine@sha256:ebfe2f90462722a7a4de65e91990e97fe0d401c70e0e762c5b53302f905ec1c1
+WORKDIR /opt/harness/procedures
+COPY harness/image/procedures/package.json ./
+COPY harness/image/procedures/npm-lock.json ./package-lock.json
+RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
+COPY harness/image/procedures/lines.mjs harness/image/procedures/client-ws.mjs harness/image/procedures/server-ws.mjs ./