@e2b/n8n-nodes-e2b 0.1.0

package/dist/nodes/E2B/E2b.node.js

@@ -0,0 +1,2901 @@
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+
+// dist/nodes/E2B/client.js
+var require_client = __commonJS({
+  "dist/nodes/E2B/client.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createSandbox = createSandbox;
+    exports2.connectSandbox = connectSandbox;
+    exports2.getSandboxInfo = getSandboxInfo;
+    exports2.listSandboxes = listSandboxes;
+    exports2.killSandbox = killSandbox;
+    exports2.pauseSandbox = pauseSandbox;
+    exports2.createSnapshot = createSnapshot;
+    exports2.listSnapshots = listSnapshots;
+    exports2.deleteSnapshot = deleteSnapshot;
+    exports2.createVolume = createVolume;
+    exports2.getVolume = getVolume;
+    exports2.listVolumes = listVolumes;
+    exports2.deleteVolume = deleteVolume;
+    exports2.getPreviewHost = getPreviewHost;
+    exports2.readSandboxFile = readSandboxFile;
+    exports2.writeSandboxFile = writeSandboxFile;
+    exports2.listSandboxFiles = listSandboxFiles;
+    exports2.createSandboxFolder = createSandboxFolder;
+    exports2.deleteSandboxFile = deleteSandboxFile;
+    exports2.getSandboxFileInfo = getSandboxFileInfo;
+    exports2.moveSandboxFile = moveSandboxFile;
+    exports2.runSandboxCommand = runSandboxCommand;
+    var n8n_workflow_12 = require("n8n-workflow");
+    var CREDENTIAL_TYPE = "e2bApi";
+    var DEFAULT_DOMAIN = "e2b.app";
+    var DEFAULT_API_URL = `https://api.${DEFAULT_DOMAIN}`;
+    var DEFAULT_SANDBOX_TIMEOUT_MS = 3e5;
+    var ENVD_PORT = 49983;
+    var ENVD_DEFAULT_USER = "0.4.0";
+    var SUPPORTED_SANDBOX_DOMAINS = /* @__PURE__ */ new Set(["e2b.app", "e2b.dev", "e2b.pro", "e2b-staging.dev"]);
+    var CONNECT_PROTOCOL_VERSION = "1";
+    var CONNECT_END_STREAM_FLAG = 2;
+    var CONNECT_COMPRESSED_FLAG = 1;
+    function asRecord(value) {
+      if (typeof value !== "object" || value === null || Array.isArray(value))
+        return void 0;
+      return Object.fromEntries(Object.entries(value));
+    }
+    function asString(value) {
+      return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+    }
+    function asNumber(value) {
+      const numberValue = typeof value === "number" ? value : Number(value);
+      return Number.isFinite(numberValue) ? numberValue : void 0;
+    }
+    function asBoolean(value) {
+      return typeof value === "boolean" ? value : void 0;
+    }
+    function asStringArray(value) {
+      return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+    }
+    function cleanBaseUrl(url) {
+      return url.replace(/\/+$/, "");
+    }
+    function getCredentialString(credentials, key) {
+      return asString(credentials[key]);
+    }
+    function getApiBaseUrl(credentials) {
+      return cleanBaseUrl(getCredentialString(credentials, "apiUrl") ?? DEFAULT_API_URL);
+    }
+    function getDomain(credentials) {
+      return getCredentialString(credentials, "domain") ?? DEFAULT_DOMAIN;
+    }
+    function getStatusCode(response) {
+      return response.statusCode ?? response.status;
+    }
+    function toJsonObject(value, fallbackMessage) {
+      const record = asRecord(value);
+      if (record)
+        return record;
+      return { message: fallbackMessage };
+    }
+    function getErrorMessageFromBody(body, fallback) {
+      const record = asRecord(body);
+      const message = asString(record?.message);
+      if (message)
+        return message;
+      const error = record?.error;
+      if (typeof error === "string")
+        return error;
+      const nested = asRecord(error);
+      const nestedMessage = asString(nested?.message);
+      return nestedMessage ?? fallback;
+    }
+    function throwApiResponseError(executeFunctions, response, fallbackMessage) {
+      const statusCode = getStatusCode(response);
+      const message = getErrorMessageFromBody(response.body, statusCode ? `${statusCode}: ${fallbackMessage}` : fallbackMessage);
+      throw new n8n_workflow_12.NodeApiError(executeFunctions.getNode(), toJsonObject(response.body, message));
+    }
+    async function apiRequest(connection, method, endpoint, options = {}) {
+      const requestOptions = {
+        method,
+        url: `${getApiBaseUrl(connection.credentials)}${endpoint}`,
+        headers: options.headers,
+        qs: options.qs,
+        body: options.body,
+        encoding: options.encoding,
+        returnFullResponse: options.returnFullResponse,
+        ignoreHttpStatusErrors: options.ignoreHttpStatusErrors,
+        timeout: connection.timeoutMs
+      };
+      try {
+        return await connection.executeFunctions.helpers.httpRequestWithAuthentication.call(connection.executeFunctions, CREDENTIAL_TYPE, requestOptions);
+      } catch (error) {
+        throw new n8n_workflow_12.NodeApiError(connection.executeFunctions.getNode(), toJsonObject(error, "E2B API request failed"));
+      }
+    }
+    async function apiRequestFull(connection, method, endpoint, options = {}) {
+      return await apiRequest(connection, method, endpoint, {
+        ...options,
+        returnFullResponse: true,
+        ignoreHttpStatusErrors: true
+      });
+    }
+    function mapSandboxInfo(value) {
+      const record = asRecord(value) ?? {};
+      return {
+        sandboxId: asString(record.sandboxID) ?? asString(record.sandboxId) ?? "",
+        templateId: asString(record.templateID) ?? asString(record.templateId) ?? "",
+        ...asString(record.alias) ? { name: asString(record.alias) } : {},
+        metadata: asRecord(record.metadata) ?? {},
+        startedAt: asString(record.startedAt),
+        endAt: asString(record.endAt),
+        state: asString(record.state),
+        cpuCount: asNumber(record.cpuCount),
+        memoryMB: asNumber(record.memoryMB),
+        envdVersion: asString(record.envdVersion),
+        allowInternetAccess: asBoolean(record.allowInternetAccess),
+        network: asRecord(record.network),
+        lifecycle: asRecord(record.lifecycle),
+        volumeMounts: Array.isArray(record.volumeMounts) ? record.volumeMounts : [],
+        sandboxDomain: asString(record.domain) ?? asString(record.sandboxDomain)
+      };
+    }
+    function mapConnectedSandbox(value, sandboxId) {
+      const record = asRecord(value) ?? {};
+      return {
+        sandboxId: asString(record.sandboxID) ?? asString(record.sandboxId) ?? sandboxId ?? "",
+        sandboxDomain: asString(record.domain) ?? asString(record.sandboxDomain),
+        envdVersion: asString(record.envdVersion) ?? "0.0.0",
+        envdAccessToken: asString(record.envdAccessToken),
+        trafficAccessToken: asString(record.trafficAccessToken)
+      };
+    }
+    function mapSnapshot(value) {
+      const record = asRecord(value) ?? {};
+      return {
+        snapshotId: asString(record.snapshotID) ?? asString(record.snapshotId) ?? "",
+        names: asStringArray(record.names)
+      };
+    }
+    function mapVolume(value) {
+      const record = asRecord(value) ?? {};
+      return {
+        volumeId: asString(record.volumeID) ?? asString(record.volumeId) ?? "",
+        name: asString(record.name) ?? "",
+        token: asString(record.token)
+      };
+    }
+    function timeoutToSeconds(timeoutMs) {
+      return Math.round(timeoutMs / 1e3);
+    }
+    async function createSandbox(connection, options) {
+      const body = {
+        templateID: options.template ?? "base",
+        metadata: options.metadata,
+        envVars: options.envs,
+        timeout: timeoutToSeconds(options.timeoutMs),
+        secure: true,
+        allow_internet_access: options.allowInternetAccess
+      };
+      if (options.volumeMounts) {
+        body.volumeMounts = Object.entries(options.volumeMounts).map(([path, name]) => ({ name, path }));
+      }
+      const response = await apiRequest(connection, "POST", "/sandboxes", { body });
+      return mapConnectedSandbox(response);
+    }
+    async function connectSandbox(connection, sandboxId) {
+      const response = await apiRequest(connection, "POST", `/sandboxes/${encodeURIComponent(sandboxId)}/connect`, {
+        body: {
+          timeout: timeoutToSeconds(DEFAULT_SANDBOX_TIMEOUT_MS)
+        }
+      });
+      return mapConnectedSandbox(response, sandboxId);
+    }
+    async function getSandboxInfo(connection, sandboxId) {
+      const response = await apiRequest(connection, "GET", `/sandboxes/${encodeURIComponent(sandboxId)}`);
+      return mapSandboxInfo(response);
+    }
+    async function listSandboxes(connection, limit) {
+      const response = await apiRequest(connection, "GET", "/v2/sandboxes", { qs: { limit } });
+      return Array.isArray(response) ? response.map(mapSandboxInfo) : [];
+    }
+    async function killSandbox(connection, sandboxId) {
+      const response = await apiRequestFull(connection, "DELETE", `/sandboxes/${encodeURIComponent(sandboxId)}`);
+      const statusCode = getStatusCode(response);
+      if (statusCode === 404)
+        return false;
+      if (statusCode && statusCode >= 400)
+        throwApiResponseError(connection.executeFunctions, response, "Failed to kill sandbox");
+      return true;
+    }
+    async function pauseSandbox(connection, sandboxId) {
+      const response = await apiRequestFull(connection, "POST", `/sandboxes/${encodeURIComponent(sandboxId)}/pause`, {
+        body: { memory: true }
+      });
+      const statusCode = getStatusCode(response);
+      if (statusCode === 409)
+        return false;
+      if (statusCode && statusCode >= 400)
+        throwApiResponseError(connection.executeFunctions, response, "Failed to pause sandbox");
+      return true;
+    }
+    async function createSnapshot(connection, sandboxId, name) {
+      const response = await apiRequest(connection, "POST", `/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`, {
+        body: name ? { name } : {}
+      });
+      return mapSnapshot(response);
+    }
+    async function listSnapshots(connection, limit, sandboxId) {
+      const response = await apiRequest(connection, "GET", "/snapshots", {
+        qs: {
+          limit,
+          ...sandboxId ? { sandboxID: sandboxId } : {}
+        }
+      });
+      return Array.isArray(response) ? response.map(mapSnapshot) : [];
+    }
+    async function deleteSnapshot(connection, snapshotId) {
+      const response = await apiRequestFull(connection, "DELETE", `/templates/${encodeURIComponent(snapshotId)}`);
+      const statusCode = getStatusCode(response);
+      if (statusCode === 404)
+        return false;
+      if (statusCode && statusCode >= 400)
+        throwApiResponseError(connection.executeFunctions, response, "Failed to delete snapshot");
+      return true;
+    }
+    async function createVolume(connection, name) {
+      const response = await apiRequest(connection, "POST", "/volumes", { body: { name } });
+      return mapVolume(response);
+    }
+    async function getVolume(connection, volumeId) {
+      const response = await apiRequest(connection, "GET", `/volumes/${encodeURIComponent(volumeId)}`);
+      return mapVolume(response);
+    }
+    async function listVolumes(connection) {
+      const response = await apiRequest(connection, "GET", "/volumes");
+      return Array.isArray(response) ? response.map(mapVolume) : [];
+    }
+    async function deleteVolume(connection, volumeId) {
+      const response = await apiRequestFull(connection, "DELETE", `/volumes/${encodeURIComponent(volumeId)}`);
+      const statusCode = getStatusCode(response);
+      if (statusCode === 404)
+        return false;
+      if (statusCode && statusCode >= 400)
+        throwApiResponseError(connection.executeFunctions, response, "Failed to delete volume");
+      return true;
+    }
+    function getSandboxHost(connection, sandboxId, port, sandboxDomain) {
+      return `${port}-${sandboxId}.${sandboxDomain ?? getDomain(connection.credentials)}`;
+    }
+    function getPreviewHost(connection, sandbox, port) {
+      return getSandboxHost(connection, sandbox.sandboxId, port, sandbox.sandboxDomain);
+    }
+    function getEnvdBaseUrl(connection, sandbox) {
+      const sandboxUrl = getCredentialString(connection.credentials, "sandboxUrl");
+      if (sandboxUrl)
+        return cleanBaseUrl(sandboxUrl);
+      const sandboxDomain = sandbox.sandboxDomain ?? getDomain(connection.credentials);
+      if (SUPPORTED_SANDBOX_DOMAINS.has(sandboxDomain)) {
+        return `https://sandbox.${sandboxDomain}`;
+      }
+      return `https://${getSandboxHost(connection, sandbox.sandboxId, ENVD_PORT, sandboxDomain)}`;
+    }
+    function compareVersion(left, right) {
+      const leftParts = left.split(".").map((part) => Number.parseInt(part, 10) || 0);
+      const rightParts = right.split(".").map((part) => Number.parseInt(part, 10) || 0);
+      const length = Math.max(leftParts.length, rightParts.length);
+      for (let index = 0; index < length; index++) {
+        const diff = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+        if (diff !== 0)
+          return diff;
+      }
+      return 0;
+    }
+    function sandboxHeaders(connection, sandbox) {
+      const headers = {
+        "E2b-Sandbox-Id": sandbox.sandboxId,
+        "E2b-Sandbox-Port": ENVD_PORT.toString()
+      };
+      if (sandbox.envdAccessToken) {
+        headers["X-Access-Token"] = sandbox.envdAccessToken;
+      }
+      if (compareVersion(sandbox.envdVersion, ENVD_DEFAULT_USER) < 0) {
+        headers.Authorization = `Basic ${Buffer.from("user:").toString("base64")}`;
+      }
+      return headers;
+    }
+    async function envdRequest(connection, sandbox, method, path, options = {}) {
+      const requestOptions = {
+        method,
+        url: `${getEnvdBaseUrl(connection, sandbox)}${path}`,
+        headers: {
+          ...sandboxHeaders(connection, sandbox),
+          ...options.headers
+        },
+        qs: options.qs,
+        body: options.body,
+        encoding: options.encoding,
+        returnFullResponse: options.returnFullResponse,
+        ignoreHttpStatusErrors: options.ignoreHttpStatusErrors,
+        timeout: connection.timeoutMs
+      };
+      try {
+        return await connection.executeFunctions.helpers.httpRequest(requestOptions);
+      } catch (error) {
+        throw new n8n_workflow_12.NodeApiError(connection.executeFunctions.getNode(), toJsonObject(error, "E2B sandbox request failed"));
+      }
+    }
+    function encodeConnectEnvelope(message) {
+      const payload = Buffer.from(JSON.stringify(message), "utf8");
+      const envelope = Buffer.alloc(payload.length + 5);
+      envelope.writeUInt8(0, 0);
+      envelope.writeUInt32BE(payload.length, 1);
+      payload.copy(envelope, 5);
+      return envelope;
+    }
+    function parseConnectEnvelopes(body) {
+      const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body);
+      const messages = [];
+      let offset = 0;
+      while (offset < buffer.length) {
+        if (offset + 5 > buffer.length) {
+          throw new Error("Incomplete Connect response envelope");
+        }
+        const flags = buffer.readUInt8(offset);
+        const length = buffer.readUInt32BE(offset + 1);
+        const start = offset + 5;
+        const end = start + length;
+        if (end > buffer.length) {
+          throw new Error("Incomplete Connect response message");
+        }
+        if ((flags & CONNECT_COMPRESSED_FLAG) === CONNECT_COMPRESSED_FLAG) {
+          throw new Error("Compressed Connect responses are not supported");
+        }
+        const json = JSON.parse(buffer.subarray(start, end).toString("utf8"));
+        const record = asRecord(json) ?? {};
+        if ((flags & CONNECT_END_STREAM_FLAG) === CONNECT_END_STREAM_FLAG) {
+          const error = asRecord(record.error);
+          if (error)
+            throw new Error(getErrorMessageFromBody(error, "E2B Connect request failed"));
+        } else {
+          messages.push(record);
+        }
+        offset = end;
+      }
+      return messages;
+    }
+    async function connectUnary(connection, sandbox, service, method, body) {
+      const response = await envdRequest(connection, sandbox, "POST", `/${service}/${method}`, {
+        body,
+        headers: {
+          "Content-Type": "application/json",
+          "Connect-Protocol-Version": CONNECT_PROTOCOL_VERSION,
+          "Connect-Timeout-Ms": connection.timeoutMs.toString()
+        },
+        encoding: "json",
+        returnFullResponse: true,
+        ignoreHttpStatusErrors: true
+      });
+      const statusCode = getStatusCode(response);
+      if (statusCode && statusCode >= 400)
+        throwApiResponseError(connection.executeFunctions, response, "E2B Connect request failed");
+      return asRecord(response.body) ?? {};
+    }
+    async function connectStream(connection, sandbox, service, method, body) {
+      const response = await envdRequest(connection, sandbox, "POST", `/${service}/${method}`, {
+        body: encodeConnectEnvelope(body),
+        headers: {
+          "Content-Type": "application/connect+json",
+          "Connect-Protocol-Version": CONNECT_PROTOCOL_VERSION,
+          "Connect-Timeout-Ms": connection.timeoutMs.toString(),
+          "Keepalive-Ping-Interval": "50"
+        },
+        encoding: "arraybuffer",
+        returnFullResponse: true,
+        ignoreHttpStatusErrors: true
+      });
+      const statusCode = getStatusCode(response);
+      if (statusCode && statusCode >= 400)
+        throwApiResponseError(connection.executeFunctions, response, "E2B Connect stream failed");
+      if (!response.body || !(response.body instanceof ArrayBuffer || Buffer.isBuffer(response.body))) {
+        throw new Error("Expected E2B Connect stream response body");
+      }
+      return parseConnectEnvelopes(response.body);
+    }
+    function mapFileType(value) {
+      if (value === 1 || value === "FILE" || value === "FILE_TYPE_FILE")
+        return "file";
+      if (value === 2 || value === "DIRECTORY" || value === "FILE_TYPE_DIRECTORY")
+        return "dir";
+      return void 0;
+    }
+    function mapFileInfo(value) {
+      const record = asRecord(value) ?? {};
+      const modifiedTime = record.modifiedTime;
+      return {
+        name: asString(record.name) ?? "",
+        type: mapFileType(record.type),
+        path: asString(record.path) ?? "",
+        metadata: asRecord(record.metadata),
+        size: asNumber(record.size),
+        mode: asNumber(record.mode),
+        permissions: asString(record.permissions),
+        owner: asString(record.owner),
+        group: asString(record.group),
+        modifiedTime: typeof modifiedTime === "string" ? modifiedTime : asString(asRecord(modifiedTime)?.seconds) ? new Date(Number(asString(asRecord(modifiedTime)?.seconds)) * 1e3).toISOString() : void 0,
+        symlinkTarget: asString(record.symlinkTarget)
+      };
+    }
+    function mapWriteInfo(value) {
+      const record = asRecord(value) ?? {};
+      return {
+        name: asString(record.name) ?? "",
+        type: mapFileType(record.type),
+        path: asString(record.path) ?? "",
+        metadata: asRecord(record.metadata)
+      };
+    }
+    function parseJsonArray(value) {
+      if (Array.isArray(value))
+        return value;
+      if (typeof value !== "string")
+        return [];
+      try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    }
+    async function readSandboxFile(connection, sandbox, path, format) {
+      const response = await envdRequest(connection, sandbox, "GET", "/files", {
+        qs: { path },
+        encoding: format === "bytes" ? "arraybuffer" : "text",
+        returnFullResponse: true,
+        ignoreHttpStatusErrors: true
+      });
+      const statusCode = getStatusCode(response);
+      if (statusCode && statusCode >= 400)
+        throwApiResponseError(connection.executeFunctions, response, "Failed to read sandbox file");
+      if (format === "bytes") {
+        return Buffer.isBuffer(response.body) ? response.body : Buffer.from(response.body);
+      }
+      return typeof response.body === "string" ? response.body : "";
+    }
+    async function writeSandboxFile(connection, sandbox, path, content) {
+      const formData = new FormData();
+      const blobContent = Buffer.isBuffer(content) ? new Uint8Array(content) : content;
+      formData.append("file", new Blob([blobContent]), path);
+      const response = await envdRequest(connection, sandbox, "POST", "/files", {
+        qs: { path },
+        body: formData
+      });
+      const files = parseJsonArray(response);
+      if (files.length === 0)
+        throw new Error("Expected to receive information about written file");
+      return mapWriteInfo(files[0]);
+    }
+    async function listSandboxFiles(connection, sandbox, path, depth) {
+      const response = await connectUnary(connection, sandbox, "filesystem.Filesystem", "ListDir", { path, depth });
+      const entries = Array.isArray(response.entries) ? response.entries : [];
+      return entries.map(mapFileInfo).filter((entry) => entry.type !== void 0);
+    }
+    async function createSandboxFolder(connection, sandbox, path) {
+      const response = await connectUnary(connection, sandbox, "filesystem.Filesystem", "MakeDir", { path });
+      return Object.keys(response).length >= 0;
+    }
+    async function deleteSandboxFile(connection, sandbox, path) {
+      await connectUnary(connection, sandbox, "filesystem.Filesystem", "Remove", { path });
+    }
+    async function getSandboxFileInfo(connection, sandbox, path) {
+      const response = await connectUnary(connection, sandbox, "filesystem.Filesystem", "Stat", { path });
+      return mapFileInfo(response.entry);
+    }
+    async function moveSandboxFile(connection, sandbox, source, destination) {
+      const response = await connectUnary(connection, sandbox, "filesystem.Filesystem", "Move", {
+        source,
+        destination
+      });
+      return mapFileInfo(response.entry);
+    }
+    function decodeBase64Text(value) {
+      if (typeof value !== "string")
+        return "";
+      return Buffer.from(value, "base64").toString("utf8");
+    }
+    function mapCommandEvent(message, result) {
+      const event = asRecord(message.event);
+      if (!event)
+        return;
+      const data = asRecord(event.data);
+      if (data) {
+        result.stdout += decodeBase64Text(data.stdout);
+        result.stderr += decodeBase64Text(data.stderr);
+        return;
+      }
+      const end = asRecord(event.end);
+      if (end) {
+        result.exitCode = asNumber(end.exitCode) ?? result.exitCode;
+        result.error = asString(end.error);
+      }
+    }
+    async function runSandboxCommand(connection, sandbox, command, options = {}) {
+      const process = {
+        cmd: "/bin/bash",
+        args: ["-l", "-c", command],
+        envs: options.envs ?? {}
+      };
+      if (options.cwd)
+        process.cwd = options.cwd;
+      const messages = await connectStream(connection, sandbox, "process.Process", "Start", {
+        process,
+        stdin: false
+      });
+      const result = {
+        exitCode: 0,
+        stdout: "",
+        stderr: ""
+      };
+      for (const message of messages) {
+        mapCommandEvent(message, result);
+      }
+      return result;
+    }
+  }
+});
+
+// dist/nodes/E2B/helpers.js
+var require_helpers = __commonJS({
+  "dist/nodes/E2B/helpers.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.asNonEmptyString = asNonEmptyString;
+    exports2.getErrorMessage = getErrorMessage;
+    exports2.getCollectionParameter = getCollectionParameter;
+    exports2.getRecordString = getRecordString;
+    exports2.getRecordBoolean = getRecordBoolean;
+    exports2.getRecordNumber = getRecordNumber;
+    exports2.splitCommaSeparated = splitCommaSeparated;
+    exports2.quoteShellArg = quoteShellArg;
+    exports2.parseStringMapParameter = parseStringMapParameter;
+    exports2.getTimeoutMs = getTimeoutMs;
+    exports2.getLimit = getLimit;
+    exports2.getPort = getPort;
+    exports2.getRequiredStringParameter = getRequiredStringParameter;
+    exports2.getSandboxCreateOptions = getSandboxCreateOptions;
+    exports2.toSandboxInfoData = toSandboxInfoData;
+    exports2.toSnapshotInfoData = toSnapshotInfoData;
+    exports2.toFileInfoData = toFileInfoData;
+    exports2.toVolumeInfoData = toVolumeInfoData;
+    exports2.toCommandResultData = toCommandResultData;
+    exports2.toOperationCommandResultData = toOperationCommandResultData;
+    var n8n_workflow_12 = require("n8n-workflow");
+    function asNonEmptyString(value) {
+      return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+    }
+    function getErrorMessage(error) {
+      if (error instanceof Error)
+        return error.message;
+      return String(error);
+    }
+    function isRecord(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    function getCollectionParameter(executeFunctions, name, itemIndex) {
+      const value = executeFunctions.getNodeParameter(name, itemIndex, {});
+      return isRecord(value) ? value : {};
+    }
+    function getRecordString(record, key) {
+      return asNonEmptyString(record[key]);
+    }
+    function getRecordBoolean(record, key) {
+      return typeof record[key] === "boolean" ? record[key] : void 0;
+    }
+    function getRecordNumber(record, key) {
+      const value = record[key];
+      const numberValue = typeof value === "number" ? value : Number(value);
+      return Number.isFinite(numberValue) ? numberValue : void 0;
+    }
+    function splitCommaSeparated(value) {
+      if (!value)
+        return void 0;
+      const entries = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+      return entries.length > 0 ? entries : void 0;
+    }
+    function quoteShellArg(value) {
+      return `'${value.replaceAll("'", "'\\''")}'`;
+    }
+    function parseStringMapParameter(executeFunctions, value, displayName, itemIndex) {
+      if (value === void 0 || value === null || value === "")
+        return void 0;
+      let parsed = value;
+      if (typeof value === "string") {
+        try {
+          parsed = JSON.parse(value);
+        } catch (error) {
+          throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), `${displayName} must be valid JSON: ${getErrorMessage(error)}`, { itemIndex });
+        }
+      }
+      if (!isRecord(parsed)) {
+        throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), `${displayName} must be a JSON object`, {
+          itemIndex
+        });
+      }
+      const output = {};
+      for (const [key, entryValue] of Object.entries(parsed)) {
+        if (entryValue === void 0 || entryValue === null)
+          continue;
+        if (typeof entryValue === "object") {
+          throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), `${displayName} values must be strings, numbers, or booleans`, { itemIndex });
+        }
+        output[key] = String(entryValue);
+      }
+      return Object.keys(output).length > 0 ? output : void 0;
+    }
+    function getTimeoutMs(executeFunctions, itemIndex) {
+      const timeoutSeconds = Number(executeFunctions.getNodeParameter("timeoutSeconds", itemIndex, 300));
+      if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
+        throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), "Timeout must be greater than 0", {
+          itemIndex
+        });
+      }
+      return Math.round(timeoutSeconds * 1e3);
+    }
+    function getLimit(executeFunctions, itemIndex) {
+      const limit = Number(executeFunctions.getNodeParameter("limit", itemIndex, 50));
+      if (!Number.isInteger(limit) || limit <= 0) {
+        throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), "Limit must be a positive integer", {
+          itemIndex
+        });
+      }
+      return limit;
+    }
+    function getPort(executeFunctions, itemIndex) {
+      const port = Number(executeFunctions.getNodeParameter("port", itemIndex, 3e3));
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), "Port must be an integer between 1 and 65535", { itemIndex });
+      }
+      return port;
+    }
+    function getRequiredStringParameter(executeFunctions, name, displayName, itemIndex) {
+      const value = asNonEmptyString(executeFunctions.getNodeParameter(name, itemIndex));
+      if (!value) {
+        throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), `${displayName} is required`, {
+          itemIndex
+        });
+      }
+      return value;
+    }
+    function getSandboxCreateOptions(executeFunctions, itemIndex) {
+      const timeoutMs = getTimeoutMs(executeFunctions, itemIndex);
+      const template = asNonEmptyString(executeFunctions.getNodeParameter("template", itemIndex, ""));
+      const metadata = parseStringMapParameter(executeFunctions, executeFunctions.getNodeParameter("metadataJson", itemIndex, ""), "Metadata", itemIndex);
+      const envs = parseStringMapParameter(executeFunctions, executeFunctions.getNodeParameter("envJson", itemIndex, ""), "Environment Variables", itemIndex);
+      const volumeMounts = parseStringMapParameter(executeFunctions, executeFunctions.getNodeParameter("volumeMountsJson", itemIndex, ""), "Volume Mounts", itemIndex);
+      const allowInternetAccess = executeFunctions.getNodeParameter("allowInternetAccess", itemIndex, true) === true;
+      return {
+        ...template ? { template } : {},
+        ...metadata ? { metadata } : {},
+        ...envs ? { envs } : {},
+        ...volumeMounts ? { volumeMounts } : {},
+        allowInternetAccess,
+        timeoutMs
+      };
+    }
+    function toIsoString(value) {
+      if (value instanceof Date)
+        return value.toISOString();
+      return value;
+    }
+    function toSandboxInfoData(info, sandboxDomain) {
+      return {
+        sandboxId: info.sandboxId,
+        templateId: info.templateId,
+        name: info.name,
+        state: info.state,
+        metadata: info.metadata ?? {},
+        startedAt: toIsoString(info.startedAt),
+        endAt: toIsoString(info.endAt),
+        cpuCount: info.cpuCount,
+        memoryMB: info.memoryMB,
+        envdVersion: info.envdVersion,
+        allowInternetAccess: info.allowInternetAccess,
+        network: info.network,
+        lifecycle: info.lifecycle,
+        volumeMounts: info.volumeMounts ?? [],
+        sandboxDomain: sandboxDomain ?? info.sandboxDomain
+      };
+    }
+    function toSnapshotInfoData(info) {
+      return {
+        snapshotId: info.snapshotId,
+        names: info.names
+      };
+    }
+    function toFileInfoData(info) {
+      return {
+        name: info.name,
+        type: info.type,
+        path: info.path,
+        metadata: info.metadata ?? {},
+        ..."size" in info ? {
+          size: info.size,
+          mode: info.mode,
+          permissions: info.permissions,
+          owner: info.owner,
+          group: info.group,
+          modifiedTime: toIsoString(info.modifiedTime),
+          symlinkTarget: info.symlinkTarget
+        } : {}
+      };
+    }
+    function toVolumeInfoData(info) {
+      return {
+        volumeId: info.volumeId,
+        name: info.name,
+        ...info.token ? { token: info.token } : {}
+      };
+    }
+    function toCommandResultData(result, sandbox, command, startedAt, createdSandbox, killedAfterRun) {
+      return {
+        sandboxId: sandbox.sandboxId,
+        sandboxDomain: sandbox.sandboxDomain,
+        createdSandbox,
+        killedAfterRun,
+        command,
+        success: result.exitCode === 0,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        error: result.error,
+        executionTimeMs: Date.now() - startedAt
+      };
+    }
+    function toOperationCommandResultData(result, sandboxId, operation, startedAt, extra = {}) {
+      return {
+        sandboxId,
+        operation,
+        success: result.exitCode === 0,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        error: result.error,
+        executionTimeMs: Date.now() - startedAt,
+        ...extra
+      };
+    }
+  }
+});
+
+// dist/nodes/E2B/actions/code.operations.js
+var require_code_operations = __commonJS({
+  "dist/nodes/E2B/actions/code.operations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.runCommand = runCommand;
+    var n8n_workflow_12 = require("n8n-workflow");
+    var client_1 = require_client();
+    var helpers_12 = require_helpers();
+    async function runCommand(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.asNonEmptyString)(executeFunctions.getNodeParameter("sandboxId", itemIndex, ""));
+      const command = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "command", "Command", itemIndex);
+      const cwd = (0, helpers_12.asNonEmptyString)(executeFunctions.getNodeParameter("cwd", itemIndex, ""));
+      const killAfterRun = executeFunctions.getNodeParameter("killAfterRun", itemIndex, false) === true;
+      const envs = (0, helpers_12.parseStringMapParameter)(executeFunctions, executeFunctions.getNodeParameter("envJson", itemIndex, ""), "Environment Variables", itemIndex);
+      const createdSandbox = !sandboxId;
+      const sandbox = sandboxId ? await (0, client_1.connectSandbox)(connection, sandboxId) : await (0, client_1.createSandbox)(connection, (0, helpers_12.getSandboxCreateOptions)(executeFunctions, itemIndex));
+      let resultData;
+      let executionError;
+      let cleanupError;
+      try {
+        const startedAt = Date.now();
+        const result = await (0, client_1.runSandboxCommand)(connection, sandbox, command, {
+          ...cwd ? { cwd } : {},
+          ...envs ? { envs } : {}
+        });
+        resultData = (0, helpers_12.toCommandResultData)(result, sandbox, command, startedAt, createdSandbox, false);
+      } catch (error) {
+        executionError = error;
+      } finally {
+        if (killAfterRun) {
+          try {
+            await (0, client_1.killSandbox)(connection, sandbox.sandboxId);
+            if (resultData)
+              resultData.killedAfterRun = true;
+          } catch (error) {
+            cleanupError = error;
+            if (resultData)
+              resultData.cleanupError = (0, helpers_12.getErrorMessage)(error);
+          }
+        }
+      }
+      if (executionError) {
+        if (cleanupError) {
+          throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), `E2B command failed and the sandbox could not be killed: ${(0, helpers_12.getErrorMessage)(executionError)}; cleanup error: ${(0, helpers_12.getErrorMessage)(cleanupError)}`, { itemIndex });
+        }
+        throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), (0, helpers_12.getErrorMessage)(executionError), {
+          itemIndex
+        });
+      }
+      if (cleanupError) {
+        throw new n8n_workflow_12.NodeOperationError(executeFunctions.getNode(), `E2B command succeeded but the sandbox could not be killed: ${(0, helpers_12.getErrorMessage)(cleanupError)}`, { itemIndex });
+      }
+      return resultData ? [
+        {
+          json: resultData,
+          pairedItem: { item: itemIndex }
+        }
+      ] : [];
+    }
+  }
+});
+
+// dist/nodes/E2B/actions/file.operations.js
+var require_file_operations = __commonJS({
+  "dist/nodes/E2B/actions/file.operations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createFolder = createFolder;
+    exports2.deleteFile = deleteFile;
+    exports2.download = download;
+    exports2.info = info;
+    exports2.list = list;
+    exports2.move = move;
+    exports2.read = read;
+    exports2.upload = upload;
+    exports2.write = write;
+    var client_1 = require_client();
+    var helpers_12 = require_helpers();
+    async function getConnectedSandbox(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "sandboxId", "Sandbox ID", itemIndex);
+      const sandbox = await (0, client_1.connectSandbox)(connection, sandboxId);
+      return { connection, sandbox, sandboxId };
+    }
+    async function createFolder(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const path = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "path", "Path", itemIndex);
+      const created = await (0, client_1.createSandboxFolder)(connection, sandbox, path);
+      return [
+        {
+          json: {
+            sandboxId,
+            path,
+            created
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function deleteFile(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const path = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "path", "Path", itemIndex);
+      await (0, client_1.deleteSandboxFile)(connection, sandbox, path);
+      return [
+        {
+          json: {
+            sandboxId,
+            path,
+            deleted: true
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function download(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const remotePath = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "remotePath", "Remote Path", itemIndex);
+      const binaryPropertyName = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "binaryPropertyName", "Binary Field", itemIndex);
+      const content = await (0, client_1.readSandboxFile)(connection, sandbox, remotePath, "bytes");
+      const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+      const filename = remotePath.split("/").pop()?.trim() || "download";
+      const binaryData = await executeFunctions.helpers.prepareBinaryData(buffer, filename, "application/octet-stream");
+      return [
+        {
+          json: {
+            sandboxId,
+            remotePath,
+            fileName: filename,
+            sizeBytes: buffer.byteLength
+          },
+          binary: {
+            [binaryPropertyName]: binaryData
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function info(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const path = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "path", "Path", itemIndex);
+      const fileInfo = await (0, client_1.getSandboxFileInfo)(connection, sandbox, path);
+      return [
+        {
+          json: {
+            sandboxId,
+            ...(0, helpers_12.toFileInfoData)(fileInfo)
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function list(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const path = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "path", "Path", itemIndex);
+      const depth = Number(executeFunctions.getNodeParameter("depth", itemIndex, 1));
+      const entries = await (0, client_1.listSandboxFiles)(connection, sandbox, path, Number.isInteger(depth) && depth > 0 ? depth : 1);
+      return [
+        {
+          json: {
+            sandboxId,
+            path,
+            count: entries.length,
+            files: entries.map(helpers_12.toFileInfoData)
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function move(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const source = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "source", "Source", itemIndex);
+      const destination = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "destination", "Destination", itemIndex);
+      const fileInfo = await (0, client_1.moveSandboxFile)(connection, sandbox, source, destination);
+      return [
+        {
+          json: {
+            sandboxId,
+            source,
+            destination,
+            ...(0, helpers_12.toFileInfoData)(fileInfo)
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function read(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const path = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "path", "Path", itemIndex);
+      const content = await (0, client_1.readSandboxFile)(connection, sandbox, path, "text");
+      return [
+        {
+          json: {
+            sandboxId,
+            path,
+            content
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function upload(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const remotePath = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "remotePath", "Remote Path", itemIndex);
+      const binaryPropertyName = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "binaryPropertyName", "Binary Field", itemIndex);
+      const binaryMeta = executeFunctions.helpers.assertBinaryData(itemIndex, binaryPropertyName);
+      const buffer = await executeFunctions.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
+      const fileInfo = await (0, client_1.writeSandboxFile)(connection, sandbox, remotePath, buffer);
+      return [
+        {
+          json: {
+            sandboxId,
+            remotePath,
+            fileName: binaryMeta.fileName,
+            mimeType: binaryMeta.mimeType,
+            sizeBytes: buffer.length,
+            ...(0, helpers_12.toFileInfoData)(fileInfo)
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function write(context) {
+      const { executeFunctions, itemIndex } = context;
+      const { connection, sandbox, sandboxId } = await getConnectedSandbox(context);
+      const path = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "path", "Path", itemIndex);
+      const content = executeFunctions.getNodeParameter("content", itemIndex, "");
+      const fileInfo = await (0, client_1.writeSandboxFile)(connection, sandbox, path, String(content));
+      return [
+        {
+          json: {
+            sandboxId,
+            contentLength: String(content).length,
+            ...(0, helpers_12.toFileInfoData)(fileInfo)
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+  }
+});
+
+// dist/nodes/E2B/actions/git.operations.js
+var require_git_operations = __commonJS({
+  "dist/nodes/E2B/actions/git.operations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.status = status;
+    exports2.add = add;
+    exports2.checkout = checkout;
+    exports2.clone = clone;
+    exports2.commit = commit;
+    exports2.pull = pull;
+    exports2.push = push;
+    var n8n_workflow_12 = require("n8n-workflow");
+    var client_1 = require_client();
+    var helpers_12 = require_helpers();
+    var DEFAULT_GIT_ENV = {
+      GIT_TERMINAL_PROMPT: "0"
+    };
+    function parseAheadBehind(segment) {
+      if (!segment)
+        return { ahead: 0, behind: 0 };
+      let ahead = 0;
+      let behind = 0;
+      if (segment.includes("ahead")) {
+        const value = Number.parseInt(segment.split("ahead")[1].split(",")[0].trim(), 10);
+        ahead = Number.isFinite(value) ? value : 0;
+      }
+      if (segment.includes("behind")) {
+        const value = Number.parseInt(segment.split("behind")[1].split(",")[0].trim(), 10);
+        behind = Number.isFinite(value) ? value : 0;
+      }
+      return { ahead, behind };
+    }
+    function normalizeBranchName(name) {
+      if (name.startsWith("HEAD (detached at ")) {
+        return name.replace("HEAD (detached at ", "").replace(/\)$/, "");
+      }
+      return name.replace("HEAD (no branch)", "HEAD").replace("No commits yet on ", "").replace("Initial commit on ", "");
+    }
+    function deriveStatus(indexStatus, workingStatus) {
+      const statuses = /* @__PURE__ */ new Set([indexStatus, workingStatus]);
+      if (statuses.has("U"))
+        return "conflict";
+      if (statuses.has("R"))
+        return "renamed";
+      if (statuses.has("C"))
+        return "copied";
+      if (statuses.has("D"))
+        return "deleted";
+      if (statuses.has("A"))
+        return "added";
+      if (statuses.has("M"))
+        return "modified";
+      if (statuses.has("T"))
+        return "typechange";
+      if (statuses.has("?"))
+        return "untracked";
+      return "unknown";
+    }
+    function parseGitStatus(output) {
+      const lines = output.split("\n").map((line) => line.replace(/\r$/, "")).filter((line) => line.trim().length > 0);
+      let currentBranch;
+      let upstream;
+      let ahead = 0;
+      let behind = 0;
+      let detached = false;
+      const fileStatus = [];
+      if (lines.length === 0) {
+        return {
+          currentBranch,
+          upstream,
+          ahead,
+          behind,
+          detached,
+          fileStatus,
+          isClean: true,
+          hasChanges: false,
+          hasStaged: false,
+          hasUntracked: false,
+          hasConflicts: false,
+          totalCount: 0,
+          stagedCount: 0,
+          unstagedCount: 0,
+          untrackedCount: 0,
+          conflictCount: 0
+        };
+      }
+      const branchLine = lines[0];
+      if (branchLine.startsWith("## ")) {
+        const branchInfo = branchLine.slice(3);
+        const aheadStart = branchInfo.indexOf(" [");
+        const branchPart = aheadStart === -1 ? branchInfo : branchInfo.slice(0, aheadStart);
+        const aheadPart = aheadStart === -1 ? void 0 : branchInfo.slice(aheadStart + 2, -1);
+        const normalizedBranch = normalizeBranchName(branchPart);
+        const isDetached = branchPart.startsWith("HEAD (detached at ") || branchPart.includes("detached");
+        if (isDetached || normalizedBranch.startsWith("HEAD")) {
+          detached = true;
+        } else if (normalizedBranch.includes("...")) {
+          const [branch, upstreamBranch] = normalizedBranch.split("...");
+          currentBranch = branch || void 0;
+          upstream = upstreamBranch || void 0;
+        } else {
+          currentBranch = normalizedBranch || void 0;
+        }
+        const aheadBehind = parseAheadBehind(aheadPart);
+        ahead = aheadBehind.ahead;
+        behind = aheadBehind.behind;
+      }
+      for (const line of lines.slice(1)) {
+        if (line.startsWith("?? ")) {
+          const name2 = line.slice(3);
+          fileStatus.push({
+            name: name2,
+            status: "untracked",
+            indexStatus: "?",
+            workingTreeStatus: "?",
+            staged: false
+          });
+          continue;
+        }
+        if (line.length < 3)
+          continue;
+        const indexStatus = line[0];
+        const workingTreeStatus = line[1];
+        const path = line.slice(3);
+        let renamedFrom;
+        let name = path;
+        if (path.includes(" -> ")) {
+          const parts = path.split(" -> ");
+          renamedFrom = parts[0];
+          name = parts.slice(1).join(" -> ");
+        }
+        fileStatus.push({
+          name,
+          status: deriveStatus(indexStatus, workingTreeStatus),
+          indexStatus,
+          workingTreeStatus,
+          staged: indexStatus !== " " && indexStatus !== "?",
+          ...renamedFrom ? { renamedFrom } : {}
+        });
+      }
+      const totalCount = fileStatus.length;
+      const stagedCount = fileStatus.filter((item) => item.staged).length;
+      const untrackedCount = fileStatus.filter((item) => item.status === "untracked").length;
+      const conflictCount = fileStatus.filter((item) => item.status === "conflict").length;
+      const unstagedCount = totalCount - stagedCount;
+      return {
+        currentBranch,
+        upstream,
+        ahead,
+        behind,
+        detached,
+        fileStatus,
+        isClean: totalCount === 0,
+        hasChanges: totalCount > 0,
+        hasStaged: stagedCount > 0,
+        hasUntracked: untrackedCount > 0,
+        hasConflicts: conflictCount > 0,
+        totalCount,
+        stagedCount,
+        unstagedCount,
+        untrackedCount,
+        conflictCount
+      };
+    }
+    function buildGitCommand(args, repoPath) {
+      const parts = ["git"];
+      if (repoPath)
+        parts.push("-C", repoPath);
+      parts.push(...args);
+      return parts.map(helpers_12.quoteShellArg).join(" ");
+    }
+    function resultMessage(result) {
+      const details = [result.error, result.stderr.trim(), result.stdout.trim()].filter((entry) => entry && entry.length > 0).join("; ");
+      return details || `Git command exited with code ${result.exitCode}`;
+    }
+    function commandText(result) {
+      return `${result.stderr}
+${result.stdout}`.toLowerCase();
+    }
+    function isAuthFailure(result) {
+      if (result.exitCode === 0)
+        return false;
+      const message = commandText(result);
+      const authSnippets = [
+        "authentication failed",
+        "terminal prompts disabled",
+        "could not read username",
+        "invalid username or password",
+        "access denied",
+        "permission denied",
+        "not authorized"
+      ];
+      return authSnippets.some((snippet) => message.includes(snippet));
+    }
+    function isMissingUpstream(result) {
+      if (result.exitCode === 0)
+        return false;
+      const message = commandText(result);
+      const upstreamSnippets = [
+        "has no upstream branch",
+        "no upstream branch",
+        "no upstream configured",
+        "no tracking information for the current branch",
+        "no tracking information",
+        "set the remote as upstream",
+        "set the upstream branch",
+        "please specify which branch you want to merge with"
+      ];
+      return upstreamSnippets.some((snippet) => message.includes(snippet));
+    }
+    function buildAuthErrorMessage(action, missingPassword) {
+      if (missingPassword) {
+        return `Git ${action} requires a password/token for private repositories.`;
+      }
+      return `Git ${action} requires credentials for private repositories.`;
+    }
+    function buildUpstreamErrorMessage(action) {
+      if (action === "push") {
+        return "Git push failed because no upstream branch is configured. Set upstream once with the Set Upstream option, or pass remote and branch explicitly.";
+      }
+      return "Git pull failed because no upstream branch is configured. Pass remote and branch explicitly, or set upstream once before pulling.";
+    }
+    function throwGitError(context, message) {
+      throw new n8n_workflow_12.NodeOperationError(context.executeFunctions.getNode(), message, {
+        itemIndex: context.itemIndex
+      });
+    }
+    function addCredentialsToUrl(context, url, username, password) {
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        throwGitError(context, `Invalid Git URL: ${url}`);
+      }
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throwGitError(context, "Only http(s) Git URLs support username/password credentials.");
+      }
+      parsed.username = username;
+      parsed.password = password;
+      return parsed.toString();
+    }
+    function stripCredentials(url) {
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        return url;
+      }
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+        return url;
+      if (!parsed.username && !parsed.password)
+        return url;
+      parsed.username = "";
+      parsed.password = "";
+      return parsed.toString();
+    }
+    function buildPushArgs(remote, branch, setUpstream) {
+      const args = ["push"];
+      if (setUpstream && remote)
+        args.push("--set-upstream");
+      if (remote)
+        args.push(remote);
+      if (branch)
+        args.push(branch);
+      return args;
+    }
+    async function getGitContext(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "sandboxId", "Sandbox ID", itemIndex);
+      const repositoryPath = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "repositoryPath", "Repository Path", itemIndex);
+      const sandbox = await (0, client_1.connectSandbox)(connection, sandboxId);
+      const startedAt = Date.now();
+      return { ...context, connection, sandbox, sandboxId, repositoryPath, startedAt };
+    }
+    async function runGit(context, args, repoPath = context.repositoryPath, envs) {
+      const targetRepoPath = repoPath === null ? void 0 : repoPath;
+      return await (0, client_1.runSandboxCommand)(context.connection, context.sandbox, buildGitCommand(args, targetRepoPath), {
+        envs: { ...DEFAULT_GIT_ENV, ...envs ?? {} }
+      });
+    }
+    function assertSuccessfulGitResult(context, result) {
+      if (result.exitCode === 0)
+        return;
+      throwGitError(context, resultMessage(result));
+    }
+    async function getRemoteUrl(context, remote) {
+      const result = await runGit(context, ["remote", "get-url", remote]);
+      assertSuccessfulGitResult(context, result);
+      const url = result.stdout.trim();
+      if (!url)
+        throwGitError(context, `Remote "${remote}" URL not found in repository.`);
+      return url;
+    }
+    async function resolveRemoteName(context, remote) {
+      if (remote)
+        return remote;
+      const result = await runGit(context, ["remote"]);
+      assertSuccessfulGitResult(context, result);
+      const remotes = result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+      if (remotes.length === 1)
+        return remotes[0];
+      throwGitError(context, "Remote is required when using username/password and the repository has multiple remotes.");
+    }
+    async function withRemoteCredentials(context, remote, username, password, operation) {
+      const originalUrl = await getRemoteUrl(context, remote);
+      const credentialUrl = addCredentialsToUrl(context, originalUrl, username, password);
+      assertSuccessfulGitResult(context, await runGit(context, ["remote", "set-url", remote, credentialUrl]));
+      let operationResult;
+      let operationError;
+      try {
+        operationResult = await operation();
+      } catch (error) {
+        operationError = error;
+      }
+      let restoreError;
+      try {
+        assertSuccessfulGitResult(context, await runGit(context, ["remote", "set-url", remote, originalUrl]));
+      } catch (error) {
+        restoreError = error;
+      }
+      if (operationError)
+        throw operationError;
+      if (restoreError)
+        throw restoreError;
+      if (!operationResult)
+        throwGitError(context, "Git operation did not return a result.");
+      return operationResult;
+    }
+    function handleAuthOrUpstreamError(context, result, action, missingPassword) {
+      if (isAuthFailure(result))
+        throwGitError(context, buildAuthErrorMessage(action, missingPassword));
+      if ((action === "push" || action === "pull") && isMissingUpstream(result)) {
+        throwGitError(context, buildUpstreamErrorMessage(action));
+      }
+    }
+    async function status(context) {
+      const gitContext = await getGitContext(context);
+      const result = await runGit(gitContext, ["status", "--porcelain=1", "-b"]);
+      assertSuccessfulGitResult(gitContext, result);
+      const statusData = parseGitStatus(result.stdout);
+      return [
+        {
+          json: {
+            sandboxId: gitContext.sandboxId,
+            repositoryPath: gitContext.repositoryPath,
+            status: statusData
+          },
+          pairedItem: { item: context.itemIndex }
+        }
+      ];
+    }
+    async function add(context) {
+      const gitContext = await getGitContext(context);
+      const filesRaw = (0, helpers_12.asNonEmptyString)(context.executeFunctions.getNodeParameter("files", context.itemIndex, "."));
+      const files = (0, helpers_12.splitCommaSeparated)(filesRaw);
+      const addAll = !files || files.length === 1 && files[0] === ".";
+      const result = await runGit(gitContext, addAll ? ["add", "-A"] : ["add", "--", ...files ?? []]);
+      return [
+        {
+          json: (0, helpers_12.toOperationCommandResultData)(result, gitContext.sandboxId, "git.add", gitContext.startedAt, {
+            repositoryPath: gitContext.repositoryPath,
+            files: addAll ? ["."] : files
+          }),
+          pairedItem: { item: context.itemIndex }
+        }
+      ];
+    }
+    async function checkout(context) {
+      const gitContext = await getGitContext(context);
+      const gitRef = (0, helpers_12.getRequiredStringParameter)(context.executeFunctions, "gitRef", "Git Ref", context.itemIndex);
+      const result = await runGit(gitContext, ["checkout", gitRef]);
+      return [
+        {
+          json: (0, helpers_12.toOperationCommandResultData)(result, gitContext.sandboxId, "git.checkout", gitContext.startedAt, {
+            repositoryPath: gitContext.repositoryPath,
+            gitRef
+          }),
+          pairedItem: { item: context.itemIndex }
+        }
+      ];
+    }
+    async function clone(context) {
+      const gitContext = await getGitContext(context);
+      const repositoryUrl = (0, helpers_12.getRequiredStringParameter)(context.executeFunctions, "repositoryUrl", "Repository URL", context.itemIndex);
+      const cloneOptions = (0, helpers_12.getCollectionParameter)(context.executeFunctions, "cloneOptions", context.itemIndex);
+      const branch = (0, helpers_12.getRecordString)(cloneOptions, "branch");
+      const commitId = (0, helpers_12.getRecordString)(cloneOptions, "commitId");
+      const depth = (0, helpers_12.getRecordNumber)(cloneOptions, "depth");
+      const username = (0, helpers_12.getRecordString)(cloneOptions, "username");
+      const password = (0, helpers_12.getRecordString)(cloneOptions, "password");
+      const dangerouslyStoreCredentials = (0, helpers_12.getRecordBoolean)(cloneOptions, "dangerouslyStoreCredentials") === true;
+      if (password && !username) {
+        throwGitError(context, "Username is required when using a password or token for git clone.");
+      }
+      const urlWithCreds = username && password ? addCredentialsToUrl(context, repositoryUrl, username, password) : repositoryUrl;
+      const sanitizedUrl = stripCredentials(urlWithCreds);
+      const shouldStripInlineCreds = !dangerouslyStoreCredentials && sanitizedUrl !== urlWithCreds;
+      const args = ["clone", urlWithCreds];
+      if (branch)
+        args.push("--branch", branch, "--single-branch");
+      if (depth)
+        args.push("--depth", depth.toString());
+      args.push(gitContext.repositoryPath);
+      const result = await runGit(gitContext, args, null);
+      handleAuthOrUpstreamError(gitContext, result, "clone", Boolean(username) && !password);
+      if (shouldStripInlineCreds && result.exitCode === 0) {
+        assertSuccessfulGitResult(gitContext, await runGit(gitContext, ["remote", "set-url", "origin", sanitizedUrl]));
+      }
+      const resultData = (0, helpers_12.toOperationCommandResultData)(result, gitContext.sandboxId, "git.clone", gitContext.startedAt, {
+        repositoryPath: gitContext.repositoryPath,
+        repositoryUrl,
+        branch,
+        depth
+      });
+      if (commitId) {
+        const checkoutResult = await runGit(gitContext, ["checkout", commitId]);
+        resultData.checkout = {
+          success: checkoutResult.exitCode === 0,
+          exitCode: checkoutResult.exitCode,
+          stdout: checkoutResult.stdout,
+          stderr: checkoutResult.stderr,
+          error: checkoutResult.error,
+          commitId
+        };
+        resultData.success = result.exitCode === 0 && checkoutResult.exitCode === 0;
+      }
+      return [
+        {
+          json: resultData,
+          pairedItem: { item: context.itemIndex }
+        }
+      ];
+    }
+    async function commit(context) {
+      const gitContext = await getGitContext(context);
+      const message = (0, helpers_12.getRequiredStringParameter)(context.executeFunctions, "message", "Message", context.itemIndex);
+      const commitOptions = (0, helpers_12.getCollectionParameter)(context.executeFunctions, "commitOptions", context.itemIndex);
+      const authorName = (0, helpers_12.asNonEmptyString)(context.executeFunctions.getNodeParameter("authorName", context.itemIndex, ""));
+      const authorEmail = (0, helpers_12.asNonEmptyString)(context.executeFunctions.getNodeParameter("authorEmail", context.itemIndex, ""));
+      const allowEmpty = (0, helpers_12.getRecordBoolean)(commitOptions, "allowEmpty") === true;
+      const args = ["commit", "-m", message];
+      if (allowEmpty)
+        args.push("--allow-empty");
+      const authorArgs = [];
+      if (authorName)
+        authorArgs.push("-c", `user.name=${authorName}`);
+      if (authorEmail)
+        authorArgs.push("-c", `user.email=${authorEmail}`);
+      const result = await runGit(gitContext, [...authorArgs, ...args]);
+      return [
+        {
+          json: (0, helpers_12.toOperationCommandResultData)(result, gitContext.sandboxId, "git.commit", gitContext.startedAt, {
+            repositoryPath: gitContext.repositoryPath,
+            message,
+            authorName,
+            authorEmail,
+            allowEmpty
+          }),
+          pairedItem: { item: context.itemIndex }
+        }
+      ];
+    }
+    async function pull(context) {
+      const gitContext = await getGitContext(context);
+      const remoteOptions = (0, helpers_12.getCollectionParameter)(context.executeFunctions, "remoteOptions", context.itemIndex);
+      const remote = (0, helpers_12.getRecordString)(remoteOptions, "remote");
+      const branch = (0, helpers_12.getRecordString)(remoteOptions, "branch");
+      const username = (0, helpers_12.getRecordString)(remoteOptions, "username");
+      const password = (0, helpers_12.getRecordString)(remoteOptions, "password");
+      if (password && !username) {
+        throwGitError(context, "Username is required when using a password or token for git pull.");
+      }
+      if (!remote && !branch) {
+        const hasUpstream = await runGit(gitContext, [
+          "rev-parse",
+          "--abbrev-ref",
+          "--symbolic-full-name",
+          "@{u}"
+        ]);
+        if (hasUpstream.exitCode !== 0 || hasUpstream.stdout.trim().length === 0) {
+          throwGitError(gitContext, buildUpstreamErrorMessage("pull"));
+        }
+      }
+      const args = ["pull"];
+      if (remote)
+        args.push(remote);
+      if (branch)
+        args.push(branch);
+      const result = username && password ? await withRemoteCredentials(gitContext, await resolveRemoteName(gitContext, remote), username, password, async () => await runGit(gitContext, args)) : await runGit(gitContext, args);
+      handleAuthOrUpstreamError(gitContext, result, "pull", Boolean(username) && !password);
+      return [
+        {
+          json: (0, helpers_12.toOperationCommandResultData)(result, gitContext.sandboxId, "git.pull", gitContext.startedAt, {
+            repositoryPath: gitContext.repositoryPath,
+            remote,
+            branch
+          }),
+          pairedItem: { item: context.itemIndex }
+        }
+      ];
+    }
+    async function push(context) {
+      const gitContext = await getGitContext(context);
+      const remoteOptions = (0, helpers_12.getCollectionParameter)(context.executeFunctions, "remoteOptions", context.itemIndex);
+      const remote = (0, helpers_12.getRecordString)(remoteOptions, "remote");
+      const branch = (0, helpers_12.getRecordString)(remoteOptions, "branch");
+      const setUpstream = (0, helpers_12.getRecordBoolean)(remoteOptions, "setUpstream") === true;
+      const username = (0, helpers_12.getRecordString)(remoteOptions, "username");
+      const password = (0, helpers_12.getRecordString)(remoteOptions, "password");
+      if (password && !username) {
+        throwGitError(context, "Username is required when using a password or token for git push.");
+      }
+      const args = buildPushArgs(remote, branch, setUpstream);
+      let result;
+      if (username && password) {
+        const remoteName = await resolveRemoteName(gitContext, remote);
+        result = await withRemoteCredentials(gitContext, remoteName, username, password, async () => await runGit(gitContext, buildPushArgs(remoteName, branch, setUpstream)));
+      } else {
+        result = await runGit(gitContext, args);
+      }
+      handleAuthOrUpstreamError(gitContext, result, "push", Boolean(username) && !password);
+      return [
+        {
+          json: (0, helpers_12.toOperationCommandResultData)(result, gitContext.sandboxId, "git.push", gitContext.startedAt, {
+            repositoryPath: gitContext.repositoryPath,
+            remote,
+            branch,
+            setUpstream
+          }),
+          pairedItem: { item: context.itemIndex }
+        }
+      ];
+    }
+  }
+});
+
+// dist/nodes/E2B/actions/sandbox.operations.js
+var require_sandbox_operations = __commonJS({
+  "dist/nodes/E2B/actions/sandbox.operations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.create = create;
+    exports2.get = get;
+    exports2.getMany = getMany;
+    exports2.getPreviewUrl = getPreviewUrl;
+    exports2.kill = kill;
+    exports2.pause = pause;
+    var client_1 = require_client();
+    var helpers_12 = require_helpers();
+    async function create(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandbox = await (0, client_1.createSandbox)(connection, (0, helpers_12.getSandboxCreateOptions)(executeFunctions, itemIndex));
+      const info = await (0, client_1.getSandboxInfo)(connection, sandbox.sandboxId);
+      return [
+        {
+          json: (0, helpers_12.toSandboxInfoData)(info, sandbox.sandboxDomain),
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function get(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "sandboxId", "Sandbox ID", itemIndex);
+      const info = await (0, client_1.getSandboxInfo)(connection, sandboxId);
+      return [
+        {
+          json: (0, helpers_12.toSandboxInfoData)(info),
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function getMany(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxes = await (0, client_1.listSandboxes)(connection, (0, helpers_12.getLimit)(executeFunctions, itemIndex));
+      return sandboxes.map((sandbox) => ({
+        json: (0, helpers_12.toSandboxInfoData)(sandbox),
+        pairedItem: { item: itemIndex }
+      }));
+    }
+    async function getPreviewUrl(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "sandboxId", "Sandbox ID", itemIndex);
+      const port = (0, helpers_12.getPort)(executeFunctions, itemIndex);
+      const sandbox = await (0, client_1.connectSandbox)(connection, sandboxId);
+      const host = (0, client_1.getPreviewHost)(connection, sandbox, port);
+      return [
+        {
+          json: {
+            sandboxId,
+            port,
+            host,
+            url: `https://${host}`
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function kill(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "sandboxId", "Sandbox ID", itemIndex);
+      const killed = await (0, client_1.killSandbox)(connection, sandboxId);
+      return [
+        {
+          json: {
+            sandboxId,
+            killed
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function pause(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "sandboxId", "Sandbox ID", itemIndex);
+      const paused = await (0, client_1.pauseSandbox)(connection, sandboxId);
+      return [
+        {
+          json: {
+            sandboxId,
+            paused
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+  }
+});
+
+// dist/nodes/E2B/actions/snapshot.operations.js
+var require_snapshot_operations = __commonJS({
+  "dist/nodes/E2B/actions/snapshot.operations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.create = create;
+    exports2.getMany = getMany;
+    exports2.deleteSnapshot = deleteSnapshot;
+    var client_1 = require_client();
+    var helpers_12 = require_helpers();
+    async function create(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "sandboxId", "Sandbox ID", itemIndex);
+      const snapshotName = (0, helpers_12.asNonEmptyString)(executeFunctions.getNodeParameter("snapshotName", itemIndex, ""));
+      const snapshot = await (0, client_1.createSnapshot)(connection, sandboxId, snapshotName);
+      return [
+        {
+          json: (0, helpers_12.toSnapshotInfoData)(snapshot),
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function getMany(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const sandboxId = (0, helpers_12.asNonEmptyString)(executeFunctions.getNodeParameter("sandboxId", itemIndex, ""));
+      const snapshots = await (0, client_1.listSnapshots)(connection, (0, helpers_12.getLimit)(executeFunctions, itemIndex), sandboxId);
+      return snapshots.map((snapshot) => ({
+        json: (0, helpers_12.toSnapshotInfoData)(snapshot),
+        pairedItem: { item: itemIndex }
+      }));
+    }
+    async function deleteSnapshot(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const snapshotId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "snapshotId", "Snapshot ID", itemIndex);
+      const deleted = await (0, client_1.deleteSnapshot)(connection, snapshotId);
+      return [
+        {
+          json: {
+            snapshotId,
+            deleted
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+  }
+});
+
+// dist/nodes/E2B/actions/volume.operations.js
+var require_volume_operations = __commonJS({
+  "dist/nodes/E2B/actions/volume.operations.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.create = create;
+    exports2.get = get;
+    exports2.getMany = getMany;
+    exports2.deleteVolume = deleteVolume;
+    var client_1 = require_client();
+    var helpers_12 = require_helpers();
+    async function create(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const name = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "volumeName", "Volume Name", itemIndex);
+      const volume = await (0, client_1.createVolume)(connection, name);
+      return [
+        {
+          json: (0, helpers_12.toVolumeInfoData)(volume),
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function get(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const volumeId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "volumeId", "Volume ID", itemIndex);
+      const volume = await (0, client_1.getVolume)(connection, volumeId);
+      return [
+        {
+          json: (0, helpers_12.toVolumeInfoData)(volume),
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+    async function getMany(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const volumes = await (0, client_1.listVolumes)(connection);
+      return volumes.slice(0, (0, helpers_12.getLimit)(executeFunctions, itemIndex)).map((volume) => ({
+        json: (0, helpers_12.toVolumeInfoData)(volume),
+        pairedItem: { item: itemIndex }
+      }));
+    }
+    async function deleteVolume(context) {
+      const { executeFunctions, credentials, itemIndex, timeoutMs } = context;
+      const connection = { executeFunctions, credentials, timeoutMs };
+      const volumeId = (0, helpers_12.getRequiredStringParameter)(executeFunctions, "volumeId", "Volume ID", itemIndex);
+      const deleted = await (0, client_1.deleteVolume)(connection, volumeId);
+      return [
+        {
+          json: {
+            volumeId,
+            deleted
+          },
+          pairedItem: { item: itemIndex }
+        }
+      ];
+    }
+  }
+});
+
+// dist/nodes/E2B/actions/index.js
+var require_actions = __commonJS({
+  "dist/nodes/E2B/actions/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getOperationHandler = getOperationHandler;
+    var code = __importStar(require_code_operations());
+    var file = __importStar(require_file_operations());
+    var git = __importStar(require_git_operations());
+    var sandbox = __importStar(require_sandbox_operations());
+    var snapshot = __importStar(require_snapshot_operations());
+    var volume = __importStar(require_volume_operations());
+    var operationHandlers = {
+      code: {
+        runCommand: code.runCommand
+      },
+      file: {
+        createFolder: file.createFolder,
+        delete: file.deleteFile,
+        download: file.download,
+        info: file.info,
+        list: file.list,
+        move: file.move,
+        read: file.read,
+        upload: file.upload,
+        write: file.write
+      },
+      git: {
+        add: git.add,
+        checkout: git.checkout,
+        clone: git.clone,
+        commit: git.commit,
+        pull: git.pull,
+        push: git.push,
+        status: git.status
+      },
+      sandbox: {
+        create: sandbox.create,
+        get: sandbox.get,
+        getMany: sandbox.getMany,
+        getPreviewUrl: sandbox.getPreviewUrl,
+        kill: sandbox.kill,
+        pause: sandbox.pause
+      },
+      snapshot: {
+        create: snapshot.create,
+        delete: snapshot.deleteSnapshot,
+        getMany: snapshot.getMany
+      },
+      volume: {
+        create: volume.create,
+        delete: volume.deleteVolume,
+        get: volume.get,
+        getMany: volume.getMany
+      }
+    };
+    function getOperationHandler(resource, operation) {
+      const resourceHandlers = operationHandlers[resource];
+      const handler = resourceHandlers[operation];
+      if (!handler) {
+        throw new Error(`Operation "${operation}" is not implemented for resource "${resource}"`);
+      }
+      return handler;
+    }
+  }
+});
+
+// dist/nodes/E2B/types.js
+var require_types = __commonJS({
+  "dist/nodes/E2B/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RESOURCE_OPERATIONS = void 0;
+    exports2.isResource = isResource;
+    exports2.isOperationForResource = isOperationForResource;
+    exports2.RESOURCE_OPERATIONS = {
+      code: ["runCommand"],
+      file: ["createFolder", "delete", "download", "info", "list", "move", "read", "upload", "write"],
+      git: ["add", "checkout", "clone", "commit", "pull", "push", "status"],
+      sandbox: ["create", "get", "getMany", "getPreviewUrl", "kill", "pause"],
+      snapshot: ["create", "delete", "getMany"],
+      volume: ["create", "delete", "get", "getMany"]
+    };
+    function isResource(value) {
+      return typeof value === "string" && value in exports2.RESOURCE_OPERATIONS;
+    }
+    function isOperationForResource(resource, value) {
+      return typeof value === "string" && exports2.RESOURCE_OPERATIONS[resource].some((operation) => operation === value);
+    }
+  }
+});
+
+// dist/nodes/E2B/E2b.node.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E2b = void 0;
+var n8n_workflow_1 = require("n8n-workflow");
+var actions_1 = require_actions();
+var helpers_1 = require_helpers();
+var types_1 = require_types();
+var E2b = class {
+  description = {
+    displayName: "E2B",
+    name: "e2b",
+    icon: {
+      light: "file:e2b.svg",
+      dark: "file:e2b.dark.svg"
+    },
+    group: ["transform"],
+    version: 1,
+    subtitle: '={{ $parameter["operation"] + ": " + $parameter["resource"] }}',
+    description: "Run commands and manage E2B sandboxes and snapshots",
+    defaults: {
+      name: "E2B"
+    },
+    usableAsTool: true,
+    inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+    outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+    credentials: [
+      {
+        name: "e2bApi",
+        required: true
+      }
+    ],
+    properties: [
+      {
+        displayName: "Resource",
+        name: "resource",
+        type: "options",
+        noDataExpression: true,
+        options: [
+          {
+            name: "Code",
+            value: "code"
+          },
+          {
+            name: "File",
+            value: "file"
+          },
+          {
+            name: "Git",
+            value: "git"
+          },
+          {
+            name: "Sandbox",
+            value: "sandbox"
+          },
+          {
+            name: "Snapshot",
+            value: "snapshot"
+          },
+          {
+            name: "Volume",
+            value: "volume"
+          }
+        ],
+        default: "code"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ["code"]
+          }
+        },
+        options: [
+          {
+            name: "Run Command",
+            value: "runCommand",
+            action: "Run a command in a sandbox",
+            description: "Run a shell command in an existing sandbox, or create a temporary sandbox for this execution"
+          }
+        ],
+        default: "runCommand"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ["file"]
+          }
+        },
+        options: [
+          {
+            name: "Create Folder",
+            value: "createFolder",
+            action: "Create a folder in a sandbox",
+            description: "Create a directory inside an E2B sandbox"
+          },
+          {
+            name: "Delete",
+            value: "delete",
+            action: "Delete a file or folder in a sandbox",
+            description: "Delete a file or directory inside an E2B sandbox"
+          },
+          {
+            name: "Download",
+            value: "download",
+            action: "Download a file from a sandbox",
+            description: "Read a sandbox file and return it as binary data"
+          },
+          {
+            name: "Get Info",
+            value: "info",
+            action: "Get file info in a sandbox",
+            description: "Get metadata for a file or directory inside an E2B sandbox"
+          },
+          {
+            name: "List",
+            value: "list",
+            action: "List files in a sandbox",
+            description: "List files and directories under a sandbox path"
+          },
+          {
+            name: "Move",
+            value: "move",
+            action: "Move a file or folder in a sandbox",
+            description: "Move or rename a file or directory inside an E2B sandbox"
+          },
+          {
+            name: "Read",
+            value: "read",
+            action: "Read a text file from a sandbox",
+            description: "Read a sandbox file as text"
+          },
+          {
+            name: "Upload",
+            value: "upload",
+            action: "Upload a file to a sandbox",
+            description: "Write input binary data to a sandbox file"
+          },
+          {
+            name: "Write",
+            value: "write",
+            action: "Write text to a sandbox file",
+            description: "Write text content to a file inside an E2B sandbox"
+          }
+        ],
+        default: "write"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ["git"]
+          }
+        },
+        options: [
+          {
+            name: "Add",
+            value: "add",
+            action: "Stage files in a sandbox repository",
+            description: "Stage files for the next commit"
+          },
+          {
+            name: "Checkout",
+            value: "checkout",
+            action: "Check out a git ref in a sandbox",
+            description: "Check out a branch, tag, or commit in a sandbox repository"
+          },
+          {
+            name: "Clone",
+            value: "clone",
+            action: "Clone a repository into a sandbox",
+            description: "Clone a git repository into an E2B sandbox"
+          },
+          {
+            name: "Commit",
+            value: "commit",
+            action: "Commit staged files in a sandbox repository",
+            description: "Create a git commit from staged changes"
+          },
+          {
+            name: "Pull",
+            value: "pull",
+            action: "Pull changes in a sandbox repository",
+            description: "Pull changes from the configured remote"
+          },
+          {
+            name: "Push",
+            value: "push",
+            action: "Push changes from a sandbox repository",
+            description: "Push commits to the configured remote"
+          },
+          {
+            name: "Status",
+            value: "status",
+            action: "Get git status in a sandbox repository",
+            description: "Return parsed git status for a repository"
+          }
+        ],
+        default: "status"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ["sandbox"]
+          }
+        },
+        options: [
+          {
+            name: "Create",
+            value: "create",
+            action: "Create a sandbox",
+            description: "Create a new E2B sandbox"
+          },
+          {
+            name: "Get",
+            value: "get",
+            action: "Get a sandbox",
+            description: "Retrieve a sandbox by ID"
+          },
+          {
+            name: "Get Many",
+            value: "getMany",
+            action: "Get many sandboxes",
+            description: "List running E2B sandboxes"
+          },
+          {
+            name: "Get Preview URL",
+            value: "getPreviewUrl",
+            action: "Get a sandbox preview URL",
+            description: "Get an external URL for a port exposed inside a sandbox"
+          },
+          {
+            name: "Kill",
+            value: "kill",
+            action: "Kill a sandbox",
+            description: "Kill a sandbox by ID"
+          },
+          {
+            name: "Pause",
+            value: "pause",
+            action: "Pause a sandbox",
+            description: "Pause a sandbox by ID"
+          }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ["snapshot"]
+          }
+        },
+        options: [
+          {
+            name: "Create",
+            value: "create",
+            action: "Create a snapshot",
+            description: "Create a snapshot from a sandbox"
+          },
+          {
+            name: "Delete",
+            value: "delete",
+            action: "Delete a snapshot",
+            description: "Delete a snapshot by ID"
+          },
+          {
+            name: "Get Many",
+            value: "getMany",
+            action: "Get many snapshots",
+            description: "List E2B snapshots"
+          }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ["volume"]
+          }
+        },
+        options: [
+          {
+            name: "Create",
+            value: "create",
+            action: "Create a volume",
+            description: "Create a persistent E2B volume"
+          },
+          {
+            name: "Delete",
+            value: "delete",
+            action: "Delete a volume",
+            description: "Delete a persistent E2B volume"
+          },
+          {
+            name: "Get",
+            value: "get",
+            action: "Get a volume",
+            description: "Retrieve a persistent E2B volume by ID"
+          },
+          {
+            name: "Get Many",
+            value: "getMany",
+            action: "Get many volumes",
+            description: "List persistent E2B volumes"
+          }
+        ],
+        default: "getMany"
+      },
+      {
+        displayName: "Sandbox ID",
+        name: "sandboxId",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: {
+          show: {
+            resource: ["sandbox"],
+            operation: ["get", "getPreviewUrl", "kill", "pause"]
+          }
+        }
+      },
+      {
+        displayName: "Sandbox ID",
+        name: "sandboxId",
+        type: "string",
+        required: true,
+        default: "",
+        description: "Source sandbox ID to snapshot",
+        displayOptions: {
+          show: {
+            resource: ["snapshot"],
+            operation: ["create"]
+          }
+        }
+      },
+      {
+        displayName: "Snapshot ID",
+        name: "snapshotId",
+        type: "string",
+        required: true,
+        default: "",
+        displayOptions: {
+          show: {
+            resource: ["snapshot"],
+            operation: ["delete"]
+          }
+        }
+      },
+      {
+        displayName: "Sandbox ID",
+        name: "sandboxId",
+        type: "string",
+        default: "",
+        description: "Existing sandbox ID. Leave empty to create a sandbox for this command.",
+        displayOptions: {
+          show: {
+            resource: ["code"],
+            operation: ["runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Sandbox ID",
+        name: "sandboxId",
+        type: "string",
+        default: "",
+        description: "Optional source sandbox ID to filter snapshots by",
+        displayOptions: {
+          show: {
+            resource: ["snapshot"],
+            operation: ["getMany"]
+          }
+        }
+      },
+      {
+        displayName: "Sandbox ID",
+        name: "sandboxId",
+        type: "string",
+        required: true,
+        default: "",
+        description: "ID of the sandbox to work with",
+        displayOptions: {
+          show: {
+            resource: ["file", "git"]
+          }
+        }
+      },
+      {
+        displayName: "Port",
+        name: "port",
+        type: "number",
+        required: true,
+        default: 3e3,
+        typeOptions: {
+          minValue: 1,
+          maxValue: 65535
+        },
+        description: "Port inside the sandbox to expose",
+        displayOptions: {
+          show: {
+            resource: ["sandbox"],
+            operation: ["getPreviewUrl"]
+          }
+        }
+      },
+      {
+        displayName: "Path",
+        name: "path",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: "/home/user/project",
+        description: "Path inside the sandbox",
+        displayOptions: {
+          show: {
+            resource: ["file"],
+            operation: ["createFolder", "delete", "info", "list", "read", "write"]
+          }
+        }
+      },
+      {
+        displayName: "Remote Path",
+        name: "remotePath",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: "/home/user/file.txt",
+        description: "File path inside the sandbox",
+        displayOptions: {
+          show: {
+            resource: ["file"],
+            operation: ["download", "upload"]
+          }
+        }
+      },
+      {
+        displayName: "Content",
+        name: "content",
+        type: "string",
+        required: true,
+        default: "",
+        typeOptions: {
+          rows: 8
+        },
+        description: "Text content to write to the sandbox file",
+        displayOptions: {
+          show: {
+            resource: ["file"],
+            operation: ["write"]
+          }
+        }
+      },
+      {
+        displayName: "Source",
+        name: "source",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: "/home/user/old-name.txt",
+        description: "Source path inside the sandbox",
+        displayOptions: {
+          show: {
+            resource: ["file"],
+            operation: ["move"]
+          }
+        }
+      },
+      {
+        displayName: "Destination",
+        name: "destination",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: "/home/user/new-name.txt",
+        description: "Destination path inside the sandbox",
+        displayOptions: {
+          show: {
+            resource: ["file"],
+            operation: ["move"]
+          }
+        }
+      },
+      {
+        displayName: "Depth",
+        name: "depth",
+        type: "number",
+        typeOptions: {
+          minValue: 1
+        },
+        default: 1,
+        description: "Directory depth to list",
+        displayOptions: {
+          show: {
+            resource: ["file"],
+            operation: ["list"]
+          }
+        }
+      },
+      {
+        displayName: "Binary Field",
+        name: "binaryPropertyName",
+        type: "string",
+        required: true,
+        default: "data",
+        description: "Name of the binary field to read from or write to",
+        displayOptions: {
+          show: {
+            resource: ["file"],
+            operation: ["download", "upload"]
+          }
+        }
+      },
+      {
+        displayName: "Repository URL",
+        name: "repositoryUrl",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: "https://github.com/owner/repo.git",
+        description: "Git repository URL to clone",
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["clone"]
+          }
+        }
+      },
+      {
+        displayName: "Repository Path",
+        name: "repositoryPath",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: "/home/user/repo",
+        description: "Path to the git repository inside the sandbox",
+        displayOptions: {
+          show: {
+            resource: ["git"]
+          }
+        }
+      },
+      {
+        displayName: "Files",
+        name: "files",
+        type: "string",
+        default: ".",
+        placeholder: ". or README.md,src/index.ts",
+        description: 'Comma-separated list of files to stage. Use "." to stage all changes.',
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["add"]
+          }
+        }
+      },
+      {
+        displayName: "Git Ref",
+        name: "gitRef",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: "main, feature/new-thing, or a commit SHA",
+        description: "Branch, tag, or commit SHA to check out",
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["checkout"]
+          }
+        }
+      },
+      {
+        displayName: "Message",
+        name: "message",
+        type: "string",
+        required: true,
+        default: "",
+        typeOptions: {
+          rows: 3
+        },
+        description: "Commit message",
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["commit"]
+          }
+        }
+      },
+      {
+        displayName: "Author Name",
+        name: "authorName",
+        type: "string",
+        default: "",
+        description: "Optional commit author name",
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["commit"]
+          }
+        }
+      },
+      {
+        displayName: "Author Email",
+        name: "authorEmail",
+        type: "string",
+        default: "",
+        description: "Optional commit author email",
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["commit"]
+          }
+        }
+      },
+      {
+        displayName: "Clone Options",
+        name: "cloneOptions",
+        type: "collection",
+        placeholder: "Add Option",
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["clone"]
+          }
+        },
+        options: [
+          {
+            displayName: "Branch",
+            name: "branch",
+            type: "string",
+            default: "",
+            description: "Branch to check out after cloning"
+          },
+          {
+            displayName: "Commit ID",
+            name: "commitId",
+            type: "string",
+            default: "",
+            description: "Commit SHA to check out after cloning"
+          },
+          {
+            displayName: "Depth",
+            name: "depth",
+            type: "number",
+            typeOptions: {
+              minValue: 1
+            },
+            default: 1,
+            description: "Shallow clone depth"
+          },
+          {
+            displayName: "Password or Token",
+            name: "password",
+            type: "string",
+            typeOptions: {
+              password: true
+            },
+            default: "",
+            description: "HTTPS password or personal access token"
+          },
+          {
+            displayName: "Store Credentials in Repository",
+            name: "dangerouslyStoreCredentials",
+            type: "boolean",
+            default: false,
+            description: "Whether to persist clone credentials in the repository config"
+          },
+          {
+            displayName: "Username",
+            name: "username",
+            type: "string",
+            default: "",
+            description: "HTTPS username for private repositories"
+          }
+        ]
+      },
+      {
+        displayName: "Remote Options",
+        name: "remoteOptions",
+        type: "collection",
+        placeholder: "Add Option",
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["pull", "push"]
+          }
+        },
+        options: [
+          {
+            displayName: "Branch",
+            name: "branch",
+            type: "string",
+            default: "",
+            description: "Branch name to pull or push"
+          },
+          {
+            displayName: "Password or Token",
+            name: "password",
+            type: "string",
+            typeOptions: {
+              password: true
+            },
+            default: "",
+            description: "HTTPS password or personal access token for the remote"
+          },
+          {
+            displayName: "Remote",
+            name: "remote",
+            type: "string",
+            default: "",
+            description: "Remote name, for example origin"
+          },
+          {
+            displayName: "Set Upstream",
+            name: "setUpstream",
+            type: "boolean",
+            default: false,
+            description: "Whether to set upstream tracking when pushing",
+            displayOptions: {
+              show: {
+                "/operation": ["push"]
+              }
+            }
+          },
+          {
+            displayName: "Username",
+            name: "username",
+            type: "string",
+            default: "",
+            description: "HTTPS username for the remote"
+          }
+        ]
+      },
+      {
+        displayName: "Commit Options",
+        name: "commitOptions",
+        type: "collection",
+        placeholder: "Add Option",
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ["git"],
+            operation: ["commit"]
+          }
+        },
+        options: [
+          {
+            displayName: "Allow Empty Commit",
+            name: "allowEmpty",
+            type: "boolean",
+            default: false,
+            description: "Whether to create a commit when no files are staged"
+          }
+        ]
+      },
+      {
+        displayName: "Volume Name",
+        name: "volumeName",
+        type: "string",
+        required: true,
+        default: "",
+        description: "Name for the new volume",
+        displayOptions: {
+          show: {
+            resource: ["volume"],
+            operation: ["create"]
+          }
+        }
+      },
+      {
+        displayName: "Volume ID",
+        name: "volumeId",
+        type: "string",
+        required: true,
+        default: "",
+        description: "ID of the volume",
+        displayOptions: {
+          show: {
+            resource: ["volume"],
+            operation: ["get", "delete"]
+          }
+        }
+      },
+      {
+        displayName: "Command",
+        name: "command",
+        type: "string",
+        required: true,
+        default: "",
+        placeholder: 'python -c "print(1 + 1)"',
+        typeOptions: {
+          rows: 4
+        },
+        displayOptions: {
+          show: {
+            resource: ["code"],
+            operation: ["runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Working Directory",
+        name: "cwd",
+        type: "string",
+        default: "",
+        displayOptions: {
+          show: {
+            resource: ["code"],
+            operation: ["runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Template or Snapshot ID",
+        name: "template",
+        type: "string",
+        default: "",
+        description: "E2B template name/ID or snapshot ID. Leave empty to use the default E2B sandbox template.",
+        displayOptions: {
+          show: {
+            resource: ["sandbox", "code"],
+            operation: ["create", "runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Snapshot Name",
+        name: "snapshotName",
+        type: "string",
+        default: "",
+        description: "Optional name for the snapshot template",
+        displayOptions: {
+          show: {
+            resource: ["snapshot"],
+            operation: ["create"]
+          }
+        }
+      },
+      {
+        displayName: "Metadata",
+        name: "metadataJson",
+        type: "json",
+        default: "{}",
+        description: "Metadata to attach when creating a sandbox",
+        displayOptions: {
+          show: {
+            resource: ["sandbox", "code"],
+            operation: ["create", "runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Environment Variables",
+        name: "envJson",
+        type: "json",
+        default: "{}",
+        description: "Environment variables to set for the sandbox or command",
+        displayOptions: {
+          show: {
+            resource: ["sandbox", "code"],
+            operation: ["create", "runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Allow Internet Access",
+        name: "allowInternetAccess",
+        type: "boolean",
+        default: true,
+        displayOptions: {
+          show: {
+            resource: ["sandbox", "code"],
+            operation: ["create", "runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Volume Mounts",
+        name: "volumeMountsJson",
+        type: "json",
+        default: "{}",
+        description: 'JSON object mapping sandbox mount paths to E2B volume names, for example {"\\/data":"my-volume"}',
+        displayOptions: {
+          show: {
+            resource: ["sandbox", "code"],
+            operation: ["create", "runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Kill Sandbox After Run",
+        name: "killAfterRun",
+        type: "boolean",
+        default: false,
+        description: "Whether to kill the sandbox after running the command",
+        displayOptions: {
+          show: {
+            resource: ["code"],
+            operation: ["runCommand"]
+          }
+        }
+      },
+      {
+        displayName: "Limit",
+        name: "limit",
+        type: "number",
+        typeOptions: {
+          minValue: 1
+        },
+        default: 50,
+        description: "Max number of results to return",
+        displayOptions: {
+          show: {
+            resource: ["sandbox", "snapshot", "volume"],
+            operation: ["getMany"]
+          }
+        }
+      },
+      {
+        displayName: "Timeout",
+        name: "timeoutSeconds",
+        type: "number",
+        typeOptions: {
+          minValue: 1
+        },
+        default: 300,
+        description: "Timeout in seconds for the E2B operation"
+      }
+    ]
+  };
+  async execute() {
+    const items = this.getInputData();
+    const credentials = await this.getCredentials("e2bApi");
+    const returnData = [];
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+      try {
+        const rawResource = this.getNodeParameter("resource", itemIndex);
+        if (!(0, types_1.isResource)(rawResource)) {
+          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The resource "${rawResource}" is not known`, {
+            itemIndex
+          });
+        }
+        const rawOperation = this.getNodeParameter("operation", itemIndex);
+        if (!(0, types_1.isOperationForResource)(rawResource, rawOperation)) {
+          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${rawOperation}" is not known for resource "${rawResource}"`, { itemIndex });
+        }
+        const handler = (0, actions_1.getOperationHandler)(rawResource, rawOperation);
+        const itemData = await handler({
+          executeFunctions: this,
+          credentials,
+          itemIndex,
+          timeoutMs: (0, helpers_1.getTimeoutMs)(this, itemIndex)
+        });
+        returnData.push(...itemData);
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({
+            json: {
+              error: (0, helpers_1.getErrorMessage)(error)
+            },
+            pairedItem: { item: itemIndex }
+          });
+          continue;
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), (0, helpers_1.getErrorMessage)(error), { itemIndex });
+      }
+    }
+    return [returnData];
+  }
+};
+exports.E2b = E2b;
+//# sourceMappingURL=E2b.node.bundle.js.map