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

package/dist/nodes/sandbox.js

@@ -0,0 +1,681 @@
+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 { DockerSandboxProvider, SessionStore } from "@nodetool-ai/sandbox";
+import { randomUUID } from "node:crypto";
+import { runAgentLoop } from "./agents.js";
+const DEFAULT_SCOPE_USER = "no-user";
+const DEFAULT_SCOPE_WORKFLOW = "no-workflow";
+const DEFAULT_SESSION_ID = "workflow";
+const BROWSER_ACTIONS = {
+    view: {
+        toolName: "sandbox_browser_view",
+        description: "Inspect current sandbox browser page and elements.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                include_screenshot: { type: "boolean" }
+            }
+        },
+        invoke: (client, params) => client.browserView(params)
+    },
+    navigate: {
+        toolName: "sandbox_browser_navigate",
+        description: "Navigate the sandbox browser to a URL.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string" },
+                wait_until: {
+                    type: "string",
+                    enum: ["load", "domcontentloaded", "networkidle"]
+                }
+            },
+            required: ["url"]
+        },
+        invoke: (client, params) => client.browserNavigate(params)
+    },
+    restart: {
+        toolName: "sandbox_browser_restart",
+        description: "Restart sandbox browser context.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string" }
+            }
+        },
+        invoke: (client, params) => client.browserRestart(params)
+    },
+    click: {
+        toolName: "sandbox_browser_click",
+        description: "Click an element in the sandbox browser.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                index: { type: "integer" },
+                coordinate_x: { type: "integer" },
+                coordinate_y: { type: "integer" }
+            }
+        },
+        invoke: (client, params) => client.browserClick(params)
+    },
+    input_text: {
+        toolName: "sandbox_browser_input_text",
+        description: "Type into an element in the sandbox browser.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: { type: "string" },
+                press_enter: { type: "boolean" },
+                index: { type: "integer" },
+                coordinate_x: { type: "integer" },
+                coordinate_y: { type: "integer" }
+            },
+            required: ["text"]
+        },
+        invoke: (client, params) => client.browserInput(params)
+    },
+    move_mouse: {
+        toolName: "sandbox_browser_move_mouse",
+        description: "Move mouse in sandbox browser viewport.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                coordinate_x: { type: "integer" },
+                coordinate_y: { type: "integer" }
+            },
+            required: ["coordinate_x", "coordinate_y"]
+        },
+        invoke: (client, params) => client.browserMoveMouse(params)
+    },
+    press_key: {
+        toolName: "sandbox_browser_press_key",
+        description: "Press a keyboard key in the sandbox browser.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                key: { type: "string" }
+            },
+            required: ["key"]
+        },
+        invoke: (client, params) => client.browserPressKey(params)
+    },
+    select_option: {
+        toolName: "sandbox_browser_select_option",
+        description: "Select an option in a sandbox browser select element.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                index: { type: "integer" },
+                option: { type: "string" }
+            },
+            required: ["index", "option"]
+        },
+        invoke: (client, params) => client.browserSelectOption(params)
+    },
+    scroll: {
+        toolName: "sandbox_browser_scroll",
+        description: "Scroll the sandbox browser page.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                to_top: { type: "boolean" },
+                to_bottom: { type: "boolean" },
+                pixels: { type: "integer" }
+            }
+        },
+        invoke: (client, params) => client.browserScroll(params)
+    },
+    console_exec: {
+        toolName: "sandbox_browser_console_exec",
+        description: "Execute JavaScript in sandbox browser console.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                javascript: { type: "string" }
+            },
+            required: ["javascript"]
+        },
+        invoke: (client, params) => client.browserConsoleExec(params)
+    },
+    console_view: {
+        toolName: "sandbox_browser_console_view",
+        description: "View sandbox browser console messages.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                max_lines: { type: "integer" }
+            }
+        },
+        invoke: (client, params) => client.browserConsoleView(params)
+    }
+};
+const FILE_ACTIONS = {
+    read: {
+        toolName: "sandbox_file_read",
+        description: "Read a file from the sandbox.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file: { type: "string" },
+                start_line: { type: "integer" },
+                end_line: { type: "integer" }
+            },
+            required: ["file"]
+        },
+        invoke: (client, params) => client.fileRead(params)
+    },
+    write: {
+        toolName: "sandbox_file_write",
+        description: "Write a file in the sandbox.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file: { type: "string" },
+                content: { type: "string" },
+                append: { type: "boolean" },
+                leading_newline: { type: "boolean" },
+                trailing_newline: { type: "boolean" }
+            },
+            required: ["file", "content"]
+        },
+        invoke: (client, params) => client.fileWrite(params)
+    },
+    str_replace: {
+        toolName: "sandbox_file_str_replace",
+        description: "Replace string content inside a sandbox file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file: { type: "string" },
+                old_str: { type: "string" },
+                new_str: { type: "string" }
+            },
+            required: ["file", "old_str", "new_str"]
+        },
+        invoke: (client, params) => client.fileStrReplace(params)
+    },
+    find_in_content: {
+        toolName: "sandbox_file_find_in_content",
+        description: "Find content in a sandbox file using regex.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file: { type: "string" },
+                regex: { type: "string" }
+            },
+            required: ["file", "regex"]
+        },
+        invoke: (client, params) => client.fileFindInContent(params)
+    },
+    find_by_name: {
+        toolName: "sandbox_file_find_by_name",
+        description: "Find files by glob pattern in sandbox workspace.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string" },
+                glob: { type: "string" }
+            },
+            required: ["path", "glob"]
+        },
+        invoke: (client, params) => client.fileFindByName(params)
+    }
+};
+const SHELL_AGENT_TOOLS = [
+    {
+        toolName: "sandbox_shell_exec",
+        description: "Start a shell command in the sandbox.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+                command: { type: "string" },
+                exec_dir: { type: "string" }
+            },
+            required: ["id", "command"]
+        },
+        invoke: (client, params) => client.shellExec(params)
+    },
+    {
+        toolName: "sandbox_shell_wait",
+        description: "Wait for a shell command in the sandbox and collect output.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+                seconds: { type: "number" }
+            },
+            required: ["id"]
+        },
+        invoke: (client, params) => client.shellWait(params)
+    },
+    {
+        toolName: "sandbox_shell_view",
+        description: "Read current shell command output in the sandbox.",
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"]
+        },
+        invoke: (client, params) => client.shellView(params)
+    },
+    {
+        toolName: "sandbox_shell_write",
+        description: "Write to a running sandbox shell process.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string" },
+                input: { type: "string" },
+                press_enter: { type: "boolean" }
+            },
+            required: ["id", "input", "press_enter"]
+        },
+        invoke: (client, params) => client.shellWriteToProcess(params)
+    },
+    {
+        toolName: "sandbox_shell_kill",
+        description: "Kill a running sandbox shell process.",
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"]
+        },
+        invoke: (client, params) => client.shellKillProcess(params)
+    }
+];
+let sharedSandboxStore = null;
+let sandboxStoreCleanupHooksRegistered = false;
+let sharedSandboxStoreClosePromise = null;
+async function closeSharedSandboxStore() {
+    if (sharedSandboxStoreClosePromise) {
+        return sharedSandboxStoreClosePromise;
+    }
+    if (!sharedSandboxStore) {
+        return;
+    }
+    const store = sharedSandboxStore;
+    sharedSandboxStore = null;
+    const closePromise = (async () => {
+        try {
+            await store.close();
+        }
+        catch {
+            // Best-effort shutdown cleanup: ignore close failures so signal handling can continue.
+        }
+    })();
+    sharedSandboxStoreClosePromise = closePromise;
+    try {
+        await closePromise;
+    }
+    finally {
+        if (sharedSandboxStoreClosePromise === closePromise) {
+            sharedSandboxStoreClosePromise = null;
+        }
+    }
+}
+function registerSandboxStoreCleanupHooks() {
+    if (sandboxStoreCleanupHooksRegistered ||
+        typeof process === "undefined" ||
+        typeof process.once !== "function") {
+        return;
+    }
+    sandboxStoreCleanupHooksRegistered = true;
+    const handleProcessShutdown = (exitCode) => {
+        closeSharedSandboxStore()
+            .catch(() => {
+            // Ignore cleanup errors while handling process shutdown signals.
+        })
+            .finally(() => process.exit(exitCode));
+    };
+    process.once("SIGINT", () => {
+        handleProcessShutdown(130);
+    });
+    process.once("SIGTERM", () => {
+        handleProcessShutdown(143);
+    });
+}
+function getSandboxStore() {
+    registerSandboxStoreCleanupHooks();
+    if (sharedSandboxStore) {
+        return sharedSandboxStore;
+    }
+    sharedSandboxStore = new SessionStore({
+        provider: new DockerSandboxProvider()
+    });
+    return sharedSandboxStore;
+}
+function asRecord(value) {
+    if (value === null ||
+        value === undefined ||
+        typeof value !== "object" ||
+        Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function asString(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    return String(value);
+}
+function asTrimmedString(value) {
+    return asString(value).trim();
+}
+/**
+ * Build a stable context scope used to isolate sandbox sessions per workflow run.
+ * Format: "<userId>:<workflowId>:<jobId>" with explicit fallback tokens.
+ */
+function getContextScope(context) {
+    if (!context) {
+        return `${DEFAULT_SCOPE_USER}:${DEFAULT_SCOPE_WORKFLOW}`;
+    }
+    const userId = asTrimmedString(context.userId) || DEFAULT_SCOPE_USER;
+    const workflowId = asTrimmedString(context.workflowId) || DEFAULT_SCOPE_WORKFLOW;
+    return `${userId}:${workflowId}`;
+}
+function toEffectiveSessionId(sessionId, context) {
+    return `${getContextScope(context)}:${sessionId}`;
+}
+async function getClient(sessionId, workspaceDir, context) {
+    const store = getSandboxStore();
+    const options = {};
+    if (workspaceDir.length > 0) {
+        options.workspaceDir = workspaceDir;
+    }
+    if (context?.userId) {
+        options.env = { NODETOOL_USER_ID: context.userId };
+    }
+    const sandbox = await store.acquire(sessionId, options);
+    return sandbox.client;
+}
+function createAgentTools(client) {
+    const defs = [
+        ...SHELL_AGENT_TOOLS,
+        ...Object.values(FILE_ACTIONS),
+        ...Object.values(BROWSER_ACTIONS)
+    ];
+    return defs.map((def) => ({
+        name: def.toolName,
+        description: def.description,
+        inputSchema: def.inputSchema,
+        process: async (_context, params) => def.invoke(client, params)
+    }));
+}
+export class SandboxShellNode extends BaseNode {
+    static nodeType = "nodetool.sandbox.SandboxShell";
+    static title = "SandboxShell";
+    static description = "Execute shell commands in an isolated sandbox session.";
+    static metadataOutputTypes = {
+        output: "str",
+        running: "bool",
+        exit_code: "union[int, none]",
+        timed_out: "bool"
+    };
+    static exposeAsTool = true;
+    async process(context) {
+        const effectiveSessionId = toEffectiveSessionId(DEFAULT_SESSION_ID, context);
+        const workspaceDir = asTrimmedString(this.workspace_dir);
+        const command = asString(this.command);
+        const normalizedCommand = asTrimmedString(this.command);
+        const waitSeconds = Number(this.wait_seconds ?? 1);
+        const commandId = `cmd-${randomUUID().slice(0, 8)}`;
+        if (normalizedCommand.length === 0) {
+            throw new Error("Command is required");
+        }
+        const client = await getClient(effectiveSessionId, workspaceDir, context);
+        await client.shellExec({
+            id: commandId,
+            command,
+            exec_dir: workspaceDir || undefined
+        });
+        const shellResult = waitSeconds > 0
+            ? await client.shellWait({ id: commandId, seconds: waitSeconds })
+            : await client.shellView({ id: commandId });
+        return {
+            output: shellResult.output,
+            running: shellResult.running,
+            exit_code: shellResult.exit_code,
+            timed_out: "timed_out" in shellResult ? shellResult.timed_out : false
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Workspace Dir",
+        description: "Optional sandbox workspace directory."
+    })
+], SandboxShellNode.prototype, "workspace_dir", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Command",
+        description: "Shell command to execute in the sandbox."
+    })
+], SandboxShellNode.prototype, "command", void 0);
+__decorate([
+    prop({
+        type: "float",
+        default: 1,
+        title: "Wait Seconds",
+        description: "If greater than 0, wait this long for output after launching command."
+    })
+], SandboxShellNode.prototype, "wait_seconds", void 0);
+export class SandboxBrowserNode extends BaseNode {
+    static nodeType = "nodetool.sandbox.SandboxBrowser";
+    static title = "SandboxBrowser";
+    static description = "Control the sandbox browser (navigate, inspect, click, input, and console actions).";
+    static metadataOutputTypes = {
+        output: "dict[str, any]"
+    };
+    static exposeAsTool = true;
+    async process(context) {
+        const effectiveSessionId = toEffectiveSessionId(DEFAULT_SESSION_ID, context);
+        const workspaceDir = asTrimmedString(this.workspace_dir);
+        const action = asTrimmedString(this.action || "view");
+        const params = asRecord(this.params);
+        const client = await getClient(effectiveSessionId, workspaceDir, context);
+        const actionDef = BROWSER_ACTIONS[action];
+        if (!actionDef) {
+            throw new Error(`Unsupported browser action: ${action}`);
+        }
+        const output = await actionDef.invoke(client, params);
+        return {
+            output
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Workspace Dir",
+        description: "Optional sandbox workspace directory."
+    })
+], SandboxBrowserNode.prototype, "workspace_dir", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "view",
+        title: "Action",
+        description: "Browser action to execute.",
+        values: [
+            "view",
+            "navigate",
+            "restart",
+            "click",
+            "input_text",
+            "move_mouse",
+            "press_key",
+            "select_option",
+            "scroll",
+            "console_exec",
+            "console_view"
+        ]
+    })
+], SandboxBrowserNode.prototype, "action", void 0);
+__decorate([
+    prop({
+        type: "dict",
+        default: {},
+        title: "Params",
+        description: "Action parameters validated by the sandbox browser tool."
+    })
+], SandboxBrowserNode.prototype, "params", void 0);
+export class SandboxFileNode extends BaseNode {
+    static nodeType = "nodetool.sandbox.SandboxFile";
+    static title = "SandboxFile";
+    static description = "Read, write, search, and replace files inside a sandbox session.";
+    static metadataOutputTypes = {
+        output: "dict[str, any]"
+    };
+    static exposeAsTool = true;
+    async process(context) {
+        const effectiveSessionId = toEffectiveSessionId(DEFAULT_SESSION_ID, context);
+        const workspaceDir = asTrimmedString(this.workspace_dir);
+        const action = asTrimmedString(this.action || "read");
+        const params = asRecord(this.params);
+        const client = await getClient(effectiveSessionId, workspaceDir, context);
+        const actionDef = FILE_ACTIONS[action];
+        if (!actionDef) {
+            throw new Error(`Unsupported file action: ${action}`);
+        }
+        const output = await actionDef.invoke(client, params);
+        return {
+            output
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Workspace Dir",
+        description: "Optional sandbox workspace directory."
+    })
+], SandboxFileNode.prototype, "workspace_dir", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "read",
+        title: "Action",
+        description: "File action to execute.",
+        values: ["read", "write", "str_replace", "find_in_content", "find_by_name"]
+    })
+], SandboxFileNode.prototype, "action", void 0);
+__decorate([
+    prop({
+        type: "dict",
+        default: {},
+        title: "Params",
+        description: "Action parameters validated by the sandbox file tool."
+    })
+], SandboxFileNode.prototype, "params", void 0);
+export class SandboxAgentNode extends BaseNode {
+    static nodeType = "nodetool.sandbox.SandboxAgent";
+    static title = "SandboxAgent";
+    static description = "Prompt-driven agent with access to configured sandbox shell, browser, and file tools.";
+    static metadataOutputTypes = {
+        text: "str"
+    };
+    static isStreamingOutput = true;
+    async process(context) {
+        const prompt = String(this.prompt ?? "").trim();
+        if (prompt.length === 0) {
+            throw new Error("Prompt is required");
+        }
+        if (!context || typeof context.getProvider !== "function") {
+            throw new Error("Processing context with provider access is required");
+        }
+        const model = (this.model ?? {});
+        const providerId = asTrimmedString(model.provider);
+        const modelId = asTrimmedString(model.id);
+        if (providerId.length === 0 || modelId.length === 0) {
+            throw new Error("Select a model for SandboxAgent.");
+        }
+        const effectiveSessionId = toEffectiveSessionId(DEFAULT_SESSION_ID, context);
+        const workspaceDir = asTrimmedString(this.workspace_dir);
+        const maxIterations = Number(this.max_iterations ?? 12);
+        const client = await getClient(effectiveSessionId, workspaceDir, context);
+        const tools = createAgentTools(client);
+        const { text } = await runAgentLoop({
+            context,
+            providerId,
+            modelId,
+            systemPrompt: String(this.system_prompt ?? "").trim() ||
+                "You are a careful sandbox execution agent. Use tools and provide concise results.",
+            prompt,
+            tools,
+            maxTokens: 4096,
+            maxIterations
+        });
+        return {
+            text
+        };
+    }
+}
+__decorate([
+    prop({
+        type: "language_model",
+        default: {
+            type: "language_model",
+            provider: "empty",
+            id: "",
+            name: "",
+            path: null,
+            supported_tasks: []
+        },
+        title: "Model",
+        description: "Model used by the sandbox agent."
+    })
+], SandboxAgentNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Prompt",
+        description: "Prompt describing what the sandbox agent should do."
+    })
+], SandboxAgentNode.prototype, "prompt", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "System Prompt",
+        description: "Optional system prompt."
+    })
+], SandboxAgentNode.prototype, "system_prompt", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Workspace Dir",
+        description: "Optional sandbox workspace directory."
+    })
+], SandboxAgentNode.prototype, "workspace_dir", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 12,
+        title: "Max Iterations",
+        description: "Maximum agent tool-calling iterations.",
+        min: 1,
+        max: 100
+    })
+], SandboxAgentNode.prototype, "max_iterations", void 0);
+export const SANDBOX_NODES = [
+    SandboxShellNode,
+    SandboxBrowserNode,
+    SandboxFileNode,
+    SandboxAgentNode
+];
+//# sourceMappingURL=sandbox.js.map