@teampitch/mcpx 0.2.1

package/src/executor.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect } from "bun:test";
+
+import type { Backend } from "./backends.js";
+import { executeCode, sanitizeName } from "./executor.js";
+
+const emptyBackends = new Map<string, Backend>();
+
+describe("executeCode", () => {
+  test("returns simple value with no tool calls", async () => {
+    const result = await executeCode("return 42;", emptyBackends);
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toBe(42);
+  });
+
+  test("returns string value", async () => {
+    const result = await executeCode('return "hello world";', emptyBackends);
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toBe("hello world");
+  });
+
+  test("returns object value", async () => {
+    const result = await executeCode('return { key: "value", num: 1 };', emptyBackends);
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toEqual({ key: "value", num: 1 });
+  });
+
+  test("returns array value", async () => {
+    const result = await executeCode("return [1, 2, 3];", emptyBackends);
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toEqual([1, 2, 3]);
+  });
+
+  test("handles async computation", async () => {
+    const result = await executeCode(
+      "const x = await Promise.resolve(10); return x * 2;",
+      emptyBackends,
+    );
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toBe(20);
+  });
+
+  test("returns null for code with no return", async () => {
+    const result = await executeCode("const x = 1;", emptyBackends);
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value == null).toBe(true);
+  });
+
+  test("handles syntax error gracefully", async () => {
+    const result = await executeCode("{{{{invalid syntax", emptyBackends);
+    expect(result.isErr()).toBe(true);
+  });
+
+  test("handles runtime error gracefully", async () => {
+    const result = await executeCode('throw new Error("something went wrong");', emptyBackends);
+    expect(result.isErr()).toBe(true);
+  });
+
+  test("with empty backends, no tool functions are injected", async () => {
+    const result = await executeCode(
+      "return typeof nonexistent_tool === 'undefined' ? 'no-tools' : 'has-tools';",
+      emptyBackends,
+    );
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toBe("no-tools");
+  });
+
+  test("tool bindings return real values via await", async () => {
+    const mockBackend: Backend = {
+      name: "test",
+      client: {
+        callTool: async ({
+          name,
+          arguments: args,
+        }: {
+          name: string;
+          arguments?: Record<string, unknown>;
+        }) => ({
+          content: [
+            {
+              type: "text",
+              text: `called ${name} with ${JSON.stringify(args)}`,
+            },
+          ],
+        }),
+        close: async () => {},
+      } as any,
+      tools: [{ name: "echo", description: "echo tool", inputSchema: {} }],
+    };
+    const backends = new Map([["test", mockBackend]]);
+
+    const result = await executeCode(
+      'const r = await test_echo({ msg: "hello" }); return r.content[0].text;',
+      backends,
+    );
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toBe('called echo with {"msg":"hello"}');
+  });
+
+  test("multi-step tool calls use results from previous calls", async () => {
+    let callCount = 0;
+    const mockBackend: Backend = {
+      name: "mock",
+      client: {
+        callTool: async ({
+          name,
+          arguments: args,
+        }: {
+          name: string;
+          arguments?: Record<string, unknown>;
+        }) => {
+          callCount++;
+          if (name === "get_id") return { content: [{ type: "text", text: "42" }] };
+          if (name === "get_details")
+            return {
+              content: [{ type: "text", text: `details for ${(args as any).id}` }],
+            };
+          return { content: [{ type: "text", text: "unknown" }] };
+        },
+        close: async () => {},
+      } as any,
+      tools: [
+        { name: "get_id", description: "get id", inputSchema: {} },
+        { name: "get_details", description: "get details", inputSchema: {} },
+      ],
+    };
+    const backends = new Map([["mock", mockBackend]]);
+
+    const result = await executeCode(
+      `const idResult = await mock_get_id({});
+       const id = idResult.content[0].text;
+       const details = await mock_get_details({ id });
+       return details.content[0].text;`,
+      backends,
+    );
+    expect(result.isOk()).toBe(true);
+    if (result.isOk()) expect(result.value.value).toBe("details for 42");
+    expect(callCount).toBe(2);
+  });
+
+  test("unknown tool returns error object", async () => {
+    const result = await executeCode(
+      "const r = await nonexistent_tool_name({}); return r;",
+      emptyBackends,
+    );
+    // Should either error or return undefined since tool doesn't exist
+    expect(result.isOk() || result.isErr()).toBe(true);
+  });
+});
+
+describe("sanitizeName", () => {
+  test("replaces hyphens", () => expect(sanitizeName("my-tool")).toBe("my_tool"));
+  test("replaces dots", () => expect(sanitizeName("my.tool")).toBe("my_tool"));
+  test("keeps underscores", () => expect(sanitizeName("my_tool")).toBe("my_tool"));
+  test("keeps alphanumeric", () => expect(sanitizeName("tool123")).toBe("tool123"));
+});

package/src/executor.ts

@@ -0,0 +1,195 @@
+import { ok, err, type Result } from "neverthrow";
+import { createNodeDriver, NodeExecutionDriver, type BindingFunction } from "secure-exec";
+
+import { validateSyntax } from "./ast.js";
+import type { Backend } from "./backends.js";
+
+type ToolFunction = (args: Record<string, unknown>) => Promise<unknown>;
+
+export interface LogEntry {
+  level: "log" | "warn" | "error" | "info" | "debug";
+  args: unknown[];
+}
+
+export interface ExecuteResult {
+  value: unknown;
+  logs: LogEntry[];
+}
+
+export type ExecuteError =
+  | { kind: "runtime"; code: number }
+  | {
+      kind: "parse";
+      message: string;
+      line?: number;
+      column?: number;
+      snippet?: string;
+    }
+  | { kind: "exception"; message: string };
+
+/** Convert snake_case to camelCase */
+export function snakeToCamel(name: string): string {
+  return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+/** Build a map of prefixed tool names → backend tool call functions */
+function buildToolRegistry(backends: Map<string, Backend>): Map<string, ToolFunction> {
+  const registry = new Map<string, ToolFunction>();
+
+  for (const [name, backend] of backends) {
+    for (const tool of backend.tools) {
+      const prefixed = `${name}_${sanitizeName(tool.name)}`;
+      registry.set(prefixed, async (args) => {
+        return backend.client.callTool({
+          name: tool.name,
+          arguments: args,
+        });
+      });
+    }
+  }
+
+  return registry;
+}
+
+/** Build a map of backend name → tool names (for namespace generation) */
+function buildBackendToolMap(backends: Map<string, Backend>): Map<string, string[]> {
+  const map = new Map<string, string[]>();
+  for (const [name, backend] of backends) {
+    map.set(
+      name,
+      backend.tools.map((t) => t.name),
+    );
+  }
+  return map;
+}
+
+/**
+ * Generate code bindings: flat aliases + namespace proxies + console capture.
+ */
+function wrapCodeWithBindings(
+  code: string,
+  toolNames: string[],
+  backendTools: Map<string, string[]>,
+): string {
+  // Console capture
+  const consoleOverride = `
+const __consoleLogs = [];
+const console = {
+  log: (...args) => __consoleLogs.push({ level: "log", args }),
+  warn: (...args) => __consoleLogs.push({ level: "warn", args }),
+  error: (...args) => __consoleLogs.push({ level: "error", args }),
+  info: (...args) => __consoleLogs.push({ level: "info", args }),
+  debug: (...args) => __consoleLogs.push({ level: "debug", args }),
+};`;
+
+  // Flat aliases (backward compat)
+  const aliases = toolNames
+    .map((n) => `const ${n} = (args) => SecureExec.bindings.callTool("${n}", args || {});`)
+    .join("\n");
+
+  // Namespace proxies
+  const namespaces: string[] = [];
+  for (const [backendName, tools] of backendTools) {
+    const methods = tools
+      .map((toolName) => {
+        const camelName = snakeToCamel(sanitizeName(toolName));
+        const prefixed = `${backendName}_${sanitizeName(toolName)}`;
+        return `  ${camelName}: (args) => SecureExec.bindings.callTool("${prefixed}", args || {})`;
+      })
+      .join(",\n");
+    namespaces.push(`const ${backendName} = {\n${methods}\n};`);
+  }
+
+  return `
+${consoleOverride}
+${aliases}
+${namespaces.join("\n")}
+
+const __userResult = await (async () => { ${code} })();
+export default { value: __userResult, logs: __consoleLogs };
+`;
+}
+
+/** Execute LLM-generated code in a V8 isolate with access to backend MCP tools */
+export async function executeCode(
+  code: string,
+  backends: Map<string, Backend>,
+  opts?: { memoryLimit?: number; cpuTimeLimitMs?: number },
+): Promise<Result<ExecuteResult, ExecuteError>> {
+  const registry = buildToolRegistry(backends);
+  const backendTools = buildBackendToolMap(backends);
+
+  const callTool: BindingFunction = async (name: unknown, args: unknown) => {
+    const toolName = name as string;
+    const toolArgs = (args as Record<string, unknown>) ?? {};
+    const fn = registry.get(toolName);
+    if (!fn) {
+      return { error: `Unknown tool: ${toolName}` };
+    }
+    try {
+      return await fn(toolArgs);
+    } catch (e) {
+      return { error: (e as Error).message };
+    }
+  };
+
+  const wrappedCode = wrapCodeWithBindings(code, [...registry.keys()], backendTools);
+
+  // AST validation — catch syntax errors with better messages before V8 execution
+  const syntaxError = validateSyntax(wrappedCode);
+  if (syntaxError) {
+    return err({
+      kind: "parse",
+      message: syntaxError.message,
+      line: syntaxError.line,
+      column: syntaxError.column,
+      snippet: syntaxError.snippet,
+    });
+  }
+
+  const systemDriver = createNodeDriver({
+    permissions: {
+      fs: () => ({ allow: false }),
+      network: () => ({ allow: false }),
+      childProcess: () => ({ allow: false }),
+      env: () => ({ allow: false }),
+    },
+  });
+
+  const driver = new NodeExecutionDriver({
+    system: systemDriver,
+    runtime: {
+      process: { cwd: "/root", env: {} },
+      os: { homedir: "/root", tmpdir: "/tmp" },
+    },
+    memoryLimit: opts?.memoryLimit ?? 64,
+    cpuTimeLimitMs: opts?.cpuTimeLimitMs ?? 30_000,
+    bindings: { callTool },
+  });
+
+  try {
+    const runResult = await driver.run(wrappedCode, "/entry.mjs");
+
+    if (runResult.code !== 0) {
+      return err({ kind: "runtime", code: runResult.code });
+    }
+
+    const exports = runResult.exports as Record<string, unknown>;
+    const result = exports?.default as {
+      value: unknown;
+      logs: LogEntry[];
+    } | null;
+    return ok({
+      value: result?.value ?? null,
+      logs: result?.logs ?? [],
+    });
+  } catch (e) {
+    return err({ kind: "exception", message: (e as Error).message });
+  } finally {
+    driver.dispose();
+  }
+}
+
+export function sanitizeName(name: string): string {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}