@tbrandenburg/node-red-agents 0.1.2 → 0.1.4

package/nodes/agent-server/lib/daemon.js

@@ -1,7 +1,7 @@
-'use strict';
+"use strict";
 
-const { spawn } = require('child_process');
-const { request } = require('./http');
+const { spawn } = require("child_process");
+const { request } = require("./http");
 
 const GRACE_PERIOD_MS = 2000;
 const DEFAULT_HEALTH_POLL_INTERVAL_MS = 200;
@@ -29,26 +29,26 @@ const MAX_BUFFERED_OUTPUT = 4000;
 //
 // config: { binary ('opencode'), hostname, port, srt: { enabled, binary, settingsPath } }
 function buildCommand(config) {
-    const serveArgs = ['serve', '--port', String(config.port), '--hostname', config.hostname];
-
-    if (config.srt && config.srt.enabled) {
-        const flags = [];
-        if (config.srt.settingsPath) flags.push('-s', config.srt.settingsPath);
-        return {
-            cmd: config.srt.binary || 'srt',
-            args: [...flags, config.binary || 'opencode', ...serveArgs]
-        };
-    }
-
-    return { cmd: config.binary || 'opencode', args: serveArgs };
+  const serveArgs = ["serve", "--port", String(config.port), "--hostname", config.hostname];
+
+  if (config.srt && config.srt.enabled) {
+    const flags = [];
+    if (config.srt.settingsPath) flags.push("-s", config.srt.settingsPath);
+    return {
+      cmd: config.srt.binary || "srt",
+      args: [...flags, config.binary || "opencode", ...serveArgs],
+    };
+  }
+
+  return { cmd: config.binary || "opencode", args: serveArgs };
 }
 
 // Bounded ring-buffer append: keeps only the last MAX_BUFFERED_OUTPUT chars,
 // so a long-lived daemon's stdout/stderr can't leak memory over a session
 // that stays open for hours.
 function appendBounded(buffer, chunk) {
-    const next = buffer + chunk;
-    return next.length > MAX_BUFFERED_OUTPUT ? next.slice(next.length - MAX_BUFFERED_OUTPUT) : next;
+  const next = buffer + chunk;
+  return next.length > MAX_BUFFERED_OUTPUT ? next.slice(next.length - MAX_BUFFERED_OUTPUT) : next;
 }
 
 // Spawns the daemon process (detached into its own process group, same
@@ -60,90 +60,105 @@ function appendBounded(buffer, chunk) {
 // Does not wait for readiness -- call waitForHealthy() with the returned
 // baseUrl afterwards.
 function spawnDaemon(config) {
-    const { cmd, args } = buildCommand(config);
-    const state = { stdout: '', stderr: '' };
-
-    const child = spawn(cmd, args, {
-        cwd: config.cwd || undefined,
-        env: config.env || process.env,
-        detached: true,
-        stdio: ['ignore', 'pipe', 'pipe']
-    });
-
-    child.stdout.on('data', (chunk) => {
-        state.stdout = appendBounded(state.stdout, chunk.toString());
-    });
-    child.stderr.on('data', (chunk) => {
-        state.stderr = appendBounded(state.stderr, chunk.toString());
-    });
-
-    return { child, cmd, args, diagnostics: state };
+  const { cmd, args } = buildCommand(config);
+  const state = { stdout: "", stderr: "" };
+
+  const child = spawn(cmd, args, {
+    cwd: config.cwd || undefined,
+    env: config.env || process.env,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  child.stdout.on("data", (chunk) => {
+    state.stdout = appendBounded(state.stdout, chunk.toString());
+  });
+  child.stderr.on("data", (chunk) => {
+    state.stderr = appendBounded(state.stderr, chunk.toString());
+  });
+
+  return { child, cmd, args, diagnostics: state };
 }
 
 // Polls GET /global/health until it responds or timeoutMs elapses. Resolves
 // with the parsed health body; rejects with a clear error (including
 // whatever stderr the daemon produced, if any) on timeout.
-async function waitForHealthy(baseUrl, { timeoutMs, intervalMs, username, password, diagnostics } = {}) {
-    const deadline = Date.now() + (timeoutMs || 15000);
-    const interval = intervalMs || DEFAULT_HEALTH_POLL_INTERVAL_MS;
-    let lastError;
-
-    while (Date.now() < deadline) {
-        try {
-            return await request(`${baseUrl}/global/health`, { timeoutMs: interval * 4, username, password });
-        } catch (err) {
-            lastError = err;
-            await new Promise((r) => setTimeout(r, interval));
-        }
+async function waitForHealthy(
+  baseUrl,
+  { timeoutMs, intervalMs, username, password, diagnostics } = {},
+) {
+  const deadline = Date.now() + (timeoutMs || 15000);
+  const interval = intervalMs || DEFAULT_HEALTH_POLL_INTERVAL_MS;
+  let lastError;
+
+  while (Date.now() < deadline) {
+    try {
+      return await request(`${baseUrl}/global/health`, {
+        timeoutMs: interval * 4,
+        username,
+        password,
+      });
+    } catch (err) {
+      lastError = err;
+      await new Promise((r) => setTimeout(r, interval));
     }
-
-    const stderrTail = diagnostics && diagnostics.stderr ? ` -- stderr: ${diagnostics.stderr.trim()}` : '';
-    throw new Error(
-        `daemon at ${baseUrl} did not become healthy within ${timeoutMs}ms` +
-            (lastError ? ` (last error: ${lastError.message})` : '') +
-            stderrTail
-    );
+  }
+
+  const stderrTail =
+    diagnostics && diagnostics.stderr ? ` -- stderr: ${diagnostics.stderr.trim()}` : "";
+  throw new Error(
+    `daemon at ${baseUrl} did not become healthy within ${timeoutMs}ms` +
+      (lastError ? ` (last error: ${lastError.message})` : "") +
+      stderrTail,
+  );
 }
 
 // `-pid` reaches the whole detached process group (see spawnDaemon).
 function killProcessGroup(child, signal) {
-    if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  try {
+    process.kill(-child.pid, signal);
+  } catch (err) {
     try {
-        process.kill(-child.pid, signal);
-    } catch (err) {
-        try {
-            child.kill(signal);
-        } catch (_err) {
-            // Already exited between the check above and here.
-        }
+      child.kill(signal);
+    } catch (_err) {
+      // Already exited between the check above and here.
     }
+  }
 }
 
 // SIGTERM, escalating to SIGKILL after GRACE_PERIOD_MS if it hasn't exited.
 // Resolves once the process has actually exited, or after a safety cap so
 // node close() can never hang forever on a daemon that refuses to die.
 function killDaemon(child) {
-    return new Promise((resolve) => {
-        if (!child || child.exitCode !== null || child.signalCode !== null) {
-            resolve();
-            return;
-        }
-
-        let settled = false;
-        const finish = () => {
-            if (settled) return;
-            settled = true;
-            clearTimeout(killTimer);
-            clearTimeout(safetyTimer);
-            resolve();
-        };
-
-        child.once('exit', finish);
-        killProcessGroup(child, 'SIGTERM');
-
-        const killTimer = setTimeout(() => killProcessGroup(child, 'SIGKILL'), GRACE_PERIOD_MS);
-        const safetyTimer = setTimeout(finish, GRACE_PERIOD_MS + 2000);
-    });
+  return new Promise((resolve) => {
+    if (!child || child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+      return;
+    }
+
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(killTimer);
+      clearTimeout(safetyTimer);
+      resolve();
+    };
+
+    child.once("exit", finish);
+    killProcessGroup(child, "SIGTERM");
+
+    const killTimer = setTimeout(() => killProcessGroup(child, "SIGKILL"), GRACE_PERIOD_MS);
+    const safetyTimer = setTimeout(finish, GRACE_PERIOD_MS + 2000);
+  });
 }
 
-module.exports = { buildCommand, spawnDaemon, waitForHealthy, killDaemon, killProcessGroup, GRACE_PERIOD_MS };
+module.exports = {
+  buildCommand,
+  spawnDaemon,
+  waitForHealthy,
+  killDaemon,
+  killProcessGroup,
+  GRACE_PERIOD_MS,
+};

package/nodes/agent-server/lib/http.js

@@ -1,11 +1,11 @@
-'use strict';
+"use strict";
 
 // Thin fetch wrapper for talking to an opencode `serve` daemon: adds an
 // AbortController-based timeout (fetch has no built-in one) and optional
 // HTTP basic auth. Deliberately not a generic HTTP client -- just enough to
 // call the handful of endpoints this node needs.
 function basicAuthHeader(username, password) {
-    return 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64');
+  return "Basic " + Buffer.from(`${username}:${password}`).toString("base64");
 }
 
 // opts: { method, body, timeoutMs, username, password }
@@ -13,48 +13,50 @@ function basicAuthHeader(username, password) {
 // Throws an Error (with .status set, if the server responded at all) on
 // network failure, timeout, or a non-2xx response.
 async function request(url, opts = {}) {
-    const controller = new AbortController();
-    const timeoutMs = opts.timeoutMs || 30000;
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-
-    const headers = { 'Content-Type': 'application/json' };
-    if (opts.username || opts.password) {
-        headers.Authorization = basicAuthHeader(opts.username || '', opts.password || '');
-    }
-
-    let res;
-    try {
-        res = await fetch(url, {
-            method: opts.method || 'GET',
-            headers,
-            body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
-            signal: controller.signal
-        });
-    } catch (err) {
-        if (err.name === 'AbortError') {
-            throw new Error(`request to ${url} timed out after ${timeoutMs}ms`);
-        }
-        throw new Error(`request to ${url} failed: ${err.message}`);
-    } finally {
-        clearTimeout(timer);
-    }
-
-    const text = await res.text();
-    let body;
-    try {
-        body = text ? JSON.parse(text) : undefined;
-    } catch (err) {
-        body = text;
-    }
-
-    if (!res.ok) {
-        const err = new Error(`${opts.method || 'GET'} ${url} -> ${res.status}${text ? ': ' + text : ''}`);
-        err.status = res.status;
-        err.body = body;
-        throw err;
+  const controller = new AbortController();
+  const timeoutMs = opts.timeoutMs || 30000;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  const headers = { "Content-Type": "application/json" };
+  if (opts.username || opts.password) {
+    headers.Authorization = basicAuthHeader(opts.username || "", opts.password || "");
+  }
+
+  let res;
+  try {
+    res = await fetch(url, {
+      method: opts.method || "GET",
+      headers,
+      body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+      signal: controller.signal,
+    });
+  } catch (err) {
+    if (err.name === "AbortError") {
+      throw new Error(`request to ${url} timed out after ${timeoutMs}ms`);
     }
-
-    return body;
+    throw new Error(`request to ${url} failed: ${err.message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+
+  const text = await res.text();
+  let body;
+  try {
+    body = text ? JSON.parse(text) : undefined;
+  } catch (err) {
+    body = text;
+  }
+
+  if (!res.ok) {
+    const err = new Error(
+      `${opts.method || "GET"} ${url} -> ${res.status}${text ? ": " + text : ""}`,
+    );
+    err.status = res.status;
+    err.body = body;
+    throw err;
+  }
+
+  return body;
 }
 
 module.exports = { request, basicAuthHeader };

package/nodes/agent-server/lib/model.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 // The `agent` node's --model flag accepts a plain "provider/model" string
 // (opencode's CLI parses that itself). The HTTP API has no such shorthand --
@@ -8,13 +8,15 @@
 // translation between the two, kept pure/testable and separate from
 // agent-server.js.
 function parseModel(value) {
-    if (value === undefined || value === null || value === '') return undefined;
-    const str = String(value);
-    const slash = str.indexOf('/');
-    if (slash <= 0 || slash === str.length - 1) {
-        throw new Error(`invalid model "${str}" -- expected "provider/model" (e.g. "github-copilot/claude-sonnet-4.6")`);
-    }
-    return { providerID: str.slice(0, slash), modelID: str.slice(slash + 1) };
+  if (value === undefined || value === null || value === "") return undefined;
+  const str = String(value);
+  const slash = str.indexOf("/");
+  if (slash <= 0 || slash === str.length - 1) {
+    throw new Error(
+      `invalid model "${str}" -- expected "provider/model" (e.g. "github-copilot/claude-sonnet-4.6")`,
+    );
+  }
+  return { providerID: str.slice(0, slash), modelID: str.slice(slash + 1) };
 }
 
 module.exports = { parseModel };

package/nodes/agent-server/lib/port.js

@@ -1,6 +1,6 @@
-'use strict';
+"use strict";
 
-const net = require('net');
+const net = require("net");
 
 // Self-allocates a free TCP port instead of spawning `opencode serve --port
 // 0` and scraping its stdout for the OS-assigned port: bind a throwaway
@@ -13,19 +13,19 @@ const net = require('net');
 // else between close() here and the daemon binding it moments later. Left
 // as a known, accepted race (same as almost every "find a free port" helper)
 // -- the daemon's own health-poll failing/timing out is the backstop.
-function findFreePort(hostname = '127.0.0.1') {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.unref();
-        server.on('error', reject);
-        server.listen(0, hostname, () => {
-            const { port } = server.address();
-            server.close((err) => {
-                if (err) reject(err);
-                else resolve(port);
-            });
-        });
+function findFreePort(hostname = "127.0.0.1") {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, hostname, () => {
+      const { port } = server.address();
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve(port);
+      });
     });
+  });
 }
 
 module.exports = { findFreePort };

package/nodes/agent-server/lib/registry.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 // Framework-agnostic, in-memory tracking of every daemon (opencode serve
 // process) this node instance has spawned, keyed by sessionID. Deliberately
@@ -10,68 +10,68 @@
 // being maintained for routing purposes anyway -- no extra network calls,
 // no separate bookkeeping subsystem.
 class InstanceRegistry {
-    constructor() {
-        this.map = new Map();
-    }
+  constructor() {
+    this.map = new Map();
+  }
 
-    // record: { child, host, port, baseUrl } -- busy/startedAt/lastUsed are
-    // owned by the registry itself, not the caller.
-    register(sessionID, record) {
-        this.map.set(
-            sessionID,
-            Object.assign({ busy: false, startedAt: Date.now(), lastUsed: Date.now() }, record)
-        );
-    }
+  // record: { child, host, port, baseUrl } -- busy/startedAt/lastUsed are
+  // owned by the registry itself, not the caller.
+  register(sessionID, record) {
+    this.map.set(
+      sessionID,
+      Object.assign({ busy: false, startedAt: Date.now(), lastUsed: Date.now() }, record),
+    );
+  }
 
-    get(sessionID) {
-        return this.map.get(sessionID);
-    }
+  get(sessionID) {
+    return this.map.get(sessionID);
+  }
 
-    has(sessionID) {
-        return this.map.has(sessionID);
-    }
+  has(sessionID) {
+    return this.map.has(sessionID);
+  }
 
-    delete(sessionID) {
-        return this.map.delete(sessionID);
-    }
+  delete(sessionID) {
+    return this.map.delete(sessionID);
+  }
 
-    list() {
-        return Array.from(this.map.keys());
-    }
+  list() {
+    return Array.from(this.map.keys());
+  }
 
-    size() {
-        return this.map.size;
-    }
+  size() {
+    return this.map.size;
+  }
 
-    // Marks a tracked session busy/idle and bumps lastUsed. No-op if the
-    // sessionID isn't tracked (e.g. already torn down) -- callers don't need
-    // to guard this themselves.
-    setBusy(sessionID, busy) {
-        const record = this.map.get(sessionID);
-        if (!record) return;
-        record.busy = busy;
-        record.lastUsed = Date.now();
-    }
+  // Marks a tracked session busy/idle and bumps lastUsed. No-op if the
+  // sessionID isn't tracked (e.g. already torn down) -- callers don't need
+  // to guard this themselves.
+  setBusy(sessionID, busy) {
+    const record = this.map.get(sessionID);
+    if (!record) return;
+    record.busy = busy;
+    record.lastUsed = Date.now();
+  }
 
-    // Pure, local (no network) snapshot -- this is what backs the 'status'
-    // operation when called without a sessionID, and the lifecycle-event
-    // envelope's live counts.
-    summary() {
-        const sessions = [];
-        let busy = 0;
-        for (const [sessionID, record] of this.map) {
-            if (record.busy) busy += 1;
-            sessions.push({
-                sessionID,
-                host: record.host,
-                port: record.port,
-                busy: !!record.busy,
-                startedAt: record.startedAt,
-                lastUsed: record.lastUsed
-            });
-        }
-        return { total: sessions.length, busy, idle: sessions.length - busy, sessions };
+  // Pure, local (no network) snapshot -- this is what backs the 'status'
+  // operation when called without a sessionID, and the lifecycle-event
+  // envelope's live counts.
+  summary() {
+    const sessions = [];
+    let busy = 0;
+    for (const [sessionID, record] of this.map) {
+      if (record.busy) busy += 1;
+      sessions.push({
+        sessionID,
+        host: record.host,
+        port: record.port,
+        busy: !!record.busy,
+        startedAt: record.startedAt,
+        lastUsed: record.lastUsed,
+      });
     }
+    return { total: sessions.length, busy, idle: sessions.length - busy, sessions };
+  }
 }
 
 module.exports = { InstanceRegistry };

package/nodes/agent-server/lib/status.js

@@ -1,15 +1,15 @@
-'use strict';
+"use strict";
 
 // Pure function computing the node.status() shape from the registry's local
 // summary (see lib/registry.js). Kept separate from agent-server.js so it's
 // unit-testable without a Node-RED runtime -- same reasoning as the `agent`
 // package's lib/execution/status.js.
-function computeNodeStatus({ total, busy, idle }) {
-    if (total === 0) return {}; // no daemons tracked -- idle, nothing to show
+function computeNodeStatus({ total, busy }) {
+  if (total === 0) return {}; // no daemons tracked -- idle, nothing to show
 
-    let text = `${total} daemon${total === 1 ? '' : 's'}`;
-    text += busy > 0 ? ` \u00b7 ${busy} busy` : ' \u00b7 idle';
-    return { fill: busy > 0 ? 'blue' : 'green', shape: 'dot', text };
+  let text = `${total} daemon${total === 1 ? "" : "s"}`;
+  text += busy > 0 ? ` \u00b7 ${busy} busy` : " \u00b7 idle";
+  return { fill: busy > 0 ? "blue" : "green", shape: "dot", text };
 }
 
 module.exports = { computeNodeStatus };

package/nodes/gh/README.md

@@ -18,22 +18,22 @@ This package does not bundle `gh` or implement its own login flow.
 
 **Inputs:** 1   **Outputs:** 1
 
-| Field | Type | Notes |
-|---|---|---|
-| Command | str/msg/flow/global | The `gh` subcommand, e.g. `pr`, `issue`, `workflow`, `api`. Not the full command line -- `gh` itself is always the executable and can never be overridden. |
-| Arguments | str/msg/flow/global | Everything after the command, e.g. `list --state open --json number,title,url`. A string value is tokenized (quote-aware, no shell evaluation); an array value (e.g. from `msg.`) is used as-is. |
-| Repository | str/msg/flow/global | Optional `owner/repo`. Sets `GH_REPO` for the invocation. |
-| Host (Advanced) | str | Optional GitHub Enterprise hostname, e.g. `github.example.com`. Sets `GH_HOST`. |
-| Timeout (Advanced) | number (ms) | Default 60000. The child process is killed (`SIGTERM`) if it runs longer than this. |
+| Field              | Type                | Notes                                                                                                                                                                                            |
+| ------------------ | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Command            | str/msg/flow/global | The `gh` subcommand, e.g. `pr`, `issue`, `workflow`, `api`. Not the full command line -- `gh` itself is always the executable and can never be overridden.                                       |
+| Arguments          | str/msg/flow/global | Everything after the command, e.g. `list --state open --json number,title,url`. A string value is tokenized (quote-aware, no shell evaluation); an array value (e.g. from `msg.`) is used as-is. |
+| Repository         | str/msg/flow/global | Optional `owner/repo`. Sets `GH_REPO` for the invocation.                                                                                                                                        |
+| Host (Advanced)    | str                 | Optional GitHub Enterprise hostname, e.g. `github.example.com`. Sets `GH_HOST`.                                                                                                                  |
+| Timeout (Advanced) | number (ms)         | Default 60000. The child process is killed (`SIGTERM`) if it runs longer than this.                                                                                                              |
 
 ### `msg.gh` overrides
 
 ```js
 msg.gh = {
-  command: 'issue',
-  args: ['list', '--state', 'open'],   // array preferred; skips parsing entirely
-  repo: 'owner/repo',
-  host: 'github.example.com'
+  command: "issue",
+  args: ["list", "--state", "open"], // array preferred; skips parsing entirely
+  repo: "owner/repo",
+  host: "github.example.com",
 };
 ```