@tbrandenburg/node-red-agents 0.1.1

package/nodes/agent/lib/agents/pi.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { AgentAdapter } = require('./base');
+
+// Maps pi's real `--mode json` event stream (verified empirically against
+// pi 0.84.1 -- its own docs don't spell this out) onto the Agent node's
+// generic event vocabulary. Deliberately coarser than pi's own granularity:
+// text/thinking *_delta and *_start events are skipped to avoid flooding
+// output 2 with one message per streamed token; only the completed chunk
+// (*_end) is surfaced.
+const TYPE_MAP = {
+    agent_start: 'started',
+    tool_execution_start: 'tool',
+    tool_execution_update: 'tool',
+    tool_execution_end: 'tool',
+    turn_end: 'progress',
+    agent_end: 'completed'
+};
+
+// pi's project-level skill/prompt-template directories, per this
+// installation's ~/.pi/agent/settings.json ("skills": [".github/skills"],
+// "prompts": [".github/prompts"]). Used only as a *resolution convention*
+// for turning the generic Agent node's bare invocationName into a path --
+// pi itself doesn't auto-discover these for a single non-interactive run
+// (verified: without an explicit --skill/--prompt-template flag, the model
+// has no idea the file exists and will try to go hunting for it with its
+// own tools instead).
+const RESOURCE_DIRS = {
+    skill: '.github/skills',
+    command: '.github/prompts'
+};
+
+function resolveResourcePath(name, kind, cwd) {
+    const base = cwd || process.cwd();
+    const candidates = [];
+
+    if (path.isAbsolute(name)) {
+        candidates.push(name);
+    } else if (name.includes('/') || name.endsWith('.md')) {
+        candidates.push(path.join(base, name));
+    }
+
+    const dir = RESOURCE_DIRS[kind];
+    candidates.push(path.join(base, dir, name, 'SKILL.md'));
+    candidates.push(path.join(base, dir, `${name}.md`));
+
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) return candidate;
+    }
+    throw new Error(`could not find a ${kind} named "${name}" (looked for: ${candidates.join(', ')})`);
+}
+
+class PiAdapter extends AgentAdapter {
+    validate(resolved) {
+        if (resolved.cwd) {
+            let stat;
+            try {
+                stat = fs.statSync(resolved.cwd);
+            } catch (err) {
+                throw new Error(`cwd does not exist: ${resolved.cwd}`);
+            }
+            if (!stat.isDirectory()) {
+                throw new Error(`cwd is not a directory: ${resolved.cwd}`);
+            }
+        }
+
+        if (resolved.invocation === 'prompt') {
+            if (!resolved.prompt || !String(resolved.prompt).trim()) {
+                throw new Error('prompt invocation requires a non-empty prompt (msg.payload or the Prompt field)');
+            }
+        } else if (resolved.invocation === 'skill' || resolved.invocation === 'command') {
+            if (!resolved.invocationName || !String(resolved.invocationName).trim()) {
+                throw new Error(`${resolved.invocation} invocation requires a non-empty name`);
+            }
+            // Throws its own clear error if nothing matches -- fail before
+            // spawning anything, per the adapter contract.
+            resolveResourcePath(resolved.invocationName, resolved.invocation, resolved.cwd);
+        } else {
+            throw new Error(`unknown invocation mode: ${resolved.invocation}`);
+        }
+
+        if (Array.isArray(resolved.mcpServers) && resolved.mcpServers.length > 0) {
+            throw new Error(
+                'the pi adapter does not support MCP servers (no MCP CLI/config surface was found in `pi --help`); ' +
+                    'remove the configured MCP servers or switch Agent to OpenCode'
+            );
+        }
+
+        if (resolved.sessionID) {
+            // Every pi invocation is built with --no-session (see
+            // buildExecution) -- deliberately ephemeral, matching the
+            // "one CLI process = one execution" model this adapter was
+            // verified against. Silently accepting a sessionID here would
+            // imply continuation that never actually happens.
+            throw new Error(
+                'the pi adapter does not support session continuation through this node (every pi run uses ' +
+                    '--no-session); leave Session ID blank or switch Agent to OpenCode'
+            );
+        }
+    }
+
+    buildExecution(resolved) {
+        const args = ['--no-session', '--mode', 'json'];
+
+        if (resolved.model) args.push('--model', String(resolved.model));
+
+        // pi has no permission-prompt system to bypass in non-interactive
+        // mode -- read/bash/edit/write tools just run immediately with no
+        // confirmation of any kind (verified: an unrestricted run had the
+        // model shell out to `find /` on its own with zero gating). The
+        // closest analogue to opencode's --auto is restricting which
+        // tools are even available: "not auto" -> read-only tool set,
+        // "auto" -> everything. This is an approximation, not a true
+        // permission bypass -- documented in the node's help text.
+        if (!resolved.auto) {
+            args.push('--tools', 'read,grep,find,ls');
+        }
+
+        let message;
+        if (resolved.invocation === 'prompt') {
+            message = String(resolved.prompt);
+        } else {
+            const resourcePath = resolveResourcePath(resolved.invocationName, resolved.invocation, resolved.cwd);
+            const flag = resolved.invocation === 'skill' ? '--skill' : '--prompt-template';
+            args.push(flag, resourcePath);
+
+            // pi has no deterministic slash-command dispatch like
+            // opencode's --command (verified: without this explicit
+            // instruction the model never used the loaded skill/template
+            // on its own). Spelling out the path and arguments in plain
+            // language is what actually worked in testing.
+            const kind = resolved.invocation === 'skill' ? 'skill' : 'prompt template';
+            const argsText = resolved.args !== undefined && resolved.args !== null ? String(resolved.args) : '';
+            message = `Use the "${resolved.invocationName}" ${kind} at ${resourcePath}. ${argsText}`.trim();
+        }
+        args.push(message);
+
+        return { command: 'pi', args, env: {} };
+    }
+
+    parseEvent(line) {
+        const trimmed = line.trim();
+        if (!trimmed) return null;
+
+        let raw;
+        try {
+            raw = JSON.parse(trimmed);
+        } catch (err) {
+            return null;
+        }
+
+        if (raw.type === 'session') {
+            return { type: 'started', sessionID: raw.id, data: raw };
+        }
+
+        if (raw.type === 'message_update' && raw.assistantMessageEvent) {
+            const inner = raw.assistantMessageEvent;
+            if (inner.type === 'text_end' || inner.type === 'thinking_end') {
+                return { type: 'agent', data: raw };
+            }
+            return null; // skip granular *_start/*_delta streaming noise
+        }
+
+        const type = TYPE_MAP[raw.type];
+        if (!type) return null;
+        return { type, data: raw };
+    }
+
+    parseResult(events, exitCode, signal, stderr) {
+        const raw = events.map((e) => e.data);
+        const sessionEvent = raw.find((e) => e.type === 'session');
+        const sessionID = sessionEvent ? sessionEvent.id : undefined;
+        const agentEnd = [...raw].reverse().find((e) => e.type === 'agent_end');
+
+        let payload = '';
+        let errorMessage;
+
+        if (agentEnd && Array.isArray(agentEnd.messages)) {
+            const lastAssistant = [...agentEnd.messages].reverse().find((m) => m.role === 'assistant');
+            if (lastAssistant) {
+                if (lastAssistant.stopReason === 'error') {
+                    // pi does NOT set a non-zero exit code for a model/API
+                    // error (verified: exit 0 with stopReason:"error" deep
+                    // in the event stream) -- this is the only reliable
+                    // signal, unlike opencode's {"type":"error"} + exit code.
+                    errorMessage = lastAssistant.errorMessage || 'pi reported an error';
+                } else if (Array.isArray(lastAssistant.content)) {
+                    payload = lastAssistant.content
+                        .filter((c) => c.type === 'text' && typeof c.text === 'string')
+                        .map((c) => c.text)
+                        .join('\n')
+                        .trim();
+                }
+            }
+        }
+
+        if (errorMessage) {
+            return { payload, sessionID, status: 'failed', errorMessage };
+        }
+        if (signal) {
+            return { payload, sessionID, status: 'failed', errorMessage: `process killed by signal ${signal}` };
+        }
+        if (exitCode !== 0) {
+            return {
+                payload,
+                sessionID,
+                status: 'failed',
+                errorMessage: `exited with code ${exitCode}${stderr ? ': ' + String(stderr).trim() : ''}`
+            };
+        }
+        if (!agentEnd) {
+            return { payload, sessionID, status: 'failed', errorMessage: 'pi produced no agent_end event' };
+        }
+        return { payload, sessionID, status: 'completed' };
+    }
+}
+
+module.exports = { PiAdapter, resolveResourcePath };

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

@@ -0,0 +1,69 @@
+'use strict';
+
+// Framework-agnostic orchestrator: given an adapter, a runtime, and an
+// already-resolved (typed-input-evaluated) input object, runs one agent
+// execution end to end. Deliberately has no Node-RED dependency so it can
+// be unit-tested with fake adapters/runtimes (see test/execution/).
+//
+// `resolved` shape (built by agent.js from node config + msg):
+//   {
+//     invocation: 'prompt' | 'skill' | 'command',
+//     prompt, name, args,   // per invocation mode
+//     cwd, model, auto,
+//     timeoutMs,
+//     mcpServers: []
+//   }
+//
+// `callbacks`:
+//   onEvent(event)   -- called for every parsed stdout event (output 2)
+//   onStatus(status) -- 'running' | 'completed' | 'failed' | 'timeout'
+async function runAgent({ adapter, runtime, resolved, executionId, onEvent, onStatus }) {
+    adapter.validate(resolved); // throws synchronously on bad config
+
+    const built = adapter.buildExecution(resolved);
+    const executionRequest = {
+        id: executionId,
+        command: built.command,
+        args: built.args,
+        cwd: resolved.cwd || undefined,
+        env: Object.assign({}, process.env, built.env || {}),
+        timeoutMs: resolved.timeoutMs || undefined
+    };
+
+    const events = [];
+    const startedAt = Date.now();
+    if (onStatus) onStatus('running');
+
+    const outcome = await runtime.execute(executionRequest, {
+        onLine: (line) => {
+            let event;
+            try {
+                event = adapter.parseEvent(line);
+            } catch (err) {
+                // parseEvent must never crash the node; treat as ignorable.
+                event = null;
+            }
+            if (event) {
+                events.push(event);
+                if (onEvent) onEvent(event);
+            }
+        }
+    });
+
+    const durationMs = Date.now() - startedAt;
+    const result = adapter.parseResult(events, outcome.exitCode, outcome.signal, outcome.stderr);
+    const status = outcome.timedOut ? 'timeout' : result.status;
+
+    if (onStatus) onStatus(status);
+
+    return Object.assign({}, result, {
+        status,
+        exitCode: outcome.exitCode,
+        signal: outcome.signal,
+        timedOut: outcome.timedOut,
+        durationMs,
+        events
+    });
+}
+
+module.exports = { runAgent };

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

@@ -0,0 +1,97 @@
+'use strict';
+
+// Framework-agnostic bounded-concurrency FIFO scheduler. Deliberately has no
+// Node-RED dependency (same reasoning as lib/execution/lifecycle.js) so it's
+// unit-testable in isolation.
+//
+// This is the entire "concurrency" feature: a plain array + Map, no worker
+// threads, no external queue library. Node-RED's own message-per-invocation
+// 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();
+    }
+
+    get activeCount() {
+        return this.active.size;
+    }
+
+    get queuedCount() {
+        return this.queue.length;
+    }
+
+    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);
+        }
+    }
+
+    _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());
+        }
+    }
+
+    // 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 };
+    }
+}
+
+module.exports = { ExecutionScheduler };

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

@@ -0,0 +1,24 @@
+'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
+// "running/queued counts take precedence" rule (spec section 4) is
+// unit-testable without a Node-RED runtime.
+//
+// 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 (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
+}
+
+module.exports = { computeNodeStatus };

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

@@ -0,0 +1,31 @@
+'use strict';
+
+// Generic mcpServers[] (see AGENTS node schema) -> OpenCode's keyed `mcp`
+// config object, as verified against opencode's real config schema:
+//   { "<name>": { "type": "remote", "url": "...", "enabled": true } }
+//   { "<name>": { "type": "local", "command": ["npx", "-y", "pkg"], "enabled": true } }
+//
+// Each agent adapter owns its own translation; this module is OpenCode's.
+function toOpenCodeMcp(mcpServers) {
+    const out = {};
+    if (!Array.isArray(mcpServers)) return out;
+
+    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.
+    }
+
+    return out;
+}
+
+module.exports = { toOpenCodeMcp };

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

@@ -0,0 +1,21 @@
+'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');
+    }
+
+    async terminate(_executionId) {}
+
+    async cleanup(_executionId) {}
+}
+
+module.exports = { RuntimeProvider };

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

@@ -0,0 +1,28 @@
+'use strict';
+
+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 terminate(executionId) {
+        terminate(executionId);
+    }
+}
+
+module.exports = { DirectRuntime };

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

@@ -0,0 +1,105 @@
+'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 GRACE_PERIOD_MS = 2000;
+
+// executionId -> { child, timeoutTimer, killTimer, timedOut }
+const registry = new Map();
+
+function killProcessGroup(child, signal) {
+    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 {
+            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;
+
+    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);
+
+        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();
+        });
+
+        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('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);
+}
+
+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);
+}
+
+module.exports = { runProcess, terminate, killProcessGroup, GRACE_PERIOD_MS };

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

@@ -0,0 +1,63 @@
+'use strict';
+
+const { RuntimeProvider } = require('./base');
+const { runProcess, terminate } = require('./process-exec');
+
+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
+// (2026-08-13) that `srt`'s default invocation mode --
+//   srt [-s <settings>] <command> [args...]
+// -- passes each argv element through to the sandboxed child literally,
+// with NO shell re-interpretation (confirmed with payloads containing
+// `;`, `&&`, quotes, backticks). Only `srt -c "<string>"` behaves like
+// `sh -c` and would be unsafe with untrusted args -- that mode is
+// deliberately never used here.
+//
+// Because of this, SRT is implemented as a thin argv-prefix transform on
+// 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 : [];
+    }
+
+    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 terminate(executionId) {
+        terminate(executionId);
+    }
+}
+
+module.exports = { SrtRuntime };