@openpond/evals 0.7.5 → 0.7.6

package/dist/sql-execution-contract.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { assertBoundedTaskJson } from "./task-schema.js";
+const integer = z.string().regex(/^(0|-?[1-9][0-9]*)$/).max(20).refine(value => {
+    if (value.length > 20 || !/^(0|-?[1-9][0-9]*)$/.test(value))
+        return false;
+    const parsed = BigInt(value);
+    return parsed >= -(1n << 63n) && parsed < (1n << 63n);
+}, "SQL integers must fit signed 64-bit storage.");
+export const SqlValueSchema = z.union([
+    z.null(), z.string().max(262_144),
+    z.number().finite(),
+    z.object({ integer }).strict(),
+    z.object({ blobBase64: z.string().max(349_528).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/) }).strict(),
+]);
+const identifier = z.string().min(1).max(128).refine(value => !value.includes("\0"));
+export const SqlSnapshotSchema = z.object({
+    tables: z.array(z.object({
+        name: identifier,
+        columns: z.array(z.object({ name: identifier, type: z.enum(["INTEGER", "REAL", "TEXT", "BLOB"]) }).strict()).min(1).max(128),
+        rows: z.array(z.array(SqlValueSchema).max(128)).max(4_096),
+    }).strict()).max(64),
+}).strict().superRefine((snapshot, context) => {
+    const names = new Set();
+    for (const [index, table] of snapshot.tables.entries()) {
+        const name = table.name.toLowerCase();
+        if (names.has(name) || name.startsWith("sqlite_"))
+            context.addIssue({ code: "custom", path: ["tables", index, "name"], message: "Table names must be unique and outside SQLite's reserved namespace." });
+        names.add(name);
+        if (new Set(table.columns.map(column => column.name.toLowerCase())).size !== table.columns.length)
+            context.addIssue({ code: "custom", path: ["tables", index, "columns"], message: "Column names must be unique." });
+        if (table.rows.some(row => row.length !== table.columns.length))
+            context.addIssue({ code: "custom", path: ["tables", index, "rows"], message: "Each row must match the declared columns." });
+    }
+});
+export const SqlExecutionRequestSchema = z.object({
+    schemaVersion: z.literal("openpond.sqlExecution.v1"),
+    snapshot: SqlSnapshotSchema,
+    sql: z.string().min(1).max(65_536).refine(value => !value.includes("\0")),
+    maxRows: z.number().int().min(1).max(4_096),
+    maxResultBytes: z.number().int().min(256).max(262_144),
+}).strict();
+export const SqlExecutionResultSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("completed"), columns: z.array(z.string()).max(128), rows: z.array(z.array(SqlValueSchema).max(128)).max(4_096) }).strict(),
+    z.object({ status: z.literal("rejected"), code: z.enum(["invalid_query", "multiple_statements", "result_too_large", "memory_limit"]) }).strict(),
+]);
+export function assertSqlExecutionRequest(value) {
+    assertBoundedTaskJson(value, 1_048_576);
+    const parsed = SqlExecutionRequestSchema.parse(value);
+    if (new TextEncoder().encode(parsed.sql).byteLength > 65_536)
+        throw new Error("sql_source_too_large");
+    return parsed;
+}

package/dist/sql-execution-engine.js

@@ -0,0 +1,135 @@
+import sqlite3InitModule from "@sqlite.org/sqlite-wasm";
+import { sqlWasmBinary } from "./sql-wasm-binary.js";
+import { assertSqlExecutionRequest } from "./sql-execution-contract.js";
+class SqlQueryRejectedError extends Error {
+}
+const functions = new Set([
+    "abs", "avg", "char", "coalesce", "concat", "concat_ws", "count", "format", "glob", "group_concat", "hex", "if", "ifnull", "iif", "instr", "length", "like", "likelihood", "likely", "lower", "ltrim", "max", "min", "nullif", "octet_length", "printf", "quote", "replace", "round", "rtrim", "sign", "string_agg", "substr", "substring", "sum", "total", "trim", "typeof", "unhex", "unicode", "unlikely", "upper", "zeroblob",
+    "row_number", "rank", "dense_rank", "percent_rank", "cume_dist", "ntile", "lag", "lead", "first_value", "last_value", "nth_value",
+    "json", "json_array", "json_array_length", "json_error_position", "json_extract", "json_group_array", "json_group_object", "json_insert", "json_object", "json_patch", "json_quote", "json_remove", "json_replace", "json_set", "json_type", "json_valid", "->", "->>",
+]);
+const quoteIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
+const decode = (value) => typeof value !== "object" || value === null ? value : "integer" in value ? BigInt(value.integer) : Buffer.from(value.blobBase64, "base64");
+function encode(value) {
+    if (typeof value === "bigint")
+        return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(Number.MIN_SAFE_INTEGER) ? Number(value) : { integer: value.toString() };
+    if (value instanceof Uint8Array)
+        return { blobBase64: Buffer.from(value).toString("base64") };
+    if (value === null || typeof value === "string" || (typeof value === "number" && Number.isFinite(value)))
+        return value;
+    throw new SqlQueryRejectedError("sql_result_unsupported_value");
+}
+/** Internal child entry only: synchronous SQLite never runs in the application owner. */
+export async function executeSqlInChild(raw) {
+    const input = assertSqlExecutionRequest(raw);
+    // The upstream runtime accepts Emscripten options; its declaration omits them.
+    const initialize = sqlite3InitModule;
+    const sqlite = await initialize({ wasmBinary: sqlWasmBinary, wasmMemory: new WebAssembly.Memory({ initial: 128, maximum: 512 }), print: () => { }, printErr: () => { } });
+    const { capi } = sqlite;
+    const db = new sqlite.oo1.DB(":memory:", "c");
+    try {
+        db.exec("PRAGMA temp_store=MEMORY; PRAGMA trusted_schema=OFF;");
+        for (const table of input.snapshot.tables) {
+            db.exec(`CREATE TABLE ${quoteIdentifier(table.name)} (${table.columns.map(column => `${quoteIdentifier(column.name)} ${column.type}`).join(",")})`);
+            const statement = db.prepare(`INSERT INTO ${quoteIdentifier(table.name)} VALUES (${table.columns.map(() => "?").join(",")})`);
+            try {
+                for (const row of table.rows) {
+                    statement.bind(row.map(decode));
+                    statement.step();
+                    statement.reset(true);
+                }
+            }
+            finally {
+                statement.finalize();
+            }
+        }
+        db.exec("PRAGMA query_only=ON");
+        for (const [id, limit] of [[capi.SQLITE_LIMIT_LENGTH, 1_048_576], [capi.SQLITE_LIMIT_SQL_LENGTH, 65_536], [capi.SQLITE_LIMIT_COLUMN, 128], [capi.SQLITE_LIMIT_EXPR_DEPTH, 100], [capi.SQLITE_LIMIT_COMPOUND_SELECT, 50], [capi.SQLITE_LIMIT_VDBE_OP, 100_000], [capi.SQLITE_LIMIT_ATTACHED, 0], [capi.SQLITE_LIMIT_WORKER_THREADS, 0]])
+            capi.sqlite3_limit(db.pointer, id, limit);
+        const tables = new Set(input.snapshot.tables.map(table => table.name.toLowerCase()));
+        const rc = capi.sqlite3_set_authorizer(db.pointer, (_, action, first, second, database) => {
+            if (action === capi.SQLITE_SELECT || action === capi.SQLITE_RECURSIVE)
+                return capi.SQLITE_OK;
+            // SQLite's count(*) optimization reports a null database and empty column.
+            if (action === capi.SQLITE_READ && (database === "main" || (database === 0 && second === "")) && typeof first === "string" && tables.has(first.toLowerCase()))
+                return capi.SQLITE_OK;
+            if (action === capi.SQLITE_FUNCTION && typeof second === "string" && functions.has(second.toLowerCase()))
+                return capi.SQLITE_OK;
+            return capi.SQLITE_DENY;
+        }, 0);
+        if (rc !== capi.SQLITE_OK)
+            throw new Error("sql_authorizer_install_failed");
+        try {
+            const count = countStatements(sqlite, db.pointer, input.sql);
+            if (count > 1)
+                return { status: "rejected", code: "multiple_statements" };
+            if (count !== 1)
+                return { status: "rejected", code: "invalid_query" };
+            const statement = db.prepare(input.sql);
+            try {
+                if (!statement.columnCount || statement.parameterCount)
+                    return { status: "rejected", code: "invalid_query" };
+                const columns = statement.getColumnNames();
+                const rows = [];
+                let bytes = Buffer.byteLength(JSON.stringify({ status: "completed", columns, rows }));
+                if (bytes > input.maxResultBytes)
+                    return { status: "rejected", code: "result_too_large" };
+                while (statement.step()) {
+                    if (rows.length >= input.maxRows)
+                        return { status: "rejected", code: "result_too_large" };
+                    const row = statement.get([]).map(encode);
+                    bytes += Buffer.byteLength(JSON.stringify(row)) + (rows.length ? 1 : 0);
+                    if (bytes > input.maxResultBytes)
+                        return { status: "rejected", code: "result_too_large" };
+                    rows.push(row);
+                }
+                return { status: "completed", columns, rows };
+            }
+            finally {
+                statement.finalize();
+            }
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "resultCode" in error ? error.resultCode : undefined;
+            if (typeof code !== "number" && !(error instanceof SqlQueryRejectedError))
+                throw error;
+            return { status: "rejected", code: code === capi.SQLITE_NOMEM ? "memory_limit" : code === capi.SQLITE_TOOBIG ? "result_too_large" : "invalid_query" };
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function countStatements(sqlite, db, sql) {
+    const { wasm, capi } = sqlite;
+    const scope = wasm.scopedAllocPush();
+    try {
+        const [start, bytes] = wasm.scopedAllocCString(sql, true);
+        const [statementOut, tailOut] = wasm.scopedAllocPtr(2);
+        let cursor = start, count = 0;
+        while (cursor < start + bytes) {
+            wasm.pokePtr(statementOut, 0);
+            wasm.pokePtr(tailOut, 0);
+            const rc = capi.sqlite3_prepare_v3(db, cursor, start + bytes - cursor, 0, statementOut, tailOut);
+            const statement = wasm.peekPtr(statementOut);
+            try {
+                if (rc !== capi.SQLITE_OK)
+                    throw Object.assign(new Error("sql_prepare_failed"), { resultCode: rc });
+                if (statement && ++count > 1)
+                    return count;
+            }
+            finally {
+                if (statement)
+                    capi.sqlite3_finalize(statement);
+            }
+            const tail = wasm.peekPtr(tailOut);
+            if (tail <= cursor)
+                throw new Error("sql_parser_did_not_advance");
+            cursor = tail;
+        }
+        return count;
+    }
+    finally {
+        wasm.scopedAllocPop(scope);
+    }
+}

package/dist/sql-execution-node.js

@@ -0,0 +1,58 @@
+import { spawn } from "node:child_process";
+import { sqlExecutionProcessSource } from "./sql-execution-process-source.js";
+import { assertBoundedTaskJson } from "./task-schema.js";
+import { assertSqlExecutionRequest, SqlExecutionResultSchema } from "./sql-execution-contract.js";
+export * from "./sql-execution-contract.js";
+/** Every result, cancellation and timeout settles after the owned child exits. */
+export async function executeSqlInProcess(input) {
+    input.signal?.throwIfAborted();
+    if (!Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 30_000)
+        throw new Error("sql_timeout_invalid");
+    const request = assertSqlExecutionRequest(input.request);
+    const { signal } = input;
+    const program = `globalThis.__openpondSqlInput = JSON.parse(${JSON.stringify(JSON.stringify(request))});\n${sqlExecutionProcessSource}`;
+    return new Promise((resolve, reject) => {
+        const child = spawn("node", ["--max-old-space-size=64", "--input-type=module", "-"], { stdio: ["pipe", "pipe", "pipe"], env: { PATH: process.env.PATH }, windowsHide: true });
+        let failure, output = "", outputBytes = 0, stderrBytes = 0;
+        const stop = (error) => { failure ??= error; child.kill("SIGKILL"); };
+        const cancel = () => stop(signal?.reason instanceof Error ? signal.reason : new Error("sql_cancelled"));
+        const timer = setTimeout(() => stop(new Error("sql_timeout")), input.timeoutMs);
+        signal?.addEventListener("abort", cancel, { once: true });
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            outputBytes += Buffer.byteLength(chunk);
+            if (outputBytes > request.maxResultBytes + 65_536)
+                stop(new Error("sql_process_response_too_large"));
+            else
+                output += chunk;
+        });
+        child.stderr.on("data", (chunk) => { stderrBytes += chunk.byteLength; if (stderrBytes > 65_536)
+            stop(new Error("sql_process_stderr_too_large")); });
+        child.once("error", error => { failure ??= error; });
+        child.stdin.on("error", error => stop(error));
+        child.once("close", code => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", cancel);
+            if (failure) {
+                reject(failure);
+                return;
+            }
+            try {
+                if (code !== 0)
+                    throw new Error("sql_process_exited_without_result");
+                const message = JSON.parse(output);
+                if (!message || typeof message !== "object" || !("ok" in message) || message.ok !== true || !("result" in message))
+                    throw new Error("sql_environment_failed");
+                const result = SqlExecutionResultSchema.parse(message.result);
+                assertBoundedTaskJson(result, request.maxResultBytes);
+                resolve(result);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        child.stdin.end(program);
+        if (signal?.aborted)
+            cancel();
+    });
+}

package/dist/sql-execution-process-entry.js

@@ -0,0 +1,3 @@
+import { executeSqlInChild } from "./sql-execution-engine.js";
+const input = globalThis.__openpondSqlInput;
+void executeSqlInChild(input).then(result => process.stdout.write(JSON.stringify({ ok: true, result })), () => process.stdout.write(JSON.stringify({ ok: false, error: "sql_environment_failed" })));