@nodetool-ai/base-nodes 0.7.0-rc.11

package/dist/nodes/code.js

@@ -0,0 +1,850 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseNode, prop } from "@nodetool-ai/node-sdk";
+import { PythonDockerRunner, JavaScriptDockerRunner, BashDockerRunner, RubyDockerRunner, LuaRunner, LuaSubprocessRunner, CommandDockerRunner, ContainerFailureError } from "@nodetool-ai/code-runners";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Collect all streamed output from a runner into buffered stdout/stderr. */
+async function collectRunnerOutput(runner, userCode, envLocals, options) {
+    const stdoutBuf = [];
+    const stderrBuf = [];
+    let exitCode = 0;
+    try {
+        for await (const [slot, line] of runner.stream(userCode, envLocals, options)) {
+            if (slot === "stdout")
+                stdoutBuf.push(line);
+            else if (slot === "stderr")
+                stderrBuf.push(line);
+        }
+    }
+    catch (err) {
+        if (err instanceof ContainerFailureError) {
+            exitCode = err.exitCode;
+        }
+        else {
+            exitCode = 1;
+            stderrBuf.push(String(err));
+        }
+    }
+    return {
+        stdout: stdoutBuf.join(""),
+        stderr: stderrBuf.join(""),
+        exit_code: exitCode
+    };
+}
+/** Build an async stdin iterable from a static string. */
+async function* stdinFromString(s) {
+    if (s)
+        yield s;
+}
+// ---------------------------------------------------------------------------
+// Execute* nodes — streaming, use runners with execution_mode
+// ---------------------------------------------------------------------------
+export class ExecutePythonNode extends BaseNode {
+    static nodeType = "nodetool.code.ExecutePython";
+    static title = "Execute Python";
+    static description = "Executes Python code with safety restrictions.\n    python, code, execute\n\n    Use cases:\n    - Run custom data transformations\n    - Prototype node functionality\n    - Debug and testing workflows\n\n    IMPORTANT: Only enabled in non-production environments";
+    static isStreamingOutput = true;
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static requiredRuntimes = ["python"];
+    async process() {
+        const code = String(this.code ?? this.code ?? "");
+        if (!code.trim())
+            throw new Error("Code is required");
+        const mode = String(this.execution_mode ?? this.execution_mode ?? "docker");
+        const image = String(this.image ?? this.image ?? "python:3.11-slim");
+        const stdinStr = String(this.stdin ?? this.stdin ?? "");
+        const runner = new PythonDockerRunner({ image, mode });
+        const result = await collectRunnerOutput(runner, code, {}, {
+            stdinStream: stdinStr ? stdinFromString(stdinStr) : undefined
+        });
+        return {
+            ...result,
+            output: result.stdout,
+            success: result.exit_code === 0
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Code",
+        description: "Python code to execute as-is. Dynamic inputs are provided as local vars. Stdout lines are emitted on 'stdout'; stderr lines on 'stderr'."
+    })
+], ExecutePythonNode.prototype, "code", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "python:3.11-slim",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["python:3.11-slim", "jupyter/scipy-notebook:latest"]
+    })
+], ExecutePythonNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "docker",
+        title: "Execution Mode",
+        description: "Execution mode: 'docker' or 'subprocess'",
+        values: ["docker", "subprocess"]
+    })
+], ExecutePythonNode.prototype, "execution_mode", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Stdin",
+        description: "String to write to process stdin before any streaming input. Use newlines to separate lines."
+    })
+], ExecutePythonNode.prototype, "stdin", void 0);
+export class ExecuteJavaScriptNode extends BaseNode {
+    static nodeType = "nodetool.code.ExecuteJavaScript";
+    static title = "Execute Java Script";
+    static description = "Executes JavaScript (Node.js) code with safety restrictions.\n    javascript, nodejs, code, execute";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static requiredRuntimes = ["nodejs"];
+    async process() {
+        const code = String(this.code ?? this.code ?? "");
+        if (!code.trim())
+            throw new Error("Code is required");
+        const mode = String(this.execution_mode ?? this.execution_mode ?? "docker");
+        const image = String(this.image ?? this.image ?? "node:22-alpine");
+        const stdinStr = String(this.stdin ?? this.stdin ?? "");
+        const runner = new JavaScriptDockerRunner({ image, mode });
+        const result = await collectRunnerOutput(runner, code, {}, {
+            stdinStream: stdinStr ? stdinFromString(stdinStr) : undefined
+        });
+        return {
+            ...result,
+            output: result.stdout,
+            success: result.exit_code === 0
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Code",
+        description: "JavaScript code to execute as-is under Node.js. Dynamic inputs are provided as local vars. Stdout lines are emitted on 'stdout'; stderr lines on 'stderr'."
+    })
+], ExecuteJavaScriptNode.prototype, "code", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "node:22-alpine",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["node:22-alpine"]
+    })
+], ExecuteJavaScriptNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "docker",
+        title: "Execution Mode",
+        description: "Execution mode: 'docker' or 'subprocess'",
+        values: ["docker", "subprocess"]
+    })
+], ExecuteJavaScriptNode.prototype, "execution_mode", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Stdin",
+        description: "String to write to process stdin before any streaming input. Use newlines to separate lines."
+    })
+], ExecuteJavaScriptNode.prototype, "stdin", void 0);
+export class ExecuteBashNode extends BaseNode {
+    static nodeType = "nodetool.code.ExecuteBash";
+    static title = "Execute Bash";
+    static description = "Executes Bash script with safety restrictions.\n    bash, shell, code, execute";
+    static isStreamingOutput = true;
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static requiredRuntimes = ["bash"];
+    async process() {
+        const code = String(this.code ?? this.code ?? "");
+        if (!code.trim())
+            throw new Error("Code is required");
+        const mode = String(this.execution_mode ?? this.execution_mode ?? "docker");
+        const image = String(this.image ?? this.image ?? "ubuntu:22.04");
+        const stdinStr = String(this.stdin ?? this.stdin ?? "");
+        const runner = new BashDockerRunner({ image, mode });
+        const result = await collectRunnerOutput(runner, code, {}, {
+            stdinStream: stdinStr ? stdinFromString(stdinStr) : undefined
+        });
+        return {
+            ...result,
+            output: result.stdout,
+            success: result.exit_code === 0
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Code",
+        description: "Bash script to execute as-is. Dynamic inputs are provided as env vars. Stdout lines are emitted on 'stdout'; stderr lines on 'stderr'."
+    })
+], ExecuteBashNode.prototype, "code", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "ubuntu:22.04",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: [
+            "bash:5.2",
+            "debian:12",
+            "ubuntu:22.04",
+            "ubuntu:24.04",
+            "jupyter/scipy-notebook:latest"
+        ]
+    })
+], ExecuteBashNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "docker",
+        title: "Execution Mode",
+        description: "Execution mode: 'docker' or 'subprocess'",
+        values: ["docker", "subprocess"]
+    })
+], ExecuteBashNode.prototype, "execution_mode", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Stdin",
+        description: "String to write to process stdin before any streaming input. Use newlines to separate lines."
+    })
+], ExecuteBashNode.prototype, "stdin", void 0);
+export class ExecuteRubyNode extends BaseNode {
+    static nodeType = "nodetool.code.ExecuteRuby";
+    static title = "Execute Ruby";
+    static description = "Executes Ruby code with safety restrictions.\n    ruby, code, execute";
+    static isStreamingOutput = true;
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static requiredRuntimes = ["ruby"];
+    async process() {
+        const code = String(this.code ?? this.code ?? "");
+        if (!code.trim())
+            throw new Error("Code is required");
+        const mode = String(this.execution_mode ?? this.execution_mode ?? "docker");
+        const image = String(this.image ?? this.image ?? "ruby:3.3-alpine");
+        const stdinStr = String(this.stdin ?? this.stdin ?? "");
+        const runner = new RubyDockerRunner({ image, mode });
+        const result = await collectRunnerOutput(runner, code, {}, {
+            stdinStream: stdinStr ? stdinFromString(stdinStr) : undefined
+        });
+        return {
+            ...result,
+            output: result.stdout,
+            success: result.exit_code === 0
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Code",
+        description: "Ruby code to execute as-is. Dynamic inputs are provided as env vars. Stdout lines are emitted on 'stdout'; stderr lines on 'stderr'."
+    })
+], ExecuteRubyNode.prototype, "code", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "ruby:3.3-alpine",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["ruby:3.3-alpine"]
+    })
+], ExecuteRubyNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "docker",
+        title: "Execution Mode",
+        description: "Execution mode: 'docker' or 'subprocess'",
+        values: ["docker", "subprocess"]
+    })
+], ExecuteRubyNode.prototype, "execution_mode", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Stdin",
+        description: "String to write to process stdin before any streaming input. Use newlines to separate lines."
+    })
+], ExecuteRubyNode.prototype, "stdin", void 0);
+export class ExecuteLuaNode extends BaseNode {
+    static nodeType = "nodetool.code.ExecuteLua";
+    static title = "Execute Lua";
+    static description = "Executes Lua code with a local sandbox (no Docker).\n    lua, code, execute, sandbox";
+    static isStreamingOutput = true;
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static requiredRuntimes = ["lua"];
+    async process() {
+        const code = String(this.code ?? this.code ?? "");
+        if (!code.trim())
+            throw new Error("Code is required");
+        const mode = String(this.execution_mode ?? this.execution_mode ?? "subprocess");
+        const executable = String(this.executable ?? this.executable ?? "lua");
+        const timeoutSeconds = Number(this.timeout_seconds ?? this.timeout_seconds ?? 10);
+        const stdinStr = String(this.stdin ?? this.stdin ?? "");
+        const runner = mode === "subprocess"
+            ? new LuaSubprocessRunner({ executable, timeoutSeconds })
+            : new LuaRunner({
+                image: "nickblah/lua:5.2.4-luarocks-ubuntu",
+                executable,
+                mode,
+                timeoutSeconds
+            });
+        const result = await collectRunnerOutput(runner, code, {}, {
+            stdinStream: stdinStr ? stdinFromString(stdinStr) : undefined
+        });
+        return {
+            ...result,
+            output: result.stdout,
+            success: result.exit_code === 0
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Code",
+        description: "Lua code to execute as-is in a restricted environment. Dynamic inputs are provided as variables. Stdout lines are emitted on 'stdout'; stderr lines on 'stderr'."
+    })
+], ExecuteLuaNode.prototype, "code", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "lua",
+        title: "Executable",
+        description: "Lua executable to use",
+        values: ["lua", "luajit"]
+    })
+], ExecuteLuaNode.prototype, "executable", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "subprocess",
+        title: "Execution Mode",
+        description: "Execution mode: 'docker' or 'subprocess'",
+        values: ["docker", "subprocess"]
+    })
+], ExecuteLuaNode.prototype, "execution_mode", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 10,
+        title: "Timeout Seconds",
+        description: "Max seconds to allow execution before forced stop"
+    })
+], ExecuteLuaNode.prototype, "timeout_seconds", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Stdin",
+        description: "String to write to process stdin before any streaming input. Use newlines to separate lines."
+    })
+], ExecuteLuaNode.prototype, "stdin", void 0);
+export class ExecuteCommandNode extends BaseNode {
+    static nodeType = "nodetool.code.ExecuteCommand";
+    static title = "Execute Command";
+    static description = "Executes a single shell command inside a Docker container.\n    command, execute, shell, bash, sh\n\n    IMPORTANT: Only enabled in non-production environments";
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static isStreamingOutput = true;
+    async process() {
+        const command = String(this.command ?? this.command ?? "");
+        if (!command.trim())
+            throw new Error("Command is required");
+        const mode = String(this.execution_mode ?? this.execution_mode ?? "docker");
+        const image = String(this.image ?? this.image ?? "bash:5.2");
+        const stdinStr = String(this.stdin ?? this.stdin ?? "");
+        const runner = new CommandDockerRunner({ image, mode });
+        const result = await collectRunnerOutput(runner, command, {}, {
+            stdinStream: stdinStr ? stdinFromString(stdinStr) : undefined
+        });
+        return {
+            ...result,
+            output: result.stdout,
+            success: result.exit_code === 0
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Single command to run via the selected shell. Stdout lines are emitted on 'stdout'; stderr lines on 'stderr'."
+    })
+], ExecuteCommandNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "bash:5.2",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["bash:5.2", "alpine:3", "ubuntu:22.04", "ubuntu:24.04"]
+    })
+], ExecuteCommandNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "docker",
+        title: "Execution Mode",
+        description: "Execution mode: 'docker' or 'subprocess'",
+        values: ["docker", "subprocess"]
+    })
+], ExecuteCommandNode.prototype, "execution_mode", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Stdin",
+        description: "String to write to process stdin before any streaming input. Use newlines to separate lines."
+    })
+], ExecuteCommandNode.prototype, "stdin", void 0);
+// ---------------------------------------------------------------------------
+// RunCommand* nodes — buffered, use runners
+// ---------------------------------------------------------------------------
+/** Helper: create a runner for a RunCommand node given its language and mode. */
+function createRunner(lang, mode, opts) {
+    const m = mode;
+    switch (lang) {
+        case "python":
+            return new PythonDockerRunner({
+                image: opts?.image ?? "python:3.11-slim",
+                mode: m
+            });
+        case "javascript":
+            return new JavaScriptDockerRunner({
+                image: opts?.image ?? "node:22-alpine",
+                mode: m
+            });
+        case "bash":
+            return new BashDockerRunner({
+                image: opts?.image ?? "bash:5.2",
+                mode: m
+            });
+        case "ruby":
+            return new RubyDockerRunner({
+                image: opts?.image ?? "ruby:3.3-alpine",
+                mode: m
+            });
+        case "lua":
+            if (m === "subprocess")
+                return new LuaSubprocessRunner({
+                    executable: opts?.executable ?? "lua",
+                    timeoutSeconds: opts?.timeoutSeconds ?? 10
+                });
+            return new LuaRunner({
+                image: opts?.image ?? "nickblah/lua:5.2.4-luarocks-ubuntu",
+                executable: opts?.executable ?? "lua",
+                mode: m,
+                timeoutSeconds: opts?.timeoutSeconds ?? 10
+            });
+        case "command":
+            return new CommandDockerRunner({
+                image: opts?.image ?? "bash:5.2",
+                mode: m
+            });
+    }
+}
+class RunCommandNode extends BaseNode {
+    /** Language for creating the runner */
+    static lang = "command";
+    /** Default execution mode */
+    static defaultMode = "subprocess";
+    async process() {
+        const command = String(this.command ?? "");
+        if (!command.trim())
+            return {
+                stdout: "",
+                stderr: "",
+                exit_code: 0,
+                output: "",
+                success: true
+            };
+        const cls = this.constructor;
+        const mode = String(this.execution_mode ?? cls.defaultMode);
+        const image = this.image ?? undefined;
+        const executable = this.executable ?? undefined;
+        const timeoutSeconds = Number(this.timeout_seconds ?? 10);
+        const stdinStr = typeof this.stdin === "string"
+            ? String(this.stdin ?? "")
+            : undefined;
+        const runner = createRunner(cls.lang, mode, {
+            image,
+            executable,
+            timeoutSeconds
+        });
+        const result = await collectRunnerOutput(runner, command, {}, {
+            stdinStream: stdinStr ? stdinFromString(stdinStr) : undefined
+        });
+        return {
+            ...result,
+            output: result.stdout,
+            success: result.exit_code === 0
+        };
+    }
+}
+// --- Subprocess (local) variants ---
+export class RunPythonCommandNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunPythonCommand";
+    static title = "Run Python Command";
+    static description = "Executes a single Python command and buffers the output.\n    python, code, execute, command\n\n    Use cases:\n    - Run a single Python script or command\n    - Execute Python code with buffered stdout/stderr output\n    - One-shot Python execution without streaming\n\n    The command is executed once and the complete output is returned.\n    IMPORTANT: Only enabled in non-production environments";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "python";
+    static defaultMode = "subprocess";
+    static requiredRuntimes = ["python"];
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Python command to execute"
+    })
+], RunPythonCommandNode.prototype, "command", void 0);
+export class RunJavaScriptCommandNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunJavaScriptCommand";
+    static title = "Run Java Script Command";
+    static description = "Executes a single JavaScript command and buffers the output.\n    javascript, nodejs, code, execute, command\n\n    Use cases:\n    - Run a single JavaScript script or command\n    - Execute JavaScript code with buffered stdout/stderr output\n    - One-shot JavaScript execution without streaming\n\n    The command is executed once and the complete output is returned.";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "javascript";
+    static defaultMode = "subprocess";
+    static requiredRuntimes = ["nodejs"];
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "JavaScript command to execute"
+    })
+], RunJavaScriptCommandNode.prototype, "command", void 0);
+export class RunBashCommandNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunBashCommand";
+    static title = "Run Bash Command";
+    static description = "Executes a single Bash command and buffers the output.\n    bash, shell, code, execute, command\n\n    Use cases:\n    - Run a single Bash script or command\n    - Execute shell commands with buffered stdout/stderr output\n    - One-shot Bash execution without streaming\n\n    The command is executed once and the complete output is returned.";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "bash";
+    static defaultMode = "subprocess";
+    static requiredRuntimes = ["bash"];
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Bash command to execute"
+    })
+], RunBashCommandNode.prototype, "command", void 0);
+export class RunRubyCommandNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunRubyCommand";
+    static title = "Run Ruby Command";
+    static description = "Executes a single Ruby command and buffers the output.\n    ruby, code, execute, command\n\n    Use cases:\n    - Run a single Ruby script or command\n    - Execute Ruby code with buffered stdout/stderr output\n    - One-shot Ruby execution without streaming\n\n    The command is executed once and the complete output is returned.";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "ruby";
+    static defaultMode = "subprocess";
+    static requiredRuntimes = ["ruby"];
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Ruby command to execute"
+    })
+], RunRubyCommandNode.prototype, "command", void 0);
+export class RunLuaCommandNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunLuaCommand";
+    static title = "Run Lua Command";
+    static description = "Executes a single Lua command and buffers the output.\n    lua, code, execute, command, sandbox\n\n    Use cases:\n    - Run a single Lua script or command\n    - Execute Lua code with buffered stdout/stderr output\n    - One-shot Lua execution without streaming\n\n    The command is executed once and the complete output is returned.";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "lua";
+    static defaultMode = "subprocess";
+    static requiredRuntimes = ["lua"];
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Lua command to execute"
+    })
+], RunLuaCommandNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "lua",
+        title: "Executable",
+        description: "Lua executable to use",
+        values: ["lua", "luajit"]
+    })
+], RunLuaCommandNode.prototype, "executable", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 10,
+        title: "Timeout Seconds",
+        description: "Max seconds to allow execution before forced stop"
+    })
+], RunLuaCommandNode.prototype, "timeout_seconds", void 0);
+export class RunShellCommandNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunShellCommand";
+    static title = "Run Shell Command";
+    static description = "Executes a single shell command and buffers the output.\n    command, execute, shell, bash, sh\n\n    Use cases:\n    - Run a single shell command\n    - Execute shell commands with buffered stdout/stderr output\n    - One-shot command execution without streaming\n\n    The command is executed once and the complete output is returned.\n    IMPORTANT: Only enabled in non-production environments";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "command";
+    static defaultMode = "subprocess";
+    static requiredRuntimes = ["bash"];
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Shell command to execute"
+    })
+], RunShellCommandNode.prototype, "command", void 0);
+// --- Docker variants ---
+export class RunLuaCommandDockerNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunLuaCommandDocker";
+    static title = "Run Lua Command Docker";
+    static description = "Executes a single Lua command in Docker and buffers the output.\n    lua, code, execute, command, sandbox, docker";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "lua";
+    static defaultMode = "docker";
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Lua command to execute"
+    })
+], RunLuaCommandDockerNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "nickblah/lua:5.2.4-luarocks-ubuntu",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["nickblah/lua:5.2.4-luarocks-ubuntu"]
+    })
+], RunLuaCommandDockerNode.prototype, "image", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 10,
+        title: "Timeout Seconds",
+        description: "Max seconds to allow execution before forced stop"
+    })
+], RunLuaCommandDockerNode.prototype, "timeout_seconds", void 0);
+export class RunPythonCommandDockerNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunPythonCommandDocker";
+    static title = "Run Python Command Docker";
+    static description = "Executes a single Python command in Docker and buffers the output.\n    python, code, execute, command, docker";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "python";
+    static defaultMode = "docker";
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Python command to execute"
+    })
+], RunPythonCommandDockerNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "python:3.11-slim",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["python:3.11-slim", "jupyter/scipy-notebook:latest"]
+    })
+], RunPythonCommandDockerNode.prototype, "image", void 0);
+export class RunJavaScriptCommandDockerNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunJavaScriptCommandDocker";
+    static title = "Run Java Script Command Docker";
+    static description = "Executes a single JavaScript command in Docker and buffers the output.\n    javascript, nodejs, code, execute, command, docker";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "javascript";
+    static defaultMode = "docker";
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "JavaScript command to execute"
+    })
+], RunJavaScriptCommandDockerNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "node:22-alpine",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["node:22-alpine"]
+    })
+], RunJavaScriptCommandDockerNode.prototype, "image", void 0);
+export class RunBashCommandDockerNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunBashCommandDocker";
+    static title = "Run Bash Command Docker";
+    static description = "Executes a single Bash command in Docker and buffers the output.\n    bash, shell, code, execute, command, docker";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "bash";
+    static defaultMode = "docker";
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Bash command to execute"
+    })
+], RunBashCommandDockerNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "ubuntu:22.04",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: [
+            "bash:5.2",
+            "debian:12",
+            "ubuntu:22.04",
+            "ubuntu:24.04",
+            "jupyter/scipy-notebook:latest"
+        ]
+    })
+], RunBashCommandDockerNode.prototype, "image", void 0);
+export class RunRubyCommandDockerNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunRubyCommandDocker";
+    static title = "Run Ruby Command Docker";
+    static description = "Executes a single Ruby command in Docker and buffers the output.\n    ruby, code, execute, command, docker";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "ruby";
+    static defaultMode = "docker";
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Ruby command to execute"
+    })
+], RunRubyCommandDockerNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "ruby:3.3-alpine",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["ruby:3.3-alpine"]
+    })
+], RunRubyCommandDockerNode.prototype, "image", void 0);
+export class RunShellCommandDockerNode extends RunCommandNode {
+    static nodeType = "nodetool.code.RunShellCommandDocker";
+    static title = "Run Shell Command Docker";
+    static description = "Executes a single shell command in Docker and buffers the output.\n    command, execute, shell, bash, sh, docker";
+    static isDynamic = true;
+    static supportsDynamicOutputs = true;
+    static metadataOutputTypes = { stdout: "str", stderr: "str" };
+    static lang = "command";
+    static defaultMode = "docker";
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Shell command to execute"
+    })
+], RunShellCommandDockerNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "bash:5.2",
+        title: "Image",
+        description: "Docker image to use for execution",
+        values: ["bash:5.2", "alpine:3", "ubuntu:22.04", "ubuntu:24.04"]
+    })
+], RunShellCommandDockerNode.prototype, "image", void 0);
+// ---------------------------------------------------------------------------
+// Export list (same order as before for compatibility)
+// ---------------------------------------------------------------------------
+export const CODE_NODES = [
+    ExecutePythonNode,
+    ExecuteJavaScriptNode,
+    ExecuteBashNode,
+    ExecuteRubyNode,
+    ExecuteLuaNode,
+    ExecuteCommandNode,
+    RunPythonCommandNode,
+    RunJavaScriptCommandNode,
+    RunBashCommandNode,
+    RunRubyCommandNode,
+    RunLuaCommandNode,
+    RunLuaCommandDockerNode,
+    RunShellCommandNode,
+    RunPythonCommandDockerNode,
+    RunJavaScriptCommandDockerNode,
+    RunBashCommandDockerNode,
+    RunRubyCommandDockerNode,
+    RunShellCommandDockerNode
+];
+//# sourceMappingURL=code.js.map