@tbrandenburg/node-red-agents 0.1.3 → 0.1.5

package/nodes/agent/lib/execution/scheduler.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 // Framework-agnostic bounded-concurrency FIFO scheduler. Deliberately has no
 // Node-RED dependency (same reasoning as lib/execution/lifecycle.js) so it's
@@ -9,89 +9,90 @@
 // model already gives independent executions for free (see AGENTS fan-out
 // spec); this class only adds the bound + the waiting line on top of that.
 class ExecutionScheduler {
-    constructor({ concurrency, onStart, onQueued, onSettled } = {}) {
-        this.concurrency = Number.isFinite(concurrency) && concurrency > 0 ? Math.floor(concurrency) : 1;
-        this.onStart = onStart; // (item) => Promise -- required
-        this.onQueued = onQueued; // (item) => void -- optional
-        // Called after this item is removed from `active` AND after any
-        // queued item that became eligible to start has already been
-        // started -- i.e. the scheduler's own bookkeeping is fully
-        // settled, so a status render triggered from here is never stale.
-        this.onSettled = onSettled; // (item) => void -- optional
-        this.queue = [];
-        this.active = new Map();
-    }
+  constructor({ concurrency, onStart, onQueued, onSettled } = {}) {
+    this.concurrency =
+      Number.isFinite(concurrency) && concurrency > 0 ? Math.floor(concurrency) : 1;
+    this.onStart = onStart; // (item) => Promise -- required
+    this.onQueued = onQueued; // (item) => void -- optional
+    // Called after this item is removed from `active` AND after any
+    // queued item that became eligible to start has already been
+    // started -- i.e. the scheduler's own bookkeeping is fully
+    // settled, so a status render triggered from here is never stale.
+    this.onSettled = onSettled; // (item) => void -- optional
+    this.queue = [];
+    this.active = new Map();
+  }
 
-    get activeCount() {
-        return this.active.size;
-    }
+  get activeCount() {
+    return this.active.size;
+  }
 
-    get queuedCount() {
-        return this.queue.length;
-    }
+  get queuedCount() {
+    return this.queue.length;
+  }
 
-    activeIds() {
-        return Array.from(this.active.keys());
-    }
+  activeIds() {
+    return Array.from(this.active.keys());
+  }
 
-    // item must have a unique `executionId` property; anything else on it
-    // is opaque to the scheduler (agent.js stores msg/send/done/resolved).
-    submit(item) {
-        if (this.active.size < this.concurrency) {
-            this._start(item);
-        } else {
-            this.queue.push(item);
-            if (this.onQueued) this.onQueued(item);
-        }
+  // item must have a unique `executionId` property; anything else on it
+  // is opaque to the scheduler (agent.js stores msg/send/done/resolved).
+  submit(item) {
+    if (this.active.size < this.concurrency) {
+      this._start(item);
+    } else {
+      this.queue.push(item);
+      if (this.onQueued) this.onQueued(item);
     }
+  }
 
-    _start(item) {
-        this.active.set(item.executionId, item);
-        Promise.resolve(this.onStart(item)).finally(() => {
-            this.active.delete(item.executionId);
-            this._advance();
-            if (this.onSettled) this.onSettled(item);
-        });
-    }
+  _start(item) {
+    this.active.set(item.executionId, item);
+    Promise.resolve(this.onStart(item)).finally(() => {
+      this.active.delete(item.executionId);
+      this._advance();
+      if (this.onSettled) this.onSettled(item);
+    });
+  }
 
-    _advance() {
-        while (this.active.size < this.concurrency && this.queue.length > 0) {
-            this._start(this.queue.shift());
-        }
+  _advance() {
+    while (this.active.size < this.concurrency && this.queue.length > 0) {
+      this._start(this.queue.shift());
     }
+  }
 
-    // Removes every still-queued item (FIFO order) without ever starting
-    // them, calling onCancel for each. Used on node close/redeploy so
-    // queued-but-not-yet-started messages get a clean done() instead of
-    // hanging forever. Does not touch active executions -- that's the
-    // caller's responsibility (terminate() belongs to the runtime layer).
-    drainQueue(onCancel) {
-        const remaining = this.queue.splice(0, this.queue.length);
-        if (onCancel) remaining.forEach((item) => onCancel(item));
-        return remaining;
-    }
+  // Removes every still-queued item (FIFO order) without ever starting
+  // them, calling onCancel for each. Used on node close/redeploy so
+  // queued-but-not-yet-started messages get a clean done() instead of
+  // hanging forever. Does not touch active executions -- that's the
+  // caller's responsibility (terminate() belongs to the runtime layer).
+  drainQueue(onCancel) {
+    const remaining = this.queue.splice(0, this.queue.length);
+    if (onCancel) remaining.forEach((item) => onCancel(item));
+    return remaining;
+  }
 
-    // On-demand single-item cancellation (the `terminate` operation), as
-    // opposed to drainQueue's "everything, node is closing" semantics.
-    // Returns:
-    //   { status: 'active', item }  -- still running; caller must kill the
-    //                                  actual process/runtime itself, this
-    //                                  scheduler has no handle on that.
-    //   { status: 'queued', item }  -- removed from the queue before it ever
-    //                                  started; caller must still settle the
-    //                                  item's own done()/send() itself, same
-    //                                  as drainQueue's onCancel.
-    //   null                        -- unknown executionId (already finished,
-    //                                  or never existed).
-    cancel(executionId) {
-        if (this.active.has(executionId)) {
-            return { status: 'active', item: this.active.get(executionId) };
-        }
-        const idx = this.queue.findIndex((item) => item.executionId === executionId);
-        if (idx === -1) return null;
-        const [item] = this.queue.splice(idx, 1);
-        return { status: 'queued', item };
+  // On-demand single-item cancellation (the `terminate` operation), as
+  // opposed to drainQueue's "everything, node is closing" semantics.
+  // Returns:
+  //   { status: 'active', item }  -- still running; caller must kill the
+  //                                  actual process/runtime itself, this
+  //                                  scheduler has no handle on that.
+  //   { status: 'queued', item }  -- removed from the queue before it ever
+  //                                  started; caller must still settle the
+  //                                  item's own done()/send() itself, same
+  //                                  as drainQueue's onCancel.
+  //   null                        -- unknown executionId (already finished,
+  //                                  or never existed).
+  cancel(executionId) {
+    if (this.active.has(executionId)) {
+      return { status: "active", item: this.active.get(executionId) };
     }
+    const idx = this.queue.findIndex((item) => item.executionId === executionId);
+    if (idx === -1) return null;
+    const [item] = this.queue.splice(idx, 1);
+    return { status: "queued", item };
+  }
 }
 
 module.exports = { ExecutionScheduler };

package/nodes/agent/lib/execution/status.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 // Pure function computing the node.status() shape from current scheduler
 // counts plus the last terminal outcome. Kept separate from agent.js so the
@@ -8,17 +8,17 @@
 // lastTerminal: undefined (never run) | 'completed' | 'failed' | 'timeout'
 // lastText: optional override for the failed-state text (e.g. 'bad config')
 function computeNodeStatus({ active, queued, lastTerminal, lastText }) {
-    if (active > 0 || queued > 0) {
-        let text = `${active} running`;
-        if (queued > 0) text += ` \u00b7 ${queued} queued`;
-        return { fill: 'blue', shape: 'dot', text };
-    }
+  if (active > 0 || queued > 0) {
+    let text = `${active} running`;
+    if (queued > 0) text += ` \u00b7 ${queued} queued`;
+    return { fill: "blue", shape: "dot", text };
+  }
 
-    if (lastTerminal === 'completed') return { fill: 'green', shape: 'dot', text: 'completed' };
-    if (lastTerminal === 'failed') return { fill: 'red', shape: 'ring', text: lastText || 'failed' };
-    if (lastTerminal === 'timeout') return { fill: 'yellow', shape: 'ring', text: 'timeout' };
+  if (lastTerminal === "completed") return { fill: "green", shape: "dot", text: "completed" };
+  if (lastTerminal === "failed") return { fill: "red", shape: "ring", text: lastText || "failed" };
+  if (lastTerminal === "timeout") return { fill: "yellow", shape: "ring", text: "timeout" };
 
-    return {}; // idle, never run -- no status
+  return {}; // idle, never run -- no status
 }
 
 module.exports = { computeNodeStatus };

package/nodes/agent/lib/mcp/normalize.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 // Generic mcpServers[] (see AGENTS node schema) -> OpenCode's keyed `mcp`
 // config object, as verified against opencode's real config schema:
@@ -7,25 +7,25 @@
 //
 // Each agent adapter owns its own translation; this module is OpenCode's.
 function toOpenCodeMcp(mcpServers) {
-    const out = {};
-    if (!Array.isArray(mcpServers)) return out;
+  const out = {};
+  if (!Array.isArray(mcpServers)) return out;
 
-    for (const server of mcpServers) {
-        if (!server || typeof server.name !== 'string' || !server.name.trim()) continue;
+  for (const server of mcpServers) {
+    if (!server || typeof server.name !== "string" || !server.name.trim()) continue;
 
-        if (server.type === 'remote') {
-            if (typeof server.url !== 'string' || !server.url.trim()) continue;
-            out[server.name] = { type: 'remote', url: server.url, enabled: true };
-        } else if (server.type === 'local') {
-            if (typeof server.command !== 'string' || !server.command.trim()) continue;
-            const args = Array.isArray(server.args) ? server.args : [];
-            out[server.name] = { type: 'local', command: [server.command, ...args], enabled: true };
-        }
-        // Unknown types are silently skipped -- validate() at the adapter
-        // level is responsible for surfacing a clear error before execution.
+    if (server.type === "remote") {
+      if (typeof server.url !== "string" || !server.url.trim()) continue;
+      out[server.name] = { type: "remote", url: server.url, enabled: true };
+    } else if (server.type === "local") {
+      if (typeof server.command !== "string" || !server.command.trim()) continue;
+      const args = Array.isArray(server.args) ? server.args : [];
+      out[server.name] = { type: "local", command: [server.command, ...args], enabled: true };
     }
+    // Unknown types are silently skipped -- validate() at the adapter
+    // level is responsible for surfacing a clear error before execution.
+  }
 
-    return out;
+  return out;
 }
 
 module.exports = { toOpenCodeMcp };

package/nodes/agent/lib/runtimes/base.js

@@ -1,21 +1,21 @@
-'use strict';
+"use strict";
 
 // Generic interface every runtime (Direct, SRT, and later Daytona/OpenShell)
 // must implement. Agent adapters never depend on a runtime directly, and
 // runtimes never depend on an agent adapter -- they only see the normalized
 // executionRequest built by lib/execution/lifecycle.js.
 class RuntimeProvider {
-    // executionRequest: { id, command, args, cwd, env, timeoutMs }
-    // handlers: { onLine(line: string), onExit(...) } -- onExit is not
-    // called directly by implementations; execute() resolves instead with
-    // { exitCode, signal, stderr, timedOut }.
-    async execute(_executionRequest, _handlers) {
-        throw new Error('RuntimeProvider.execute() not implemented');
-    }
+  // executionRequest: { id, command, args, cwd, env, timeoutMs }
+  // handlers: { onLine(line: string), onExit(...) } -- onExit is not
+  // called directly by implementations; execute() resolves instead with
+  // { exitCode, signal, stderr, timedOut }.
+  async execute(_executionRequest, _handlers) {
+    throw new Error("RuntimeProvider.execute() not implemented");
+  }
 
-    async terminate(_executionId) {}
+  async terminate(_executionId) {}
 
-    async cleanup(_executionId) {}
+  async cleanup(_executionId) {}
 }
 
 module.exports = { RuntimeProvider };

package/nodes/agent/lib/runtimes/direct.js

@@ -1,28 +1,28 @@
-'use strict';
+"use strict";
 
-const { RuntimeProvider } = require('./base');
-const { runProcess, terminate } = require('./process-exec');
+const { RuntimeProvider } = require("./base");
+const { runProcess, terminate } = require("./process-exec");
 
 // The portability baseline: runs the agent CLI directly as a child process
 // wherever it's on PATH (laptop, GitHub runner, Kubernetes container, ...).
 class DirectRuntime extends RuntimeProvider {
-    async execute(executionRequest, handlers) {
-        return runProcess(
-            {
-                id: executionRequest.id,
-                cmd: executionRequest.command,
-                args: executionRequest.args,
-                cwd: executionRequest.cwd,
-                env: executionRequest.env,
-                timeoutMs: executionRequest.timeoutMs
-            },
-            handlers
-        );
-    }
+  async execute(executionRequest, handlers) {
+    return runProcess(
+      {
+        id: executionRequest.id,
+        cmd: executionRequest.command,
+        args: executionRequest.args,
+        cwd: executionRequest.cwd,
+        env: executionRequest.env,
+        timeoutMs: executionRequest.timeoutMs,
+      },
+      handlers,
+    );
+  }
 
-    async terminate(executionId) {
-        terminate(executionId);
-    }
+  async terminate(executionId) {
+    terminate(executionId);
+  }
 }
 
 module.exports = { DirectRuntime };

package/nodes/agent/lib/runtimes/process-exec.js

@@ -1,10 +1,10 @@
-'use strict';
+"use strict";
 
 // Shared spawn/timeout/kill logic used by both the Direct and SRT runtimes.
 // Direct and SRT differ only in *which* command+args get spawned (see
 // direct.js / srt.js) -- everything about process lifecycle, JSONL line
 // buffering, and timeout handling lives here exactly once.
-const { spawn } = require('child_process');
+const { spawn } = require("child_process");
 
 const GRACE_PERIOD_MS = 2000;
 
@@ -12,94 +12,94 @@ const GRACE_PERIOD_MS = 2000;
 const registry = new Map();
 
 function killProcessGroup(child, signal) {
-    if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  try {
+    // `detached: true` (see runProcess) gives the child its own process
+    // group with pgid === child.pid, so `-pid` reaches the whole tree
+    // (e.g. srt's bwrap wrapper + the agent CLI it spawns), leaving no
+    // orphans -- verified manually against a real `srt`-wrapped process.
+    process.kill(-child.pid, signal);
+  } catch (err) {
     try {
-        // `detached: true` (see runProcess) gives the child its own process
-        // group with pgid === child.pid, so `-pid` reaches the whole tree
-        // (e.g. srt's bwrap wrapper + the agent CLI it spawns), leaving no
-        // orphans -- verified manually against a real `srt`-wrapped process.
-        process.kill(-child.pid, signal);
-    } catch (err) {
-        try {
-            child.kill(signal);
-        } catch (_err) {
-            // Process likely already exited between the check above and here.
-        }
+      child.kill(signal);
+    } catch (_err) {
+      // Process likely already exited between the check above and here.
     }
+  }
 }
 
 function runProcess(executionRequest, handlers = {}) {
-    const { id, cmd, args, cwd, env, timeoutMs } = executionRequest;
+  const { id, cmd, args, cwd, env, timeoutMs } = executionRequest;
 
-    return new Promise((resolve, reject) => {
-        let child;
-        try {
-            child = spawn(cmd, args, {
-                cwd: cwd || undefined,
-                env: env || process.env,
-                detached: true,
-                // Agent CLIs (opencode, srt-wrapped or not) wait on stdin if
-                // it's left open as a pipe; close it so they behave like a
-                // normal non-interactive invocation (see AGENTS.md).
-                stdio: ['ignore', 'pipe', 'pipe']
-            });
-        } catch (err) {
-            reject(err);
-            return;
-        }
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(cmd, args, {
+        cwd: cwd || undefined,
+        env: env || process.env,
+        detached: true,
+        // Agent CLIs (opencode, srt-wrapped or not) wait on stdin if
+        // it's left open as a pipe; close it so they behave like a
+        // normal non-interactive invocation (see AGENTS.md).
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } catch (err) {
+      reject(err);
+      return;
+    }
 
-        const state = { child, timeoutTimer: null, killTimer: null, timedOut: false };
-        registry.set(id, state);
+    const state = { child, timeoutTimer: null, killTimer: null, timedOut: false };
+    registry.set(id, state);
 
-        let lineBuffer = '';
-        let stderr = '';
+    let lineBuffer = "";
+    let stderr = "";
 
-        child.stdout.on('data', (chunk) => {
-            lineBuffer += chunk.toString();
-            let idx;
-            while ((idx = lineBuffer.indexOf('\n')) >= 0) {
-                const line = lineBuffer.slice(0, idx);
-                lineBuffer = lineBuffer.slice(idx + 1);
-                if (handlers.onLine) handlers.onLine(line);
-            }
-        });
-        child.stderr.on('data', (chunk) => {
-            stderr += chunk.toString();
-        });
+    child.stdout.on("data", (chunk) => {
+      lineBuffer += chunk.toString();
+      let idx;
+      while ((idx = lineBuffer.indexOf("\n")) >= 0) {
+        const line = lineBuffer.slice(0, idx);
+        lineBuffer = lineBuffer.slice(idx + 1);
+        if (handlers.onLine) handlers.onLine(line);
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
 
-        if (timeoutMs && timeoutMs > 0) {
-            state.timeoutTimer = setTimeout(() => {
-                state.timedOut = true;
-                killProcessGroup(child, 'SIGTERM');
-                state.killTimer = setTimeout(() => killProcessGroup(child, 'SIGKILL'), GRACE_PERIOD_MS);
-            }, timeoutMs);
-        }
+    if (timeoutMs && timeoutMs > 0) {
+      state.timeoutTimer = setTimeout(() => {
+        state.timedOut = true;
+        killProcessGroup(child, "SIGTERM");
+        state.killTimer = setTimeout(() => killProcessGroup(child, "SIGKILL"), GRACE_PERIOD_MS);
+      }, timeoutMs);
+    }
 
-        child.on('error', (err) => {
-            cleanupTimers(state);
-            registry.delete(id);
-            reject(err);
-        });
+    child.on("error", (err) => {
+      cleanupTimers(state);
+      registry.delete(id);
+      reject(err);
+    });
 
-        child.on('close', (code, signal) => {
-            if (lineBuffer.length && handlers.onLine) handlers.onLine(lineBuffer);
-            cleanupTimers(state);
-            registry.delete(id);
-            resolve({ exitCode: code, signal, stderr, timedOut: state.timedOut, pid: child.pid });
-        });
+    child.on("close", (code, signal) => {
+      if (lineBuffer.length && handlers.onLine) handlers.onLine(lineBuffer);
+      cleanupTimers(state);
+      registry.delete(id);
+      resolve({ exitCode: code, signal, stderr, timedOut: state.timedOut, pid: child.pid });
     });
+  });
 }
 
 function cleanupTimers(state) {
-    if (state.timeoutTimer) clearTimeout(state.timeoutTimer);
-    if (state.killTimer) clearTimeout(state.killTimer);
+  if (state.timeoutTimer) clearTimeout(state.timeoutTimer);
+  if (state.killTimer) clearTimeout(state.killTimer);
 }
 
 function terminate(id) {
-    const state = registry.get(id);
-    if (!state) return;
-    killProcessGroup(state.child, 'SIGTERM');
-    state.killTimer = setTimeout(() => killProcessGroup(state.child, 'SIGKILL'), GRACE_PERIOD_MS);
+  const state = registry.get(id);
+  if (!state) return;
+  killProcessGroup(state.child, "SIGTERM");
+  state.killTimer = setTimeout(() => killProcessGroup(state.child, "SIGKILL"), GRACE_PERIOD_MS);
 }
 
 module.exports = { runProcess, terminate, killProcessGroup, GRACE_PERIOD_MS };

package/nodes/agent/lib/runtimes/srt.js

@@ -1,9 +1,9 @@
-'use strict';
+"use strict";
 
-const { RuntimeProvider } = require('./base');
-const { runProcess, terminate } = require('./process-exec');
+const { RuntimeProvider } = require("./base");
+const { runProcess, terminate } = require("./process-exec");
 
-const DEFAULT_BINARY = 'srt';
+const DEFAULT_BINARY = "srt";
 
 // Wraps execution in Anthropic's `srt` (sandbox-runtime) CLI, which is
 // already installed on this host as a plain binary. Verified empirically
@@ -19,45 +19,45 @@ const DEFAULT_BINARY = 'srt';
 // top of the exact same process-exec.js used by Direct: no new npm
 // dependency, no shell-quoting step, no separate process lifecycle code.
 class SrtRuntime extends RuntimeProvider {
-    constructor(options = {}) {
-        super();
-        this.binary = options.binary || DEFAULT_BINARY;
-        // Left undefined by default so `srt` falls back to its own default
-        // (~/.srt-settings.json) -- SRT policy is deliberately kept out of
-        // the Agent node's core schema (spec: "SRT-specific configuration
-        // should be hidden... implemented by the runtime adapter").
-        this.settingsPath = options.settingsPath || undefined;
-        this.extraArgs = Array.isArray(options.extraArgs) ? options.extraArgs : [];
-    }
+  constructor(options = {}) {
+    super();
+    this.binary = options.binary || DEFAULT_BINARY;
+    // Left undefined by default so `srt` falls back to its own default
+    // (~/.srt-settings.json) -- SRT policy is deliberately kept out of
+    // the Agent node's core schema (spec: "SRT-specific configuration
+    // should be hidden... implemented by the runtime adapter").
+    this.settingsPath = options.settingsPath || undefined;
+    this.extraArgs = Array.isArray(options.extraArgs) ? options.extraArgs : [];
+  }
 
-    buildCommand(executionRequest) {
-        const flags = [];
-        if (this.settingsPath) flags.push('-s', this.settingsPath);
-        flags.push(...this.extraArgs);
-        return {
-            cmd: this.binary,
-            args: [...flags, executionRequest.command, ...executionRequest.args]
-        };
-    }
+  buildCommand(executionRequest) {
+    const flags = [];
+    if (this.settingsPath) flags.push("-s", this.settingsPath);
+    flags.push(...this.extraArgs);
+    return {
+      cmd: this.binary,
+      args: [...flags, executionRequest.command, ...executionRequest.args],
+    };
+  }
 
-    async execute(executionRequest, handlers) {
-        const { cmd, args } = this.buildCommand(executionRequest);
-        return runProcess(
-            {
-                id: executionRequest.id,
-                cmd,
-                args,
-                cwd: executionRequest.cwd,
-                env: executionRequest.env,
-                timeoutMs: executionRequest.timeoutMs
-            },
-            handlers
-        );
-    }
+  async execute(executionRequest, handlers) {
+    const { cmd, args } = this.buildCommand(executionRequest);
+    return runProcess(
+      {
+        id: executionRequest.id,
+        cmd,
+        args,
+        cwd: executionRequest.cwd,
+        env: executionRequest.env,
+        timeoutMs: executionRequest.timeoutMs,
+      },
+      handlers,
+    );
+  }
 
-    async terminate(executionId) {
-        terminate(executionId);
-    }
+  async terminate(executionId) {
+    terminate(executionId);
+  }
 }
 
 module.exports = { SrtRuntime };