@telnyx/agent-harness 0.1.0-beta.0

package/dist/node-adapter.js

@@ -0,0 +1,736 @@
+// dist/node-adapter.js
+import { applyMergePatch, decode, encode } from "@telnyx/edge-runtime/internal";
+import { mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { createRequire } from "node:module";
+var sqlite3Complete = null;
+var initStarted = false;
+function initWasmSplitter() {
+  if (initStarted) return;
+  initStarted = true;
+  void (async () => {
+    try {
+      const mod = await import("@sqlite.org/sqlite-wasm");
+      const s3 = await mod.default();
+      sqlite3Complete = s3.capi.sqlite3_complete;
+    } catch {
+    }
+  })();
+}
+function isWasmSplitterReady() {
+  return sqlite3Complete !== null;
+}
+function hasSqlContent(sql) {
+  let s = sql;
+  s = s.replace(/--[^\n]*/g, "");
+  s = s.replace(/\/\*[\s\S]*?\*\//g, "");
+  return s.trim().length > 0;
+}
+function splitSqlStatementsExact(sql) {
+  if (!sqlite3Complete) return null;
+  const complete = sqlite3Complete;
+  const statements = [];
+  let remaining = sql.trim();
+  while (remaining) {
+    let found = -1;
+    let pos = 0;
+    while ((pos = remaining.indexOf(";", pos)) !== -1) {
+      if (complete(remaining.substring(0, pos + 1))) {
+        found = pos + 1;
+        break;
+      }
+      pos++;
+    }
+    if (found === -1) {
+      const seg2 = remaining.replace(/;\s*$/, "").trim();
+      if (seg2 && hasSqlContent(seg2)) statements.push(seg2);
+      break;
+    }
+    const seg = remaining.substring(0, found).replace(/;$/, "").trim();
+    if (seg && hasSqlContent(seg)) statements.push(seg);
+    remaining = remaining.substring(found).trim();
+  }
+  return statements;
+}
+var require2 = createRequire(import.meta.url);
+initWasmSplitter();
+var MAX_PARAM_SIZE = 2 * 1024 * 1024;
+function adaptBinding(value) {
+  if (typeof value === "boolean") {
+    return value ? 1n : 0n;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && Number.isSafeInteger(value)) {
+    return BigInt(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  return value;
+}
+var SqlParameterTooLargeError = class extends Error {
+  constructor(actualSize) {
+    super(`SQL parameter size ${actualSize} bytes exceeds the 2 MiB limit`);
+    this.name = "SqlParameterTooLargeError";
+  }
+};
+var SqlTransactionControlError = class extends Error {
+  constructor(statement) {
+    super(
+      `SQL transaction control ("${statement}") is not allowed in exec(); use ctx.storage.transactionSync(() => { ... }) for atomic SQL`
+    );
+    this.name = "SqlTransactionControlError";
+  }
+};
+var SqlAsyncTransactionError = class extends Error {
+  constructor() {
+    super(
+      "transactionSync() callback must be synchronous; it returned a promise. Awaiting inside a SQL transaction would run statements outside it \u2014 do the async work before or after the transaction."
+    );
+    this.name = "SqlAsyncTransactionError";
+  }
+};
+function isPromiseLike(v) {
+  return v !== null && (typeof v === "object" || typeof v === "function") && typeof v.then === "function";
+}
+function assertSyncCallback(fn) {
+  if (fn.constructor && fn.constructor.name === "AsyncFunction") {
+    throw new SqlAsyncTransactionError();
+  }
+}
+var TXN_CONTROL_RE = /^(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i;
+function stripLeadingComments(sql) {
+  let s = sql;
+  for (; ; ) {
+    const before = s;
+    s = s.replace(/^\s+/, "");
+    if (s.startsWith("--")) {
+      const nl = s.indexOf("\n");
+      s = nl === -1 ? "" : s.slice(nl + 1);
+    } else if (s.startsWith("/*")) {
+      const end = s.indexOf("*/");
+      s = end === -1 ? "" : s.slice(end + 2);
+    }
+    if (s === before) return s;
+  }
+}
+function getStatements(query) {
+  const exact = isWasmSplitterReady() ? splitSqlStatementsExact(query) : null;
+  return exact ?? splitSqlStatements(query);
+}
+function assertNoTransactionControl(query) {
+  for (const statement of getStatements(query)) {
+    const match = TXN_CONTROL_RE.exec(stripLeadingComments(statement));
+    if (match) throw new SqlTransactionControlError(match[1].toUpperCase());
+  }
+}
+var SqliteSqlStorage = class {
+  db = null;
+  savepointDepth = 0;
+  asyncMisusePoisoned = false;
+  dbPath;
+  driver;
+  constructor(dbPath, opts) {
+    this.dbPath = dbPath;
+    this.driver = opts?.driver;
+  }
+  ensureOpen() {
+    if (this.db) return;
+    const dir = dirname(this.dbPath);
+    mkdirSync(dir, { recursive: true });
+    this.db = this.openDb(this.dbPath);
+    this.db.exec(`PRAGMA max_page_count = ${Math.floor(1073741824 / 4096)}`);
+  }
+  /**
+   * Opens the underlying database handle.
+   *
+   * Split out from ensureOpen so the DRIVER is substitutable (COMPUTE-691). The
+   * class only ever asks a driver for `prepare()`, `exec()` and `close()`, and a
+   * prepared statement for `run()` and `all()` — a deliberately small surface, so
+   * the metered SQLite addon can stand in for `node:sqlite` without this class
+   * knowing which one it has. That matters because the row counters SQLDB bills on
+   * are produced inside the engine and are unobtainable from `node:sqlite`.
+   *
+   * Default stays `node:sqlite`, so a caller that passes no driver behaves exactly
+   * as before.
+   */
+  openDb(dbPath) {
+    if (this.driver) return this.driver(dbPath);
+    const { DatabaseSync } = require2("node:sqlite");
+    return new DatabaseSync(dbPath);
+  }
+  exec(query, ...bindings) {
+    assertNoTransactionControl(query);
+    return this.execInternal(query, ...bindings);
+  }
+  /** `exec()` without the transaction-control guard — runtime-issued SQL only. */
+  execInternal(query, ...bindings) {
+    if (this.asyncMisusePoisoned) {
+      throw new SqlAsyncTransactionError();
+    }
+    for (const p of bindings) {
+      const size = getParamSize(p);
+      if (size > MAX_PARAM_SIZE) {
+        throw new SqlParameterTooLargeError(size);
+      }
+    }
+    this.ensureOpen();
+    const bound = bindings.map(adaptBinding);
+    const statements = getStatements(query);
+    if (statements.length === 0) {
+      return makeSinglePassCursor([]);
+    }
+    for (let i = 0; i < statements.length - 1; i++) {
+      this.db.prepare(statements[i]).run();
+    }
+    const last = this.db.prepare(statements[statements.length - 1]);
+    const rawRows = last.all(...bound);
+    const rows = rawRows.map(normalizeRowBlobs);
+    return makeSinglePassCursor(rows);
+  }
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  /**
+   * Run `fn` inside a runtime-owned SQLite savepoint: released on return,
+   * rolled back if `fn` throws. Savepoints (not `BEGIN`) so nesting works and
+   * an outer runtime transaction is never disturbed. Synchronous by design —
+   * an `await` inside the callback could interleave another turn's statements
+   * into this transaction, so the callback must be sync.
+   *
+   * An `async` callback (`transactionSync(async () => …)`) is rejected before it
+   * runs at all, so nothing it does happens inside or after the transaction.
+   *
+   * A plain callback that internally starts async work and returns its promise
+   * (`() => helper()`) is rejected after the fact (`isPromiseLike`), rolling the
+   * savepoint back. `helper`'s continuation still exists; `composeSqliteStorage`
+   * poisons the turn so that continuation's later `exec()` fails closed IF it
+   * resumes within the same turn. A continuation that resumes after the turn
+   * boundary is the documented residual — hence the hard rule: do not start
+   * async work inside a `transactionSync` body.
+   */
+  transactionSync(fn) {
+    this.ensureOpen();
+    assertSyncCallback(fn);
+    const name = `__telnyx_txn_${this.savepointDepth++}`;
+    this.db.exec(`SAVEPOINT ${name}`);
+    let released = false;
+    try {
+      const result = fn();
+      if (isPromiseLike(result)) {
+        this.asyncMisusePoisoned = true;
+        throw new SqlAsyncTransactionError();
+      }
+      this.db.exec(`RELEASE ${name}`);
+      released = true;
+      return result;
+    } finally {
+      this.savepointDepth--;
+      if (!released) {
+        try {
+          this.db.exec(`ROLLBACK TO ${name}`);
+          this.db.exec(`RELEASE ${name}`);
+        } catch {
+        }
+      }
+    }
+  }
+  /**
+   * Clear the async-misuse poison. Called at each turn boundary (via the
+   * composed storage's `_consumeInitDirty`), so the fail-closed state set by an
+   * escaped async `transactionSync` continuation lasts only for the remainder of
+   * the turn (or init phase) that caused it — never permanently.
+   */
+  clearAsyncMisusePoison() {
+    this.asyncMisusePoisoned = false;
+  }
+  /**
+   * Open a named savepoint and return its name. The low-level seam the
+   * sqlite-sidecar server (COMPUTE-484) uses to implement a nested
+   * `transactionSync` over HTTP: the client calls `/txn/begin` to open a
+   * savepoint, `/txn/exec` to run statements inside it, then `/txn/commit`
+   * (RELEASE) or `/txn/rollback` (ROLLBACK TO + RELEASE). Each level gets its
+   * own savepoint name (stacked), mirroring this class's own `transactionSync`
+   * nesting. NOT for in-process use — `transactionSync` is the supported
+   * in-process API; this is the escape hatch the sidecar server needs because
+   * the sync `fn` body lives in the client process, not here.
+   *
+   * The async-misuse poison is NOT checked here: the client checks it client-
+   * side and the server-side `transactionSync` (used by `/transaction`) checks
+   * it for its own path. `/txn/exec` goes through `exec()` (with the
+   * transaction-control guard), not `execInternal`.
+   */
+  beginSavepoint() {
+    this.ensureOpen();
+    const name = `__telnyx_txn_${this.savepointDepth++}`;
+    this.db.exec(`SAVEPOINT ${name}`);
+    return name;
+  }
+  /** Release (commit) a savepoint opened by `beginSavepoint`. */
+  releaseSavepoint(name) {
+    if (!this.db) return;
+    this.savepointDepth--;
+    try {
+      this.db.exec(`RELEASE ${name}`);
+    } catch {
+    }
+  }
+  /**
+   * Roll back to a savepoint opened by `beginSavepoint`, then release it so the
+   * name does not leak and (at depth 0) no transaction is left open.
+   */
+  rollbackSavepoint(name) {
+    if (!this.db) return;
+    this.savepointDepth--;
+    try {
+      this.db.exec(`ROLLBACK TO ${name}`);
+      this.db.exec(`RELEASE ${name}`);
+    } catch {
+    }
+  }
+  /**
+   * True if the connection currently has an open transaction. `VACUUM INTO`
+   * cannot run inside one, so the shipper checks this before vacuuming
+   * (COMPUTE-458). node:sqlite exposes no `inTransaction` flag, so probe it:
+   * a nested `BEGIN` throws iff a transaction is already open.
+   */
+  inTransaction() {
+    if (!this.db) return false;
+    try {
+      this.db.exec("BEGIN");
+    } catch {
+      return true;
+    }
+    try {
+      this.db.exec("ROLLBACK");
+    } catch {
+    }
+    return false;
+  }
+  /** Roll back an open transaction. No-op if none is open. */
+  rollback() {
+    if (!this.db) return;
+    try {
+      this.db.exec("ROLLBACK");
+    } catch {
+    }
+  }
+  vacuumInto(path) {
+    this.ensureOpen();
+    const escaped = path.replace(/'/g, "''");
+    this.db.exec("VACUUM INTO '" + escaped + "'");
+  }
+};
+function splitSqlStatements(sql) {
+  const statements = [];
+  let current = "";
+  let hasContent = false;
+  let inTriggerBody = false;
+  let atStatementStart = false;
+  let firstWord = null;
+  let isCreateTrigger = false;
+  let word = "";
+  const finishWord = () => {
+    if (!word) return;
+    const w = word.toUpperCase();
+    word = "";
+    if (firstWord === null) firstWord = w;
+    if (w === "TRIGGER" && firstWord === "CREATE") isCreateTrigger = true;
+    if (w === "BEGIN" && isCreateTrigger && !inTriggerBody) {
+      inTriggerBody = true;
+      atStatementStart = true;
+      return;
+    }
+    if (w === "END" && inTriggerBody && atStatementStart) {
+      inTriggerBody = false;
+    }
+    atStatementStart = false;
+  };
+  const flush = () => {
+    finishWord();
+    if (hasContent) statements.push(current.trim());
+    current = "";
+    hasContent = false;
+    inTriggerBody = false;
+    atStatementStart = true;
+    firstWord = null;
+    isCreateTrigger = false;
+  };
+  let i = 0;
+  const n = sql.length;
+  while (i < n) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === "-" && next === "-") {
+      finishWord();
+      while (i < n && sql[i] !== "\n") current += sql[i++];
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      finishWord();
+      current += "/*";
+      i += 2;
+      while (i < n && !(sql[i] === "*" && sql[i + 1] === "/")) current += sql[i++];
+      if (i < n) {
+        current += "*/";
+        i += 2;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      finishWord();
+      const quote = ch;
+      current += ch;
+      i++;
+      hasContent = true;
+      while (i < n) {
+        current += sql[i];
+        if (sql[i] === quote) {
+          if (sql[i + 1] === quote) {
+            current += sql[i + 1];
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "[") {
+      finishWord();
+      current += ch;
+      i++;
+      hasContent = true;
+      while (i < n) {
+        current += sql[i];
+        if (sql[i] === "]") {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (/[A-Za-z0-9_]/.test(ch)) {
+      word += ch;
+      current += ch;
+      hasContent = true;
+      i++;
+      continue;
+    }
+    finishWord();
+    if (ch === ";") {
+      if (inTriggerBody) {
+        current += ch;
+        atStatementStart = true;
+        i++;
+        continue;
+      }
+      flush();
+      i++;
+      continue;
+    }
+    current += ch;
+    if (!/\s/.test(ch)) hasContent = true;
+    i++;
+  }
+  flush();
+  return statements;
+}
+function getParamSize(p) {
+  if (p === null || p === void 0) return 0;
+  if (typeof p === "string") return Buffer.byteLength(p, "utf8");
+  if (p instanceof ArrayBuffer) return p.byteLength;
+  if (ArrayBuffer.isView(p)) return p.byteLength;
+  if (typeof p === "number" || typeof p === "boolean") return 8;
+  try {
+    return Buffer.byteLength(JSON.stringify(p), "utf8");
+  } catch {
+    return 0;
+  }
+}
+function normalizeRowBlobs(row) {
+  let copy;
+  for (const key of Object.keys(row)) {
+    const v = row[key];
+    if (v instanceof Uint8Array) {
+      copy ??= { ...row };
+      copy[key] = v.buffer.slice(
+        v.byteOffset,
+        v.byteOffset + v.byteLength
+      );
+    }
+  }
+  return copy ?? row;
+}
+function makeSinglePassCursor(rows) {
+  let pos = 0;
+  return {
+    toArray() {
+      const rest = rows.slice(pos);
+      pos = rows.length;
+      return rest;
+    },
+    [Symbol.iterator]() {
+      return {
+        next() {
+          return pos < rows.length ? { value: rows[pos++], done: false } : { value: void 0, done: true };
+        }
+      };
+    }
+  };
+}
+var AGENT_HARNESS_PORTS_VERSION = 2;
+var EVENT_RETAIN = 1e3;
+var TASK_DRAIN_BATCH = 100;
+var TASK_BACKOFF_BASE_MS = 1e3;
+var TASK_BACKOFF_CAP_MS = 5 * 6e4;
+function taskBackoffMs(attempts) {
+  return Math.min(TASK_BACKOFF_CAP_MS, TASK_BACKOFF_BASE_MS * 2 ** (attempts - 1));
+}
+function assertSchedulableDue(due) {
+  if (!Number.isFinite(due) || due < 0 || Math.floor(due) !== due) {
+    throw new Error(`task due must be a non-negative integer, got ${due}`);
+  }
+  if (String(due).length > 16) {
+    throw new Error(`task due ${due} exceeds 16 digits`);
+  }
+}
+function clone(value) {
+  return decode(encode(value));
+}
+function newBacking(databasePath) {
+  return {
+    messageSeq: 0,
+    messages: [],
+    eventSeq: 0,
+    events: [],
+    state: void 0,
+    tasks: /* @__PURE__ */ new Map(),
+    nextTaskId: 1,
+    sql: new SqliteSqlStorage(databasePath),
+    closed: false
+  };
+}
+var NodeAgentHarnessPorts = class _NodeAgentHarnessPorts {
+  options;
+  backing;
+  version = AGENT_HARNESS_PORTS_VERSION;
+  identity;
+  activation = Object.freeze({});
+  clock;
+  authorization;
+  environment;
+  messages;
+  state;
+  events;
+  tasks;
+  sql;
+  constructor(options, backing = newBacking(options.databasePath)) {
+    this.options = options;
+    this.backing = backing;
+    this.identity = Object.freeze({ id: options.id });
+    this.clock = Object.freeze({ now: () => options.now() });
+    this.authorization = options.authorization;
+    this.environment = Object.freeze({ ...options.environment ?? {} });
+    const last = ((count) => {
+      if (count === void 0) {
+        const message = this.backing.messages.at(-1);
+        return Promise.resolve(message === void 0 ? void 0 : clone(message));
+      }
+      if (count <= 0)
+        return Promise.resolve([]);
+      return Promise.resolve(clone(this.backing.messages.slice(-count)));
+    });
+    this.messages = Object.freeze({
+      append: async (message) => {
+        const safe = clone(message);
+        const stored = {
+          ...safe,
+          seq: this.backing.messageSeq + 1,
+          at: new Date(this.clock.now())
+        };
+        this.backing.messages.push(stored);
+        this.backing.messageSeq = stored.seq;
+        return stored.seq;
+      },
+      appendMany: async (messages) => {
+        const safe = clone(messages);
+        if (safe.length === 0)
+          return this.backing.messageSeq;
+        const base = this.backing.messageSeq;
+        const stored = safe.map((message, index) => ({
+          ...message,
+          seq: base + index + 1,
+          at: new Date(this.clock.now())
+        }));
+        this.backing.messages.push(...stored);
+        this.backing.messageSeq = base + stored.length;
+        return this.backing.messageSeq;
+      },
+      all: async () => clone(this.backing.messages),
+      last,
+      count: async () => this.backing.messageSeq
+    });
+    const currentState = () => this.backing.state === void 0 ? this.options.initialState() : clone(this.backing.state);
+    this.state = Object.freeze({
+      get: async () => currentState(),
+      merge: async (patch) => {
+        const current = currentState();
+        const next = applyMergePatch({ ...current }, patch);
+        this.backing.state = clone(next);
+        await this.options.onStateChanged?.(next, current);
+        return clone(next);
+      },
+      replace: async (state) => {
+        const prev = currentState();
+        const safe = clone(state);
+        this.backing.state = clone(safe);
+        await this.options.onStateChanged?.(safe, prev);
+        return clone(safe);
+      }
+    });
+    this.events = Object.freeze({
+      emit: async (type, payload) => {
+        const stored = {
+          seq: this.backing.eventSeq + 1,
+          type,
+          payload: clone(payload),
+          at: new Date(this.clock.now())
+        };
+        this.backing.events.push(stored);
+        if (this.backing.events.length > EVENT_RETAIN) {
+          this.backing.events.splice(0, this.backing.events.length - EVENT_RETAIN);
+        }
+        this.backing.eventSeq = stored.seq;
+        return stored.seq;
+      },
+      read: async (afterSeq = 0, limit) => {
+        if (limit !== void 0 && limit <= 0)
+          return [];
+        const selected = this.backing.events.filter((event) => event.seq > afterSeq);
+        return clone(limit === void 0 ? selected : selected.slice(0, limit));
+      },
+      count: async () => this.backing.eventSeq
+    });
+    const schedule = async (delaySeconds, method, payload, scheduleOptions) => {
+      const due = Math.floor(this.clock.now() + Math.max(0, delaySeconds * 1e3));
+      assertSchedulableDue(due);
+      const id = scheduleOptions?.id ?? `task-${this.backing.nextTaskId++}`;
+      const record = {
+        id,
+        name: method,
+        payload: clone(payload),
+        due,
+        everyMs: scheduleOptions?.everyMs,
+        attempts: 0,
+        maxRetries: scheduleOptions?.maxRetries ?? 5,
+        createdAt: new Date(this.clock.now())
+      };
+      this.backing.tasks.set(id, record);
+      return id;
+    };
+    this.tasks = Object.freeze({
+      delivery: "at-least-once",
+      queue: (method, payload, scheduleOptions) => schedule(0, method, payload, scheduleOptions),
+      schedule,
+      every: async (intervalSeconds, method, payload, scheduleOptions) => {
+        if (!(intervalSeconds > 0)) {
+          throw new Error(`every() requires a positive intervalSeconds, got ${intervalSeconds}`);
+        }
+        return schedule(intervalSeconds, method, payload, {
+          ...scheduleOptions,
+          everyMs: intervalSeconds * 1e3
+        });
+      },
+      cancel: async (id) => this.backing.tasks.delete(id),
+      list: async () => clone(Array.from(this.backing.tasks.values()))
+    });
+    this.sql = Object.freeze({
+      exec: (query, ...bindings) => this.backing.sql.exec(query, ...bindings),
+      transactionSync: (fn) => this.backing.sql.transactionSync(fn)
+    });
+  }
+  /** Reconstruct the adapter while retaining its in-process durable backing. */
+  reopen() {
+    return new _NodeAgentHarnessPorts(this.options, this.backing);
+  }
+  /**
+   * Pump due tasks for deterministic Node tests. This is a host control, not an
+   * AgentHarnessPorts method or a durable run-status API.
+   */
+  async runDue(dispatch) {
+    const now = this.clock.now();
+    const due = Array.from(this.backing.tasks.values()).sort((left, right) => left.due - right.due || left.id.localeCompare(right.id)).slice(0, TASK_DRAIN_BATCH);
+    let ran = 0;
+    for (const task of due) {
+      if (task.due > now)
+        break;
+      try {
+        await dispatch(clone(task));
+        if (this.backing.tasks.get(task.id) !== task) {
+          ran += 1;
+          continue;
+        }
+        if (task.everyMs && task.everyMs > 0) {
+          this.backing.tasks.set(task.id, {
+            ...task,
+            due: now + task.everyMs,
+            attempts: 0
+          });
+        } else {
+          this.backing.tasks.delete(task.id);
+        }
+      } catch {
+        const attempts = task.attempts + 1;
+        const current = this.backing.tasks.get(task.id);
+        if (current !== task) {
+          if (current === void 0) {
+            ran += 1;
+            continue;
+          }
+          if (attempts > current.maxRetries) {
+            this.backing.tasks.delete(task.id);
+          } else {
+            this.backing.tasks.set(task.id, {
+              ...current,
+              attempts,
+              due: Math.max(current.due, now + taskBackoffMs(attempts))
+            });
+          }
+          ran += 1;
+          continue;
+        }
+        if (attempts > task.maxRetries) {
+          this.backing.tasks.delete(task.id);
+        } else {
+          this.backing.tasks.set(task.id, {
+            ...task,
+            attempts,
+            due: now + taskBackoffMs(attempts)
+          });
+        }
+      }
+      ran += 1;
+    }
+    return ran;
+  }
+  /** Close the fixture-owned SQLite database. Idempotent. */
+  close() {
+    if (this.backing.closed)
+      return;
+    this.backing.closed = true;
+    this.backing.sql.close();
+  }
+};
+function createNodeAgentHarnessPorts(options) {
+  return new NodeAgentHarnessPorts(options);
+}
+export {
+  NodeAgentHarnessPorts,
+  createNodeAgentHarnessPorts
+};