@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.2

package/dist/nodes/code.js

@@ -1,850 +0,0 @@
-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