@poncho-ai/harness 0.36.0 → 0.36.2

package/dist/isolate-KUZ5NOPG.js

@@ -1,727 +0,0 @@
-// src/isolate/run-code-tool.ts
-import { defineTool } from "@poncho-ai/sdk";
-
-// src/isolate/runtime.ts
-var ivmModule;
-async function loadIvm() {
-  if (ivmModule) return ivmModule;
-  try {
-    const mod = await import("isolated-vm");
-    ivmModule = mod.default ?? mod;
-    return ivmModule;
-  } catch {
-    throw new Error(
-      "Code execution requires isolated-vm. Run: pnpm add isolated-vm"
-    );
-  }
-}
-function buildRuntimePreamble() {
-  return `
-// --- console capture ---
-const __stdout = [];
-const __stderr = [];
-let __outputBytes = 0;
-const __outputLimit = typeof __OUTPUT_LIMIT === "number" ? __OUTPUT_LIMIT : 65536;
-
-function __serialize(v) {
-  if (typeof v === "string") return v;
-  try {
-    const seen = new WeakSet();
-    return JSON.stringify(v, function(_k, val) {
-      if (typeof val === "object" && val !== null) {
-        if (seen.has(val)) return "[Circular]";
-        seen.add(val);
-      }
-      return val;
-    }, 2);
-  } catch { return String(v); }
-}
-
-function __capture(arr, args) {
-  const line = Array.from(args).map(__serialize).join(" ");
-  const bytes = line.length;
-  if (__outputBytes + bytes > __outputLimit) {
-    arr.push("[output truncated at " + __outputLimit + " bytes]");
-    __outputBytes = __outputLimit;
-    return;
-  }
-  __outputBytes += bytes;
-  arr.push(line);
-}
-
-const console = {
-  log:   function() { __capture(__stdout, arguments); },
-  info:  function() { __capture(__stdout, arguments); },
-  warn:  function() { __capture(__stderr, arguments); },
-  error: function() { __capture(__stderr, arguments); },
-  debug: function() { __capture(__stdout, arguments); },
-};
-`;
-}
-function createIsolateRuntime(config) {
-  return {
-    async execute(code, bindings, preamble, signal) {
-      const ivm = await loadIvm();
-      const isolate = new ivm.Isolate({
-        memoryLimit: config.memoryLimit
-      });
-      let abortHandler;
-      let aborted = false;
-      if (signal) {
-        if (signal.aborted) {
-          isolate.dispose();
-          return {
-            stdout: "",
-            stderr: "",
-            error: { message: "Execution cancelled", name: "AbortError" },
-            executionTimeMs: 0
-          };
-        }
-        abortHandler = () => {
-          aborted = true;
-          isolate.dispose();
-        };
-        signal.addEventListener("abort", abortHandler, { once: true });
-      }
-      const t0 = performance.now();
-      try {
-        const context = await isolate.createContext();
-        const jail = context.global;
-        jail.setSync("__OUTPUT_LIMIT", config.outputLimit);
-        const bindingNames = Object.keys(bindings);
-        const wrapperDecls = [];
-        for (const name of bindingNames) {
-          const binding = bindings[name];
-          const ref = new ivm.Reference(async (inputJson) => {
-            const input = JSON.parse(inputJson);
-            const result2 = await binding.handler(input);
-            return JSON.stringify(result2 ?? null);
-          });
-          jail.setSync(`__binding_${name}`, ref);
-          wrapperDecls.push(
-            `async function ${name}(input) {
-  const raw = await __binding_${name}.apply(undefined, [JSON.stringify(input)], { result: { promise: true, copy: true } });
-  return JSON.parse(raw);
-}`
-          );
-        }
-        const runtimePreamble = buildRuntimePreamble() + "\n" + wrapperDecls.join("\n");
-        await context.eval(runtimePreamble, { filename: "<runtime>" });
-        if (preamble) {
-          await context.eval(preamble, { filename: "<libraries>" });
-        }
-        const wrapped = `(async () => {
-${code}
-})()`;
-        const rawResult = await context.eval(wrapped, {
-          filename: "<user-code>",
-          promise: true,
-          copy: true,
-          timeout: config.timeout
-        });
-        const stdout = await context.eval("__stdout.join('\\n')", { copy: true });
-        const stderr = await context.eval("__stderr.join('\\n')", { copy: true });
-        let result;
-        try {
-          result = rawResult === void 0 || rawResult === null ? rawResult : JSON.parse(JSON.stringify(rawResult));
-        } catch {
-          result = void 0;
-        }
-        return {
-          result,
-          stdout,
-          stderr,
-          executionTimeMs: performance.now() - t0
-        };
-      } catch (err) {
-        const elapsed = performance.now() - t0;
-        if (aborted) {
-          return {
-            stdout: "",
-            stderr: "",
-            error: { message: "Execution cancelled", name: "AbortError" },
-            executionTimeMs: elapsed
-          };
-        }
-        const error = err instanceof Error ? err : new Error(String(err));
-        const parsed = parseV8Error(error);
-        return {
-          stdout: "",
-          stderr: "",
-          error: parsed,
-          executionTimeMs: elapsed
-        };
-      } finally {
-        if (abortHandler && signal) {
-          signal.removeEventListener("abort", abortHandler);
-        }
-        try {
-          isolate.dispose();
-        } catch {
-        }
-      }
-    }
-  };
-}
-function parseV8Error(error) {
-  const result = {
-    message: error.message,
-    name: error.name
-  };
-  const match = error.stack?.match(/<user-code>:(\d+):(\d+)/);
-  if (match) {
-    const rawLine = parseInt(match[1], 10);
-    result.line = Math.max(1, rawLine - 1);
-    result.column = parseInt(match[2], 10);
-  }
-  return result;
-}
-
-// src/isolate/bindings.ts
-function createVfsBindings(adapter) {
-  return {
-    fs_read: {
-      description: "Read a text file from the VFS",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Absolute path in the VFS" } },
-        required: ["path"]
-      },
-      handler: async (input) => {
-        const content = await adapter.readFile(input.path);
-        return content;
-      }
-    },
-    fs_write: {
-      description: "Write a text file to the VFS",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Absolute path in the VFS" },
-          content: { type: "string", description: "Text content to write" }
-        },
-        required: ["path", "content"]
-      },
-      handler: async (input) => {
-        await adapter.writeFile(input.path, input.content);
-      }
-    },
-    fs_read_binary: {
-      description: "Read a binary file from the VFS (returns base64)",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Absolute path in the VFS" } },
-        required: ["path"]
-      },
-      handler: async (input) => {
-        const buf = await adapter.readFileBuffer(input.path);
-        return Buffer.from(buf).toString("base64");
-      }
-    },
-    fs_write_binary: {
-      description: "Write a binary file to the VFS (content is base64-encoded)",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Absolute path in the VFS" },
-          content: { type: "string", description: "Base64-encoded binary content" }
-        },
-        required: ["path", "content"]
-      },
-      handler: async (input) => {
-        const buf = Buffer.from(input.content, "base64");
-        await adapter.writeFile(input.path, buf);
-      }
-    },
-    fs_list: {
-      description: "List files and directories at a path",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Directory path in the VFS" } },
-        required: ["path"]
-      },
-      handler: async (input) => {
-        return await adapter.readdir(input.path);
-      }
-    },
-    fs_exists: {
-      description: "Check if a file or directory exists",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Absolute path in the VFS" } },
-        required: ["path"]
-      },
-      handler: async (input) => {
-        return await adapter.exists(input.path);
-      }
-    },
-    fs_delete: {
-      description: "Delete a file or directory",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Absolute path in the VFS" } },
-        required: ["path"]
-      },
-      handler: async (input) => {
-        await adapter.rm(input.path, { force: true });
-      }
-    },
-    fs_mkdir: {
-      description: "Create a directory (recursive)",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Directory path to create" } },
-        required: ["path"]
-      },
-      handler: async (input) => {
-        await adapter.mkdir(input.path, { recursive: true });
-      }
-    },
-    fs_stat: {
-      description: "Get file/directory metadata (size, type, mtime)",
-      inputSchema: {
-        type: "object",
-        properties: { path: { type: "string", description: "Absolute path in the VFS" } },
-        required: ["path"]
-      },
-      handler: async (input) => {
-        const stat = await adapter.stat(input.path);
-        return {
-          isFile: stat.isFile,
-          isDirectory: stat.isDirectory,
-          size: stat.size,
-          mtime: stat.mtime.toISOString()
-        };
-      }
-    }
-  };
-}
-function createFetchBinding(allowedDomains) {
-  const domainSet = new Set(allowedDomains.map((d) => d.toLowerCase()));
-  return {
-    description: `HTTP fetch restricted to: ${allowedDomains.join(", ")}`,
-    inputSchema: {
-      type: "object",
-      properties: {
-        url: { type: "string", description: "URL to fetch" },
-        method: { type: "string", description: "HTTP method (default: GET)" },
-        headers: {
-          type: "object",
-          description: "Request headers",
-          additionalProperties: { type: "string" }
-        },
-        body: { type: "string", description: "Request body" }
-      },
-      required: ["url"]
-    },
-    handler: async (input) => {
-      const url = new URL(input.url);
-      if (!domainSet.has(url.hostname.toLowerCase())) {
-        throw new Error(
-          `Fetch blocked: domain "${url.hostname}" is not in the allowed list [${allowedDomains.join(", ")}]`
-        );
-      }
-      const resp = await fetch(input.url, {
-        method: input.method ?? "GET",
-        headers: input.headers ?? void 0,
-        body: input.body ?? void 0
-      });
-      const body = await resp.text();
-      const headers = {};
-      resp.headers.forEach((v, k) => {
-        headers[k] = v;
-      });
-      return { status: resp.status, headers, body };
-    }
-  };
-}
-function mergeBuilderBindings(configBindings) {
-  return { ...configBindings };
-}
-
-// src/isolate/run-code-tool.ts
-var esbuildTransform;
-async function loadEsbuild() {
-  if (esbuildTransform) return esbuildTransform;
-  try {
-    const mod = await import("esbuild");
-    esbuildTransform = mod.transform;
-    return esbuildTransform;
-  } catch {
-    throw new Error(
-      "Code execution requires esbuild for TypeScript stripping. Run: pnpm add esbuild"
-    );
-  }
-}
-async function stripTypeScript(code) {
-  const transform = await loadEsbuild();
-  const result = await transform(code, { loader: "ts" });
-  return result.code;
-}
-var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".ts", ".mjs", ".mts"]);
-function hasAllowedExtension(path) {
-  const dot = path.lastIndexOf(".");
-  if (dot === -1) return false;
-  return ALLOWED_EXTENSIONS.has(path.slice(dot).toLowerCase());
-}
-function createRunCodeTool(opts) {
-  const { config, bashManager, libraryPreamble, description } = opts;
-  const memoryLimit = config.memoryLimit ?? 128;
-  const timeout = config.timeLimit ?? 1e4;
-  const outputLimit = config.outputLimit ?? 65536;
-  const codeLimit = config.codeLimit ?? 102400;
-  const runtime = createIsolateRuntime({
-    memoryLimit,
-    timeout,
-    outputLimit
-  });
-  const staticBindings = {};
-  if (config.apis?.fetch) {
-    staticBindings.fetch = createFetchBinding(config.apis.fetch.allowedDomains);
-  }
-  if (config.bindings) {
-    Object.assign(staticBindings, mergeBuilderBindings(config.bindings));
-  }
-  return defineTool({
-    name: "run_code",
-    description,
-    inputSchema: {
-      type: "object",
-      properties: {
-        code: {
-          type: "string",
-          description: "JavaScript or TypeScript code to execute"
-        },
-        file: {
-          type: "string",
-          description: "Path to a .js/.ts file in the VFS to execute instead of inline code"
-        }
-      },
-      additionalProperties: false
-    },
-    handler: async (input, context) => {
-      const code = input.code;
-      const file = input.file;
-      if (code && file) {
-        return { error: "Provide either `code` or `file`, not both." };
-      }
-      if (!code && !file) {
-        return { error: "Provide either `code` (inline) or `file` (VFS path)." };
-      }
-      let source;
-      if (file) {
-        if (!hasAllowedExtension(file)) {
-          return {
-            error: `File must have a .js, .ts, .mjs, or .mts extension. Got: "${file}"`
-          };
-        }
-        const tenantId2 = context.tenantId ?? "__default__";
-        const adapter2 = bashManager.getAdapter(tenantId2);
-        try {
-          source = await adapter2.readFile(file);
-        } catch (err) {
-          return {
-            error: `Failed to read file "${file}": ${err instanceof Error ? err.message : String(err)}`
-          };
-        }
-      } else {
-        source = code;
-      }
-      if (source.length > codeLimit) {
-        return {
-          error: `Code exceeds size limit: ${source.length} bytes > ${codeLimit} byte max.`
-        };
-      }
-      let jsCode;
-      try {
-        jsCode = await stripTypeScript(source);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return { error: `TypeScript parse error: ${msg}` };
-      }
-      const tenantId = context.tenantId ?? "__default__";
-      const adapter = bashManager.getAdapter(tenantId);
-      const vfsBindings = createVfsBindings(adapter);
-      const allBindings = {
-        ...vfsBindings,
-        ...staticBindings
-      };
-      const result = await runtime.execute(
-        jsCode,
-        allBindings,
-        libraryPreamble,
-        context.abortSignal
-      );
-      if (result.error) {
-        return {
-          error: result.error.message,
-          errorName: result.error.name,
-          line: result.error.line,
-          column: result.error.column,
-          stdout: result.stdout || void 0,
-          stderr: result.stderr || void 0,
-          executionTimeMs: result.executionTimeMs
-        };
-      }
-      return {
-        result: result.result,
-        stdout: result.stdout || void 0,
-        stderr: result.stderr || void 0,
-        executionTimeMs: result.executionTimeMs
-      };
-    }
-  });
-}
-
-// src/isolate/type-stubs.ts
-function generateIsolateTypeStubs(config) {
-  const lines = [];
-  lines.push(
-    "// Filesystem (persistent virtual filesystem, all async)",
-    "declare function fs_read(input: { path: string }): Promise<string>;",
-    "declare function fs_write(input: { path: string; content: string }): Promise<void>;",
-    "declare function fs_read_binary(input: { path: string }): Promise<string>; // returns base64",
-    "declare function fs_write_binary(input: { path: string; content: string }): Promise<void>; // content is base64",
-    "declare function fs_list(input: { path: string }): Promise<string[]>;",
-    "declare function fs_exists(input: { path: string }): Promise<boolean>;",
-    "declare function fs_delete(input: { path: string }): Promise<void>;",
-    "declare function fs_mkdir(input: { path: string }): Promise<void>;",
-    "declare function fs_stat(input: { path: string }): Promise<{ isFile: boolean; isDirectory: boolean; size: number; mtime: string }>;"
-  );
-  if (config.apis?.fetch) {
-    const domains = config.apis.fetch.allowedDomains.join(", ");
-    lines.push(
-      "",
-      `// HTTP fetch (restricted to: ${domains})`,
-      "declare function fetch(input: { url: string; method?: string; headers?: Record<string, string>; body?: string }): Promise<{ status: number; headers: Record<string, string>; body: string }>;"
-    );
-  }
-  if (config.bindings) {
-    const entries = Object.entries(config.bindings);
-    if (entries.length > 0) {
-      lines.push("", "// Custom bindings");
-      for (const [name, binding] of entries) {
-        lines.push(formatBindingStub(name, binding));
-      }
-    }
-  }
-  lines.push(
-    "",
-    "// Console (output captured and returned in tool result)",
-    "declare const console: { log(...args: unknown[]): void; error(...args: unknown[]): void; warn(...args: unknown[]): void; info(...args: unknown[]): void; debug(...args: unknown[]): void; };"
-  );
-  if (config.libraries?.length) {
-    lines.push(
-      "",
-      `// Pre-bundled libraries (use require())`,
-      `declare function require(name: ${config.libraries.map((l) => `"${l}"`).join(" | ")}): any;`
-    );
-  }
-  return lines.join("\n");
-}
-function buildRunCodeDescription(config) {
-  const parts = [
-    "Execute JavaScript/TypeScript code in a sandboxed V8 isolate.",
-    "",
-    "Input: provide either `code` (inline string) or `file` (path to a .js/.ts file in the VFS).",
-    "",
-    "Available APIs inside the isolate (all async, all take a single object argument):",
-    "- fs_read({path}) / fs_write({path, content}) / fs_read_binary({path}) / fs_write_binary({path, content})",
-    "- fs_list({path}) / fs_exists({path}) / fs_delete({path}) / fs_mkdir({path}) / fs_stat({path})",
-    "- console.log() / console.error() -- output captured and returned (not async)"
-  ];
-  if (config.apis?.fetch) {
-    parts.push(
-      `- fetch({url, method?, headers?, body?}) -- restricted to: ${config.apis.fetch.allowedDomains.join(", ")}`
-    );
-  }
-  if (config.bindings) {
-    for (const [name, binding] of Object.entries(config.bindings)) {
-      parts.push(`- ${name}({...}) -- ${binding.description}`);
-    }
-  }
-  if (config.libraries?.length) {
-    parts.push(
-      "",
-      `Pre-bundled libraries (use require()):`,
-      `- ${config.libraries.join(", ")}`
-    );
-  }
-  const memoryLimit = config.memoryLimit ?? 128;
-  const timeLimit = config.timeLimit ?? 1e4;
-  const codeLimit = config.codeLimit ?? 102400;
-  parts.push(
-    "",
-    "Notes:",
-    "- Code is wrapped in an async IIFE. Use `return` to return a value.",
-    "- Files written during execution persist even if the code throws an error.",
-    "- TypeScript is supported (type annotations are stripped before execution).",
-    `- Execution timeout: ${timeLimit / 1e3}s. Memory limit: ${memoryLimit}MB. Max code size: ${Math.round(codeLimit / 1024)}KB.`
-  );
-  return parts.join("\n");
-}
-function formatBindingStub(name, binding) {
-  const schema = binding.inputSchema;
-  const props = schema.properties ?? {};
-  const required = new Set(schema.required ?? []);
-  const params = Object.entries(props).map(([k, v]) => {
-    const opt = required.has(k) ? "" : "?";
-    const tsType = jsonSchemaToTsType(v);
-    return `${k}${opt}: ${tsType}`;
-  }).join("; ");
-  return `declare function ${name}(input: { ${params} }): Promise<unknown>; // ${binding.description}`;
-}
-function jsonSchemaToTsType(schema) {
-  switch (schema.type) {
-    case "string":
-      return "string";
-    case "number":
-    case "integer":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "array":
-      return "unknown[]";
-    case "object":
-      return "Record<string, unknown>";
-    default:
-      return "unknown";
-  }
-}
-
-// src/isolate/bundler.ts
-import { resolve } from "path";
-import { existsSync, readFileSync } from "fs";
-var esbuildBuild;
-async function loadEsbuild2() {
-  if (esbuildBuild) return esbuildBuild;
-  try {
-    const mod = await import("esbuild");
-    esbuildBuild = mod.build;
-    return esbuildBuild;
-  } catch {
-    throw new Error(
-      "Library bundling requires esbuild. Run: pnpm add esbuild"
-    );
-  }
-}
-var BLOCKED_BUILTINS = /* @__PURE__ */ new Set([
-  "fs",
-  "fs/promises",
-  "net",
-  "tls",
-  "child_process",
-  "cluster",
-  "dgram",
-  "dns",
-  "http",
-  "http2",
-  "https",
-  "inspector",
-  "module",
-  "os",
-  "perf_hooks",
-  "readline",
-  "repl",
-  "stream",
-  "tty",
-  "v8",
-  "vm",
-  "worker_threads",
-  "wasi"
-]);
-function blockedBuiltinsPlugin() {
-  return {
-    name: "blocked-builtins",
-    setup(build) {
-      const filter = new RegExp(
-        `^(node:)?(${[...BLOCKED_BUILTINS].join("|")})$`
-      );
-      build.onResolve({ filter }, (args) => ({
-        path: args.path,
-        namespace: "blocked-builtin"
-      }));
-      build.onLoad(
-        { filter: /.*/, namespace: "blocked-builtin" },
-        (args) => {
-          const name = args.path.replace(/^node:/, "");
-          return {
-            contents: `throw new Error("Module '${name}' is not available in the isolate. Use the injected fs_* functions instead.");`,
-            loader: "js"
-          };
-        }
-      );
-    }
-  };
-}
-async function bundleLibraries(libraries, projectDir) {
-  if (libraries.length === 0) return null;
-  const build = await loadEsbuild2();
-  const chunks = [];
-  const moduleEntries = [];
-  for (const lib of libraries) {
-    const pkgPath = resolve(projectDir, "node_modules", lib, "package.json");
-    if (!existsSync(pkgPath)) {
-      throw new Error(
-        `Library '${lib}' is declared in isolate.libraries but not installed. Run: pnpm add ${lib}`
-      );
-    }
-    let version = "unknown";
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-      version = pkg.version ?? "unknown";
-    } catch {
-    }
-    const safeName = lib.replace(/[^a-zA-Z0-9_]/g, "_");
-    const globalName = `__lib_${safeName}`;
-    const result = await build({
-      entryPoints: [lib],
-      bundle: true,
-      write: false,
-      format: "iife",
-      globalName,
-      platform: "neutral",
-      target: "es2022",
-      // Resolve from the project's node_modules
-      nodePaths: [resolve(projectDir, "node_modules")],
-      plugins: [blockedBuiltinsPlugin()],
-      logLevel: "silent",
-      minify: false
-    });
-    if (result.outputFiles?.[0]) {
-      chunks.push(
-        `// --- ${lib}@${version} ---
-${result.outputFiles[0].text}`
-      );
-      moduleEntries.push(`  ${JSON.stringify(lib)}: ${globalName}`);
-    } else {
-      throw new Error(
-        `Failed to bundle library '${lib}': esbuild produced no output.`
-      );
-    }
-  }
-  const requireShim = `
-// --- require() shim ---
-var __modules = {
-${moduleEntries.join(",\n")}
-};
-function require(name) {
-  var mod = __modules[name];
-  if (!mod) throw new Error('Module "' + name + '" is not available. Available: ${libraries.join(", ")}');
-  // Handle both default and namespace exports
-  if (mod && mod.default !== undefined && Object.keys(mod).length === 1) return mod.default;
-  return mod;
-}
-`;
-  return chunks.join("\n\n") + "\n\n" + requireShim;
-}
-export {
-  buildRunCodeDescription,
-  bundleLibraries,
-  createFetchBinding,
-  createIsolateRuntime,
-  createRunCodeTool,
-  createVfsBindings,
-  generateIsolateTypeStubs,
-  mergeBuilderBindings
-};