@inkeep/agents-run-api 0.14.16 → 0.16.0

package/dist/LocalSandboxExecutor-JI4X2Z3N.js

@@ -0,0 +1,319 @@
+import { __publicField } from './chunk-PKBMQBKP.js';
+import { getLogger } from '@inkeep/agents-core';
+import { spawn } from 'child_process';
+import { createHash } from 'crypto';
+import { mkdirSync, existsSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+var logger = getLogger("local-sandbox-executor");
+var _LocalSandboxExecutor = class _LocalSandboxExecutor {
+  constructor() {
+    __publicField(this, "tempDir");
+    __publicField(this, "sandboxPool", {});
+    __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
+    // 5 minutes
+    __publicField(this, "MAX_USE_COUNT", 50);
+    this.tempDir = join(tmpdir(), "inkeep-sandboxes");
+    this.ensureTempDir();
+    this.startPoolCleanup();
+  }
+  static getInstance() {
+    if (!_LocalSandboxExecutor.instance) {
+      _LocalSandboxExecutor.instance = new _LocalSandboxExecutor();
+    }
+    return _LocalSandboxExecutor.instance;
+  }
+  ensureTempDir() {
+    try {
+      mkdirSync(this.tempDir, { recursive: true });
+    } catch {
+    }
+  }
+  generateDependencyHash(dependencies) {
+    const sortedDeps = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
+    return createHash("sha256").update(sortedDeps).digest("hex").substring(0, 16);
+  }
+  getCachedSandbox(dependencyHash) {
+    const poolKey = dependencyHash;
+    const sandbox = this.sandboxPool[poolKey];
+    if (sandbox && existsSync(sandbox.sandboxDir)) {
+      const now = Date.now();
+      if (now - sandbox.lastUsed < this.POOL_TTL && sandbox.useCount < this.MAX_USE_COUNT) {
+        sandbox.lastUsed = now;
+        sandbox.useCount++;
+        logger.debug(
+          {
+            poolKey,
+            useCount: sandbox.useCount,
+            sandboxDir: sandbox.sandboxDir,
+            lastUsed: new Date(sandbox.lastUsed).toISOString()
+          },
+          "Reusing cached sandbox"
+        );
+        return sandbox.sandboxDir;
+      } else {
+        this.cleanupSandbox(sandbox.sandboxDir);
+        delete this.sandboxPool[poolKey];
+      }
+    }
+    return null;
+  }
+  addToPool(dependencyHash, sandboxDir, dependencies) {
+    const poolKey = dependencyHash;
+    if (this.sandboxPool[poolKey]) {
+      this.cleanupSandbox(this.sandboxPool[poolKey].sandboxDir);
+    }
+    this.sandboxPool[poolKey] = {
+      sandboxDir,
+      lastUsed: Date.now(),
+      useCount: 1,
+      dependencies
+    };
+    logger.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
+  }
+  cleanupSandbox(sandboxDir) {
+    try {
+      rmSync(sandboxDir, { recursive: true, force: true });
+      logger.debug({ sandboxDir }, "Cleaned up sandbox");
+    } catch (error) {
+      logger.warn({ sandboxDir, error }, "Failed to clean up sandbox");
+    }
+  }
+  startPoolCleanup() {
+    setInterval(() => {
+      const now = Date.now();
+      const keysToDelete = [];
+      for (const [key, sandbox] of Object.entries(this.sandboxPool)) {
+        if (now - sandbox.lastUsed > this.POOL_TTL || sandbox.useCount >= this.MAX_USE_COUNT) {
+          this.cleanupSandbox(sandbox.sandboxDir);
+          keysToDelete.push(key);
+        }
+      }
+      keysToDelete.forEach((key) => {
+        delete this.sandboxPool[key];
+      });
+      if (keysToDelete.length > 0) {
+        logger.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
+      }
+    }, 6e4);
+  }
+  detectModuleType(executeCode) {
+    const esmPatterns = [
+      /import\s+.*\s+from\s+['"]/g,
+      // import ... from '...'
+      /import\s*\(/g,
+      // import(...)
+      /export\s+(default|const|let|var|function|class)/g,
+      // export statements
+      /export\s*\{/g
+      // export { ... }
+    ];
+    const cjsPatterns = [
+      /require\s*\(/g,
+      // require(...)
+      /module\.exports/g,
+      // module.exports
+      /exports\./g
+      // exports.something
+    ];
+    const hasEsmSyntax = esmPatterns.some((pattern) => pattern.test(executeCode));
+    const hasCjsSyntax = cjsPatterns.some((pattern) => pattern.test(executeCode));
+    if (hasEsmSyntax && hasCjsSyntax) {
+      logger.warn(
+        { executeCode: `${executeCode.substring(0, 100)}...` },
+        "Both ESM and CommonJS syntax detected, defaulting to ESM"
+      );
+      return "esm";
+    }
+    if (hasEsmSyntax) {
+      return "esm";
+    }
+    if (hasCjsSyntax) {
+      return "cjs";
+    }
+    return "cjs";
+  }
+  async executeFunctionTool(toolId, args, config) {
+    const dependencies = config.dependencies || {};
+    const dependencyHash = this.generateDependencyHash(dependencies);
+    logger.debug(
+      {
+        toolId,
+        dependencies,
+        dependencyHash,
+        poolSize: Object.keys(this.sandboxPool).length
+      },
+      "Executing function tool"
+    );
+    let sandboxDir = this.getCachedSandbox(dependencyHash);
+    let isNewSandbox = false;
+    if (!sandboxDir) {
+      sandboxDir = join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
+      mkdirSync(sandboxDir, { recursive: true });
+      isNewSandbox = true;
+      logger.debug(
+        {
+          toolId,
+          dependencyHash,
+          sandboxDir,
+          dependencies
+        },
+        "Creating new sandbox"
+      );
+      const moduleType = this.detectModuleType(config.executeCode);
+      const packageJson = {
+        name: `function-tool-${toolId}`,
+        version: "1.0.0",
+        ...moduleType === "esm" && { type: "module" },
+        dependencies,
+        scripts: {
+          start: moduleType === "esm" ? "node index.mjs" : "node index.js"
+        }
+      };
+      writeFileSync(join(sandboxDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
+      if (Object.keys(dependencies).length > 0) {
+        await this.installDependencies(sandboxDir);
+      }
+      this.addToPool(dependencyHash, sandboxDir, dependencies);
+    }
+    try {
+      const moduleType = this.detectModuleType(config.executeCode);
+      const executionCode = this.wrapFunctionCode(config.executeCode, args);
+      const fileExtension = moduleType === "esm" ? "mjs" : "js";
+      writeFileSync(join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
+      const result = await this.executeInSandbox(
+        sandboxDir,
+        config.sandboxConfig?.timeout || 3e4,
+        moduleType
+      );
+      return result;
+    } catch (error) {
+      if (isNewSandbox) {
+        this.cleanupSandbox(sandboxDir);
+        const poolKey = dependencyHash;
+        delete this.sandboxPool[poolKey];
+      }
+      throw error;
+    }
+  }
+  async installDependencies(sandboxDir) {
+    return new Promise((resolve, reject) => {
+      const npm = spawn("npm", ["install"], {
+        cwd: sandboxDir,
+        stdio: "pipe"
+      });
+      let stderr = "";
+      npm.stdout?.on("data", () => {
+      });
+      npm.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      npm.on("close", (code) => {
+        if (code === 0) {
+          logger.debug({ sandboxDir }, "Dependencies installed successfully");
+          resolve();
+        } else {
+          logger.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
+          reject(new Error(`npm install failed with code ${code}: ${stderr}`));
+        }
+      });
+      npm.on("error", (err) => {
+        logger.error({ sandboxDir, error: err }, "Failed to spawn npm install");
+        reject(err);
+      });
+    });
+  }
+  async executeInSandbox(sandboxDir, timeout, moduleType) {
+    return new Promise((resolve, reject) => {
+      const fileExtension = moduleType === "esm" ? "mjs" : "js";
+      const spawnOptions = {
+        cwd: sandboxDir,
+        stdio: "pipe",
+        // Security: drop privileges and limit resources
+        uid: process.getuid ? process.getuid() : void 0,
+        gid: process.getgid ? process.getgid() : void 0
+      };
+      const node = spawn("node", [`index.${fileExtension}`], spawnOptions);
+      let stdout = "";
+      let stderr = "";
+      let outputSize = 0;
+      const MAX_OUTPUT_SIZE = 1024 * 1024;
+      node.stdout?.on("data", (data) => {
+        const dataStr = data.toString();
+        outputSize += dataStr.length;
+        if (outputSize > MAX_OUTPUT_SIZE) {
+          node.kill("SIGTERM");
+          reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+          return;
+        }
+        stdout += dataStr;
+      });
+      node.stderr?.on("data", (data) => {
+        const dataStr = data.toString();
+        outputSize += dataStr.length;
+        if (outputSize > MAX_OUTPUT_SIZE) {
+          node.kill("SIGTERM");
+          reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+          return;
+        }
+        stderr += dataStr;
+      });
+      const timeoutId = setTimeout(() => {
+        logger.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
+        node.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            node.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+        reject(new Error(`Function execution timed out after ${timeout}ms`));
+      }, timeout);
+      node.on("close", (code, signal) => {
+        clearTimeout(timeoutId);
+        if (code === 0) {
+          try {
+            const result = JSON.parse(stdout);
+            if (result.success) {
+              resolve(result.result);
+            } else {
+              reject(new Error(result.error || "Function execution failed"));
+            }
+          } catch (parseError) {
+            logger.error({ stdout, stderr, parseError }, "Failed to parse function result");
+            reject(new Error(`Invalid function result: ${stdout}`));
+          }
+        } else {
+          const errorMsg = signal ? `Function execution killed by signal ${signal}: ${stderr}` : `Function execution failed with code ${code}: ${stderr}`;
+          logger.error({ code, signal, stderr }, "Function execution failed");
+          reject(new Error(errorMsg));
+        }
+      });
+      node.on("error", (error) => {
+        clearTimeout(timeoutId);
+        logger.error({ sandboxDir, error }, "Failed to spawn node process");
+        reject(error);
+      });
+    });
+  }
+  wrapFunctionCode(executeCode, args) {
+    return `
+// Wrapped function execution (ESM)
+const execute = ${executeCode};
+const args = ${JSON.stringify(args)};
+
+execute(args)
+  .then(result => {
+    console.log(JSON.stringify({ success: true, result }));
+  })
+  .catch(error => {
+    console.log(JSON.stringify({ success: false, error: error.message }));
+  });
+`;
+  }
+};
+__publicField(_LocalSandboxExecutor, "instance", null);
+var LocalSandboxExecutor = _LocalSandboxExecutor;
+
+export { LocalSandboxExecutor };