c8ctl-plugin-nano 1.48.0 → 1.50.0

package/agentic-endpoint.mjs

@@ -0,0 +1,325 @@
+// The concrete host-connection agentic endpoint (ADR 0056; issue #160).
+//
+// #158 shipped the host-owned job-ownership protocol as an Effect *interface*
+// (`AgenticEndpoint` → `AgenticHandle` implementing `register`/`heartbeat`/
+// `deregister`/`claim`/`transcript`/`release`, identity explicit on every frame)
+// but no concrete transport — the `0.10.0` `@nanobpm/agentic` had no `claim`/
+// `release` presence frames to send. `@nanobpm/agentic` is now `^0.11.0`, which
+// lands families 8/9 (`claim`/`release`), the `claim-release`/`multi-instance`
+// negotiable features, and the additive negotiation module. This module is the
+// concrete wire against that bump: ONE multiplexed WebSocket connection over
+// which N supervised workers' presence + ownership + transcript frames ride,
+// each frame carrying its `instance` EXPLICITLY (never the connection id — the
+// assumption #154 structurally breaks).
+//
+// It produces a plain, Effect-free `RawEmitClient` (see `supervisor/src/emit.ts`)
+// that the supervisor bundle lifts into the Effect `AgenticHandle`. Everything on
+// the wire is CONSUMED through this plugin's single import surface (`agentic.mjs`
+// → `@nanobpm/agentic` + `@nanobpm/urban-agent-client`); nothing is re-declared.
+//
+// The supervisor's `superviseAgentic` owns reconnect (it calls the endpoint's
+// `connect` again on every drop) and the claim registry owns replay (the resync
+// re-`register`s + re-`claim`s before transcript resumes), so this client is thin
+// on purpose: one socket, encode-and-send, no buffering or reconnect of its own.
+
+import {
+  encodeFrame,
+  decodeFrame,
+  MAX_SEQ,
+  validatePayload,
+  negotiate,
+  LOCAL_ADVERTISEMENT,
+  loadAgenticClient,
+} from './agentic.mjs';
+import { buildAgenticUrl } from './work-channel.mjs';
+
+// Presence + ownership frames are facts — they ride the CONTROL lane so a
+// transcript storm on the bulk lane can never delay a claim/release (the QoS
+// ordering contract). Transcript chunks ride BULK.
+const CONTROL_LANE = 'control';
+const BULK_LANE = 'bulk';
+
+// A transcript stream name that encodes BOTH the owning instance and the jobKey,
+// so two workers' (or two jobs') transcript streams over the one connection can
+// never collide. `encodeURIComponent` on each segment makes the join
+// unambiguous regardless of what characters an instance/jobKey contains.
+function composeTranscriptStream(instance, jobKey) {
+  return `t/${encodeURIComponent(instance)}/${encodeURIComponent(jobKey)}`;
+}
+
+// Reverse of {@link composeTranscriptStream}. Returns null for a stream that is
+// not one of ours (a foreign/blackboard stream), so an inbound steer frame for
+// an unrecognised stream is dropped rather than misrouted.
+function parseTranscriptStream(stream) {
+  if (typeof stream !== 'string') return null;
+  const parts = stream.split('/');
+  if (parts.length !== 3 || parts[0] !== 't') return null;
+  try {
+    return { instance: decodeURIComponent(parts[1]), jobKey: decodeURIComponent(parts[2]) };
+  } catch {
+    return null;
+  }
+}
+
+// Drop undefined/empty attributes from a declared capability so the enrolment
+// attribute on `register` stays minimal (the S0 validator only requires
+// `capability` to be an object and tolerates extra fields).
+function cleanCapability(capability) {
+  const out = {};
+  if (capability && typeof capability === 'object') {
+    for (const [k, v] of Object.entries(capability)) {
+      if (v !== undefined && v !== null && v !== '') out[k] = v;
+    }
+  }
+  return out;
+}
+
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+
+// Compute the negotiated protocol against the peer's advertisement. There is no
+// wired advertisement-exchange frame in the `0.11.0` protocol yet, so a caller
+// that has not learned the peer's support passes nothing and we assume the peer
+// matches this build (full support) — additive negotiation still degrades
+// correctly the moment a real remote advertisement is supplied (an old hub that
+// never learned `claim`/`release` yields a negotiation without them, so those
+// methods report unsupported and the adapter omits them).
+function negotiatedSupport(remoteAdvertisement) {
+  const negotiated = negotiate(LOCAL_ADVERTISEMENT, remoteAdvertisement ?? LOCAL_ADVERTISEMENT);
+  return {
+    claimRelease:
+      negotiated.supportsFeature('claim-release') &&
+      negotiated.supportsFamily('claim') &&
+      negotiated.supportsFamily('release'),
+    // Inbound steer rides the relay lane as a delivery frame keyed by our
+    // transcript-stream naming; it is installable whenever relay is negotiated.
+    steer: negotiated.supportsFamily('relay'),
+  };
+}
+
+/**
+ * Open one multiplexed host connection and return a {@link RawEmitClient}.
+ *
+ * @param {object} params
+ * @param {string} params.url the resolved `ws(s)://…/agentic?token=…` channel URL
+ * @param {import('@nanobpm/urban-agent-client').TransportFactory} params.transportFactory
+ * @param {number} params.incarnation producer generation stamped on transcript
+ *   frames (strictly higher on each successive connection so a reconnected
+ *   producer fences its stale predecessor on the hub's incarnation ring)
+ * @param {{ claimRelease: boolean, steer: boolean }} params.support negotiated capabilities
+ * @param {{ warn?: Function, debug?: Function }} [params.logger]
+ * @returns {import('./supervisor.dist.js').RawEmitClient}
+ */
+function openHostConnection({ url, transportFactory, incarnation, support, logger }) {
+  const log = logger || {};
+  const openCbs = [];
+  const closeCbs = [];
+  let steerRoute = null;
+  let open = false;
+  let hasClosed = false;
+  let seq = 0;
+
+  // Monotonic uint32 sequence with wraparound — the relay resume-from-offset
+  // counter; mirrors the client lib's own seq handling.
+  const nextSeq = () => {
+    const s = seq;
+    seq = seq >= MAX_SEQ ? 0 : seq + 1;
+    return s;
+  };
+
+  let transport = null;
+  let closedFired = false;
+
+  // Notify registered onClose subscribers at most once, regardless of whether a
+  // caller-initiated close() or the transport's own onClose fires first. Higher
+  // layers (AgenticHandle.closed) must observe the drop even if the underlying
+  // transport delays or omits its close callback.
+  const fireClosed = () => {
+    if (closedFired) return;
+    closedFired = true;
+    open = false;
+    hasClosed = true;
+    for (const cb of closeCbs) cb();
+  };
+
+  const send = (lane, family, payload) => {
+    if (!open || transport === null) {
+      // Contract: a not-open transport throws synchronously so the adapter can
+      // surface a SupervisorError the best-effort caller swallows (the next
+      // resync replays it). Guard here too so we never encode into a dead socket.
+      throw new Error(`agentic transport not open (cannot send ${family})`);
+    }
+    const check = validatePayload(family, payload);
+    if (!check.ok) {
+      const detail = check.errors.map((e) => `${e.code}:${e.message}`).join(', ');
+      throw new Error(`invalid ${family} payload — ${detail}`);
+    }
+    transport.send(encodeFrame({ lane, family, seq: nextSeq(), payload }));
+  };
+
+  const handleInbound = (bytes) => {
+    if (steerRoute === null) return;
+    let frame;
+    try {
+      frame = decodeFrame(bytes);
+    } catch (err) {
+      log.debug?.(`agentic: undecodable inbound frame dropped — ${err?.message || err}`);
+      return;
+    }
+    // Inbound steer rides the relay family as a DELIVERY chunk ({ stream, offset,
+    // chunk }, no `op`) whose stream is one of our transcript streams; the stream
+    // carries the target instance + jobKey. A frame for a foreign stream is
+    // dropped, never misrouted.
+    if (frame.family !== 'relay') return;
+    const payload = frame.payload;
+    if (!payload || typeof payload !== 'object' || 'op' in payload) return;
+    const target = parseTranscriptStream(payload.stream);
+    if (target === null) return;
+    const chunk = typeof payload.chunk === 'string' ? textEncoder.encode(payload.chunk) : new Uint8Array(0);
+    try {
+      steerRoute(target.instance, target.jobKey, chunk);
+    } catch (err) {
+      log.debug?.(`agentic: steer route threw — ${err?.message || err}`);
+    }
+  };
+
+  transport = transportFactory(url, {
+    onOpen() {
+      open = true;
+      for (const cb of openCbs) cb();
+    },
+    onFrame(bytes) {
+      handleInbound(bytes);
+    },
+    onClose() {
+      fireClosed();
+    },
+    onError(err) {
+      // Non-fatal on its own; a close follows and drives the reconnect. Surface
+      // it for diagnosis only.
+      log.debug?.(`agentic transport error — ${err?.message || err}`);
+    },
+  });
+
+  return {
+    register(instance, capability) {
+      send(CONTROL_LANE, 'register', { instance, capability: cleanCapability(capability) });
+    },
+    heartbeat(instance) {
+      send(CONTROL_LANE, 'heartbeat', { instance });
+    },
+    deregister(instance, reason) {
+      send(CONTROL_LANE, 'deregister', reason ? { instance, reason } : { instance });
+    },
+    claim(instance, jobKey) {
+      send(CONTROL_LANE, 'claim', { instance, jobKey });
+    },
+    release(instance, jobKey) {
+      send(CONTROL_LANE, 'release', { instance, jobKey });
+    },
+    transcript(instance, jobKey, chunk) {
+      send(BULK_LANE, 'relay', {
+        op: 'produce',
+        stream: composeTranscriptStream(instance, jobKey),
+        incarnation,
+        chunk: textDecoder.decode(chunk),
+      });
+    },
+    onSteer(route) {
+      steerRoute = route;
+    },
+    onOpen(cb) {
+      // If the transport is already open (injected/synchronous factories can
+      // open before this registers), fire immediately — otherwise the queued
+      // callback never runs and connect() hangs waiting for `opened`.
+      if (open) {
+        cb();
+        return;
+      }
+      openCbs.push(cb);
+    },
+    onClose(cb) {
+      // Mirror onOpen: if the transport already closed (injected/synchronous
+      // factories can close before this registers), fire immediately —
+      // otherwise a close-before-open is never observable and connect() hangs
+      // waiting for `opened` (neither onOpen nor onClose would ever run).
+      if (hasClosed) {
+        cb();
+        return;
+      }
+      closeCbs.push(cb);
+    },
+    close() {
+      // Mark closed and drop the transport reference locally so post-close
+      // send() reliably throws (the not-open contract) even if the underlying
+      // transport delays or omits its close callback.
+      open = false;
+      hasClosed = true;
+      const t = transport;
+      transport = null;
+      try {
+        t?.close();
+      } catch {
+        /* idempotent best-effort teardown — never throw on close */
+      }
+      // Notify subscribers ourselves — never rely on the transport re-entering
+      // onClose after a caller-initiated teardown (it may delay or omit it),
+      // which would leave AgenticHandle.closed pending indefinitely. Idempotent:
+      // a subsequent transport onClose is a no-op.
+      fireClosed();
+    },
+    supportsClaimRelease: support.claimRelease,
+    supportsSteer: support.steer,
+  };
+}
+
+/**
+ * Build the `RawEmitConnect` factory the supervisor's `makeAgenticEndpoint`
+ * lifts into `deps.agenticEndpoint`. Each returned `connect()` opens ONE fresh
+ * multiplexed host connection (a reconnect calls it again), stamped with a
+ * strictly-increasing incarnation so a reconnected transcript producer fences
+ * its stale predecessor.
+ *
+ * The WebSocket transport is loaded once through the plugin's single import
+ * surface (`loadAgenticClient()` — which installs the source→dist resolve hook so
+ * the client is importable under stock Node); a test injects its own
+ * `transportFactory` and never touches the real client.
+ *
+ * @param {object} opts
+ * @param {string} opts.url the app's HTTP(S) base URL (channel served same-port at `/agentic`)
+ * @param {string} [opts.token] ADR 0028 identity token (carried as `?token=`)
+ * @param {string} [opts.credential] capability credential (carried as `?capability=`)
+ * @param {import('@nanobpm/agentic/protocol').ProtocolAdvertisement} [opts.remoteAdvertisement]
+ *   the peer's advertised support; omit to assume full support (see {@link negotiatedSupport})
+ * @param {number} [opts.incarnationBase] first transcript incarnation (default `Date.now()`)
+ * @param {import('@nanobpm/urban-agent-client').TransportFactory} [opts.transportFactory] injectable transport (tests)
+ * @param {{ warn?: Function, debug?: Function }} [opts.logger]
+ * @returns {Promise<() => import('./supervisor.dist.js').RawEmitClient>} a synchronous `connect` factory
+ */
+export async function createRawEmitConnect(opts) {
+  const { url, token, credential, remoteAdvertisement, incarnationBase, transportFactory, logger } = opts || {};
+  if (typeof url !== 'string' || url.trim() === '') {
+    throw new Error('createRawEmitConnect requires an agentic channel base url');
+  }
+
+  const channelUrl = buildAgenticUrl(url, { token, credential });
+  const factory = transportFactory ?? (await loadAgenticClient()).websocketTransport;
+  const support = negotiatedSupport(remoteAdvertisement);
+
+  // Strictly-increasing per-connection incarnation so successive reconnects fence
+  // their predecessor on the hub's transcript ring (a monotonic takeover counter,
+  // seeded from the clock so a later-started process starts ahead).
+  let generation = Number.isInteger(incarnationBase) && incarnationBase >= 0 ? incarnationBase : Date.now();
+
+  return () =>
+    openHostConnection({
+      url: channelUrl,
+      transportFactory: factory,
+      incarnation: generation++,
+      support,
+      logger,
+    });
+}
+
+// Exposed for unit tests / reuse.
+export { composeTranscriptStream, parseTranscriptStream, negotiatedSupport, cleanCapability };

package/agentic.mjs

@@ -58,6 +58,12 @@ export {
   validateVocabDocument,
   // per-family payload contracts
   validatePayload,
+  // additive capability/version negotiation (claim/release degrade gracefully)
+  PROTOCOL_VERSION,
+  PROTOCOL_FEATURES,
+  LOCAL_ADVERTISEMENT,
+  parseAdvertisement,
+  negotiate,
   // language-neutral hex helpers (used to hold the codec to the corpus)
   bytesToHex,
   hexToBytes,

package/c8ctl-plugin.js

@@ -3239,6 +3239,172 @@ function loadSupervisorRuntime() {
   return _supervisorRuntime;
 }
 
+// Build the concrete single host-connection agentic endpoint (issue #160) the
+// supervisor consumes as `deps.agenticEndpoint`. Composes the raw-JS wire client
+// (`agentic-endpoint.mjs`, one multiplexed connection over `@nanobpm/agentic`
+// `^0.11.0`'s `claim`/`release` families, consumed through this plugin's single
+// import surface) with the supervisor bundle's `makeAgenticEndpoint` adapter,
+// which lifts the plain client into the Effect `AgenticHandle`. This is the ONE
+// place the ownership/presence/transcript wire is instantiated for the
+// single-owner runtime. It is the eventual replacement for the per-worker
+// `createWorkChannel` fan-out — where every `nano work` process opened its own
+// socket for a single identity — but that per-worker flip is deferred, so
+// `createWorkChannel` is still imported and used elsewhere in this file for now.
+// The ~100 KB Effect surface loads lazily on the first `createAgenticEndpoint()`
+// call (which awaits `loadSupervisorRuntime()`) — not at module load and not
+// deferred to `endpoint.connect()` — so a plugin invocation that never runs an
+// agentic connection never pays for it.
+//
+// @param {object} opts see `createRawEmitConnect` in `agentic-endpoint.mjs`
+//   (`url`, `token`, `credential`, optional `remoteAdvertisement`, `logger`, …)
+// @returns {Promise<import('./supervisor.dist.js').AgenticEndpoint>}
+async function createAgenticEndpoint(opts) {
+  const { makeAgenticEndpoint } = await loadSupervisorRuntime();
+  const { createRawEmitConnect } = await import('./agentic-endpoint.mjs');
+  const connect = await createRawEmitConnect(opts);
+  return makeAgenticEndpoint(connect);
+}
+
+// Compose the monolith's real edges into the single-owner supervisor runtime's
+// injected ports (issue #156) — the live-cut-over seam that turns the #154
+// runtime interface into a runnable host owner. This is the ONE place the
+// concrete `EngineClient`/`ReconcileReader`/`JobRunner`/`Logger` are assembled
+// for the runtime, the direct analogue of `createAgenticEndpoint` for the
+// ownership wire:
+//
+//   - engine          → `supervisor-engine.mjs` (direct `POST /v2/jobs/activation`
+//                        + `PATCH /v2/jobs/{key}/timeout`), REPLACING the SDK job
+//                        worker per the issue, base/auth derived from the SAME
+//                        `resolveWorkerEngineBase` chain the reconcile read uses;
+//   - reconcileReader → the existing `defaultC8RestReader` (a keep-alive,
+//                        IPv4-first `httpC8RestReader`), whose shape already IS a
+//                        `RawReconcileReader`;
+//   - scan            → `demand.scanTaskDefinitions` via `scanAgentTaskLeaves`,
+//                        the single agentic-leaf source of truth (no drift);
+//   - logger          → `getLogger()`;
+//   - runner          → the caller's raw `{ run(job): Promise<void> }` (the
+//                        `runAgentJob`-owning-completion harness). REQUIRED to
+//                        actually execute; a test injects a fake.
+//
+// Returns everything a JS caller needs to run `makeSupervisor` — the assembled
+// `deps`, the seeded `registry` (so workers can be add/remove'd live), and the
+// `makeSupervisor` + `Effect` handles from the bundle. NOTE (deferred, issue
+// #156): the actual hot-path flip — deleting the per-type SDK pollers, the
+// process-wide `singleFlight`, and the per-process reconcile crawl in `workAgent`
+// and running `makeSupervisor(deps).run` as the single per-host owner — is NOT
+// wired here; it deletes battle-tested crash-safety code and can only be
+// validated against a live engine, so it is intentionally left as the follow-up
+// this seam unblocks. Constructing deps is side-effect-free (no socket opens, no
+// activation) until the caller forks `supervisor.run`.
+//
+// @param {object} opts
+// @param {{ run(job): Promise<void> }} opts.runner  raw job runner (required to run)
+// @param {object} [opts.camunda]        SDK client, for base/auth derivation
+// @param {{ baseUrl: string, token?: string }} [opts.restConfig]  explicit REST config (else derived)
+// @param {Record<string,string>} [opts.authHeaders]  ready-made auth header map
+// @param {string} [opts.worker]         worker id stamped on activations
+// @param {Array<{id: string, types?: Iterable<string>, capacity?: number}>} [opts.workers]  registry seed
+// @param {string} [opts.autoWorkerId]   worker whose types the reconcile loop rewrites
+// @param {import('./supervisor.dist.js').AgenticEndpoint} [opts.agenticEndpoint]  the ownership wire
+// @param {object} [opts.agenticConfig]  reconnect backoff config
+// @param {string} [opts.scope]          reconcile process-id scope narrowing
+// @param {object} [opts.config]         partial SupervisorConfig overrides
+// @param {{ searchProcessDefinitionKeys: Function, getProcessDefinitionXml: Function }} [opts.reconcileReader]  raw reconcile reader overriding the default keep-alive `defaultC8RestReader`
+// @param {typeof fetch} [opts.fetchImpl] injected fetch (tests)
+// @param {NodeJS.ProcessEnv} [opts.env]
+// @returns {Promise<{ deps: object, registry: object, makeSupervisor: Function, Effect: object, Fiber: object }>}
+async function createSupervisorDeps(opts = {}) {
+  const {
+    runner,
+    camunda,
+    restConfig,
+    authHeaders,
+    worker,
+    workers = [],
+    autoWorkerId,
+    agenticEndpoint,
+    agenticConfig,
+    scope = '',
+    config,
+    fetchImpl,
+    env = process.env,
+  } = opts;
+  if (!runner || typeof runner.run !== 'function') {
+    throw new TypeError('createSupervisorDeps: `runner` must be a raw job runner `{ run(job): Promise<void> }`');
+  }
+
+  const rt = await loadSupervisorRuntime();
+  const { demand } = await import('./agentic.mjs');
+  const { createRawEngineClient } = await import('./supervisor-engine.mjs');
+
+  // Base/auth: the single canonical worker-engine chain (explicit restConfig →
+  // profile restAddress → localhost), ALWAYS run through the token same-origin
+  // gate — even when a caller pins the base via `restConfig` — so token
+  // derivation (env/config REST token, same-origin agentic fallback) is never
+  // bypassed. An explicit `restConfig.token` still wins over the gate's derived
+  // token; a caller passing only `{ baseUrl }` no longer silently skips auth.
+  const gated = resolveBrokerRestConfig(env, {
+    baseUrl:
+      (restConfig && restConfig.baseUrl) ||
+      (camunda ? resolveWorkerEngineBase(camunda, env) : undefined),
+  });
+  const rc = {
+    baseUrl: gated.baseUrl,
+    token: (restConfig && restConfig.token) || gated.token,
+  };
+
+  // Auth: an explicit ready-made `authHeaders` map wins; else a bare REST token
+  // (`rc.token`) is applied by the engine client itself; else — on OAuth/basic
+  // profiles where no bare token exists — derive the headers from the SDK client's
+  // `getAuthHeaders()` (mirroring resolveLinkedPromptSource). Guarded so an older or
+  // atypical client runtime degrades to the token/none path rather than throw.
+  let resolvedAuthHeaders = authHeaders;
+  if (!resolvedAuthHeaders && !rc.token && camunda && typeof camunda.getAuthHeaders === 'function') {
+    // Resolve PER CALL, not once at startup: SDK auth headers (e.g. an OAuth
+    // bearer) rotate on token refresh, so a long-lived supervisor must re-derive
+    // them on every engine call — a cached startup snapshot would silently expire
+    // and fail activations. Pass a resolver the engine client invokes per request.
+    resolvedAuthHeaders = async () => {
+      try {
+        return await camunda.getAuthHeaders();
+      } catch {
+        return undefined;
+      }
+    };
+  }
+
+  const engine = rt.makeEngineClient(
+    createRawEngineClient({ baseUrl: rc.baseUrl, token: rc.token, authHeaders: resolvedAuthHeaders, worker, fetchImpl }),
+  );
+  // `reconcileReader` (a raw `{ searchProcessDefinitionKeys, getProcessDefinitionXml }`)
+  // may be injected to override the default keep-alive `httpC8RestReader` — the
+  // caller may already hold one, and a test drives the crawl without a socket.
+  const rawReader = opts.reconcileReader || (await defaultC8RestReader(rc));
+  const reconcileReader = rt.makeReconcileReader(rawReader);
+  const scan = (xml) => scanAgentTaskLeaves(xml, demand.scanTaskDefinitions);
+  const logger = rt.asLogger(getLogger());
+
+  const registry = await rt.Effect.runPromise(rt.makeRegistry());
+  for (const w of workers) {
+    await rt.Effect.runPromise(registry.add(w.id, w.types || [], w.capacity ?? 1));
+  }
+
+  const deps = rt.makeSupervisorDeps({
+    engine,
+    runner: rt.makeJobRunner(runner),
+    registry,
+    reconcileReader,
+    scan,
+    logger,
+    autoWorkerId,
+    agenticEndpoint,
+    agenticConfig,
+    config: scope ? { ...config, scope } : config,
+  });
+
+  return { deps, registry, makeSupervisor: rt.makeSupervisor, Effect: rt.Effect, Fiber: rt.Fiber };
+}
+
 // Build the content endpoint. Per issue #63 / nano-bpm #759 the non-binary
 // `/content` variant is deprecated for non-RPA types (Markdown → 406), so the
 // worker always fetches `/content/binary`.
@@ -12556,6 +12722,8 @@ export {
   readDeployedAgentJobTypes,
   resolveAutoJobTypes,
   loadSupervisorRuntime,
+  createAgenticEndpoint,
+  createSupervisorDeps,
   enableEngineHappyEyeballs,
   preferIpv4Resolution,
   ipv4FirstNodeOptions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c8ctl-plugin-nano",
-  "version": "1.48.0",
+  "version": "1.50.0",
   "type": "module",
   "description": "c8ctl plugin to start, inspect, and stop a local Nano BPM (nanobpmn) cluster",
   "main": "c8ctl-plugin.js",
@@ -24,6 +24,8 @@
     "platforms.mjs",
     "agentic.mjs",
     "agentic-loader-hook.mjs",
+    "agentic-endpoint.mjs",
+    "supervisor-engine.mjs",
     "work-channel.mjs",
     "work-relay.mjs",
     "work-buffer.mjs",
@@ -67,12 +69,12 @@
   },
   "optionalDependencies": {
     "node-pty": "^1.0.0",
-    "@nanobpm/c8ctl-plugin-nano-darwin-arm64": "1.48.0",
-    "@nanobpm/c8ctl-plugin-nano-darwin-x64": "1.48.0",
-    "@nanobpm/c8ctl-plugin-nano-linux-x64": "1.48.0",
-    "@nanobpm/c8ctl-plugin-nano-linux-arm64": "1.48.0",
-    "@nanobpm/c8ctl-plugin-nano-linux-armv7": "1.48.0",
-    "@nanobpm/c8ctl-plugin-nano-linux-armv6": "1.48.0",
-    "@nanobpm/c8ctl-plugin-nano-win32-x64": "1.48.0"
+    "@nanobpm/c8ctl-plugin-nano-darwin-arm64": "1.50.0",
+    "@nanobpm/c8ctl-plugin-nano-darwin-x64": "1.50.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-x64": "1.50.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-arm64": "1.50.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-armv7": "1.50.0",
+    "@nanobpm/c8ctl-plugin-nano-linux-armv6": "1.50.0",
+    "@nanobpm/c8ctl-plugin-nano-win32-x64": "1.50.0"
   }
 }