@hassangameryt/freeflow 0.2.0 → 0.4.0

package/router/dist/sandbox/jq-wasm-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { ScriptSandboxAdapter } from "./script-sandbox.js";
+export declare const JQ_WASM_ROOT_ENV = "FREEFLOW_JQ_WASM_ROOT";
+export interface JqWasmSandboxAdapterOptions {
+  packageRoot: string;
+  id?: string;
+  version?: string;
+}
+export declare function discoverJqWasmSandboxAdaptersFromEnv(env?: NodeJS.ProcessEnv): Promise<ScriptSandboxAdapter[]>;
+export declare function createJqWasmSandboxAdapter(options: JqWasmSandboxAdapterOptions): Promise<ScriptSandboxAdapter>;

package/router/dist/sandbox/jq-wasm-adapter.js

@@ -0,0 +1,429 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { Worker } from "node:worker_threads";
+import { resolveScriptTransformAdapterRoot } from "./adapter-roots.js";
+import { SCRIPT_SANDBOX_REQUIRED_PROOFS, scriptSandboxProofFixturesForLanguage } from "./script-sandbox.js";
+const DEFAULT_PROBE_TIMEOUT_MS = 250;
+const DEFAULT_PROBE_OUTPUT_BYTES = 4096;
+const DEFAULT_WORKER_OLD_GENERATION_MB = 64;
+const DEFAULT_WORKER_YOUNG_GENERATION_MB = 16;
+const SECRET_SENTINEL = "FREEFLOW_SANDBOX_SECRET_SENTINEL_VALUE";
+export const JQ_WASM_ROOT_ENV = "FREEFLOW_JQ_WASM_ROOT";
+const jqProbeCache = new Map();
+export async function discoverJqWasmSandboxAdaptersFromEnv(env = process.env) {
+  const candidate = await resolveScriptTransformAdapterRoot("jq", env);
+  if (!candidate) {
+    return [];
+  }
+  try {
+    return [await createJqWasmSandboxAdapter({ packageRoot: candidate.packageRoot })];
+  } catch (error) {
+    return [
+      unavailableJqAdapter(
+        `jq-wasm adapter could not load from ${candidate.source === "env" ? candidate.envVar : "global adapter cache"}: ${errorMessage(error)}`,
+      ),
+    ];
+  }
+}
+export async function createJqWasmSandboxAdapter(options) {
+  const runtime = await loadJqRuntime(options.packageRoot);
+  return {
+    id: options.id ?? "jq-wasm",
+    version: options.version ?? runtime.packageVersion,
+    languages: ["jq"],
+    async probe(language, config) {
+      if (language !== "jq") {
+        return {
+          status: "unavailable",
+          reason: `jq-wasm supports jq, not ${language}.`,
+          passedProofs: [],
+          failedProofs: [...SCRIPT_SANDBOX_REQUIRED_PROOFS],
+          runtime: runtimeInfo(runtime),
+        };
+      }
+      return probeJqRuntime(runtime, config);
+    },
+    async execute(request) {
+      if (request.language !== "jq") {
+        return {
+          status: "policy_violation",
+          stdout: "",
+          stderr: "",
+          outputFiles: [],
+          exitCode: null,
+          reason: `jq-wasm supports jq, not ${request.language}.`,
+        };
+      }
+      if (request.network !== "off") {
+        return {
+          status: "policy_violation",
+          stdout: "",
+          stderr: "",
+          outputFiles: [],
+          exitCode: null,
+          reason: "jq-wasm adapter only supports network=off.",
+        };
+      }
+      const json = {};
+      for (const source of request.sources) {
+        json[source.alias] = await readFile(source.path, "utf8");
+      }
+      const run = await runJq(runtime, {
+        query: request.code,
+        json,
+        timeoutMs: request.limits.timeoutMs,
+        outputBytes: request.limits.maxOutputBytes,
+      });
+      if (run.status === "timed_out") {
+        return {
+          status: "timed_out",
+          stdout: run.stdout,
+          stderr: run.stderr,
+          outputFiles: [],
+          exitCode: null,
+          durationMs: run.durationMs,
+          reason: "jq-wasm execution exceeded timeoutMs.",
+        };
+      }
+      if (run.truncated || run.status === "output_limit_exceeded") {
+        return {
+          status: "failed",
+          stdout: run.stdout,
+          stderr: run.stderr,
+          outputFiles: [],
+          exitCode: run.exitCode,
+          durationMs: run.durationMs,
+          reason: "jq-wasm execution exceeded maxOutputBytes.",
+        };
+      }
+      if (run.status === "error") {
+        return {
+          status: "failed",
+          stdout: run.stdout,
+          stderr: run.stderr || run.errorMessage || "jq-wasm execution failed.",
+          outputFiles: [],
+          exitCode: run.exitCode,
+          durationMs: run.durationMs,
+          reason: "jq-wasm execution failed.",
+        };
+      }
+      if (run.exitCode !== 0) {
+        return {
+          status: "failed",
+          stdout: run.stdout,
+          stderr: run.stderr,
+          outputFiles: [],
+          exitCode: run.exitCode,
+          durationMs: run.durationMs,
+          reason: `jq-wasm execution exited with code ${run.exitCode}.`,
+        };
+      }
+      return {
+        status: "success",
+        stdout: run.stdout,
+        stderr: run.stderr,
+        outputFiles: [],
+        exitCode: 0,
+        durationMs: run.durationMs,
+      };
+    },
+  };
+}
+function unavailableJqAdapter(reason) {
+  return {
+    id: "jq-wasm",
+    version: "unavailable",
+    languages: ["jq"],
+    async probe() {
+      return {
+        status: "unavailable",
+        reason,
+        passedProofs: [],
+        failedProofs: [...SCRIPT_SANDBOX_REQUIRED_PROOFS],
+      };
+    },
+    async execute() {
+      return {
+        status: "policy_violation",
+        stdout: "",
+        stderr: "",
+        outputFiles: [],
+        exitCode: null,
+        reason,
+      };
+    },
+  };
+}
+async function loadJqRuntime(packageRoot) {
+  const resolvedRoot = resolve(packageRoot);
+  const packageJson = JSON.parse(await readFile(join(resolvedRoot, "package.json"), "utf8"));
+  const jqPath = join(resolvedRoot, String(packageJson.main ?? "dist/index.js"));
+  const entry = await readFile(jqPath);
+  return {
+    packageName: String(packageJson.name ?? "jq-wasm"),
+    packageVersion: String(packageJson.version ?? "unknown"),
+    entrySha256: createHash("sha256").update(entry).digest("hex"),
+    jqPath,
+  };
+}
+async function probeJqRuntime(runtime, config) {
+  const timeoutMs = Math.min(config.limits.timeoutMs, DEFAULT_PROBE_TIMEOUT_MS);
+  const outputBytes = Math.min(config.limits.maxOutputBytes, DEFAULT_PROBE_OUTPUT_BYTES);
+  const cacheKey = [runtime.packageVersion, runtime.entrySha256, timeoutMs, outputBytes, config.network].join(":");
+  const cached = jqProbeCache.get(cacheKey);
+  if (cached) {
+    return cloneProbeResult(await cached);
+  }
+  const probePromise = runJqProbe(runtime, timeoutMs, outputBytes);
+  jqProbeCache.set(cacheKey, probePromise);
+  try {
+    return cloneProbeResult(await probePromise);
+  } catch (error) {
+    jqProbeCache.delete(cacheKey);
+    throw error;
+  }
+}
+async function runJqProbe(runtime, timeoutMs, outputBytes) {
+  const previousSecret = process.env.FREEFLOW_SANDBOX_SECRET_SENTINEL;
+  process.env.FREEFLOW_SANDBOX_SECRET_SENTINEL = SECRET_SENTINEL;
+  try {
+    const passedProofs = [];
+    const failedProofs = [];
+    const fixtures = scriptSandboxProofFixturesForLanguage("jq");
+    for (const fixture of fixtures) {
+      const run = await runJq(runtime, {
+        query: fixture.program,
+        json: { test_log: "INFO setup\nERROR target\n" },
+        timeoutMs,
+        outputBytes,
+      });
+      const assessment = assessJqProof(fixture.proof, run, timeoutMs, outputBytes);
+      if (assessment) {
+        passedProofs.push(fixture.proof);
+      } else {
+        failedProofs.push(fixture.proof);
+      }
+    }
+    const allPassed = SCRIPT_SANDBOX_REQUIRED_PROOFS.every((proof) => passedProofs.includes(proof));
+    return {
+      status: allPassed ? "available" : "unavailable",
+      reason: allPassed
+        ? "jq-wasm passed every required jq sandbox proof."
+        : "jq-wasm did not pass every required jq sandbox proof.",
+      passedProofs,
+      failedProofs,
+      runtime: runtimeInfo(runtime),
+    };
+  } finally {
+    if (previousSecret === undefined) {
+      delete process.env.FREEFLOW_SANDBOX_SECRET_SENTINEL;
+    } else {
+      process.env.FREEFLOW_SANDBOX_SECRET_SENTINEL = previousSecret;
+    }
+  }
+}
+function cloneProbeResult(result) {
+  const clone = {
+    ...result,
+    passedProofs: [...result.passedProofs],
+    failedProofs: [...result.failedProofs],
+  };
+  if (result.runtime) {
+    clone.runtime = { ...result.runtime };
+  }
+  return clone;
+}
+async function runJq(runtime, options) {
+  const start = Date.now();
+  const workerSource = `
+    (async () => {
+    const { parentPort, workerData } = await import('node:worker_threads');
+    const { createRequire } = await import('node:module');
+    const require = createRequire(workerData.jqPath);
+    const jq = require(workerData.jqPath);
+    const byteLength = (value) => Buffer.byteLength(String(value ?? ''), 'utf8');
+    const capText = (value, cap) => {
+      const text = String(value ?? '');
+      const buffer = Buffer.from(text, 'utf8');
+      return {
+        text: buffer.byteLength > cap ? buffer.subarray(0, cap).toString('utf8') : text,
+        bytes: buffer.byteLength,
+        truncated: buffer.byteLength > cap,
+      };
+    };
+    const capStreams = (stdoutValue, stderrValue, outputBytes) => {
+      const stdoutRawBytes = byteLength(stdoutValue);
+      const stderrRawBytes = byteLength(stderrValue);
+      let stdoutCap = 0;
+      let stderrCap = 0;
+      if (stdoutRawBytes > 0 && stderrRawBytes > 0) {
+        stdoutCap = Math.max(1, Math.floor(outputBytes / 2));
+        stderrCap = Math.max(1, outputBytes - stdoutCap);
+      } else if (stdoutRawBytes > 0) {
+        stdoutCap = Math.max(0, outputBytes);
+      } else if (stderrRawBytes > 0) {
+        stderrCap = Math.max(0, outputBytes);
+      }
+      const stdout = capText(stdoutValue, stdoutCap);
+      const stderr = capText(stderrValue, stderrCap);
+      return {
+        stdout: stdout.text,
+        stderr: stderr.text,
+        rawStdoutBytes: stdout.bytes,
+        rawStderrBytes: stderr.bytes,
+        truncated: stdout.truncated || stderr.truncated,
+      };
+    };
+      try {
+        const result = await jq.raw(workerData.json, workerData.query, ['-c']);
+        const capped = capStreams(result.stdout, result.stderr, workerData.outputBytes);
+        parentPort.postMessage({
+          status: capped.truncated ? 'output_limit_exceeded' : 'success',
+          stdout: capped.stdout,
+          stderr: capped.stderr,
+          exitCode: result.exitCode,
+          truncated: capped.truncated,
+          rawStdoutBytes: capped.rawStdoutBytes,
+          rawStderrBytes: capped.rawStderrBytes,
+        });
+      } catch (error) {
+        const message = String(error && error.stack || error);
+        const capped = capStreams('', message, workerData.outputBytes);
+        parentPort.postMessage({
+          status: capped.truncated ? 'output_limit_exceeded' : 'error',
+          stdout: capped.stdout,
+          stderr: capped.stderr,
+          exitCode: null,
+          truncated: capped.truncated,
+          rawStdoutBytes: capped.rawStdoutBytes,
+          rawStderrBytes: capped.rawStderrBytes,
+          errorMessage: message,
+        });
+      }
+    })();
+  `;
+  const worker = new Worker(workerSource, {
+    eval: true,
+    workerData: {
+      jqPath: runtime.jqPath,
+      query: options.query,
+      json: options.json,
+      outputBytes: options.outputBytes,
+    },
+    resourceLimits: {
+      maxOldGenerationSizeMb: DEFAULT_WORKER_OLD_GENERATION_MB,
+      maxYoungGenerationSizeMb: DEFAULT_WORKER_YOUNG_GENERATION_MB,
+    },
+  });
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      void worker.terminate();
+      const stdout = result.stdout ?? "";
+      const stderr = result.stderr ?? "";
+      resolve({
+        ...result,
+        stdout,
+        stderr,
+        stdoutBytes: Buffer.byteLength(stdout, "utf8"),
+        stderrBytes: Buffer.byteLength(stderr, "utf8"),
+        outputBytes: Buffer.byteLength(stdout, "utf8") + Buffer.byteLength(stderr, "utf8"),
+        durationMs: Date.now() - start,
+      });
+    };
+    const timer = setTimeout(() => {
+      finish({
+        status: "timed_out",
+        stdout: "",
+        stderr: "",
+        exitCode: null,
+        truncated: false,
+        rawStdoutBytes: 0,
+        rawStderrBytes: 0,
+      });
+    }, options.timeoutMs);
+    worker.on("message", (message) => finish(normalizeWorkerMessage(message)));
+    worker.on("error", (error) => {
+      const message = String(error?.stack ?? error);
+      finish({
+        status: "error",
+        stdout: "",
+        stderr: message,
+        exitCode: null,
+        truncated: false,
+        rawStdoutBytes: 0,
+        rawStderrBytes: Buffer.byteLength(message, "utf8"),
+        errorMessage: message,
+      });
+    });
+    worker.on("exit", (code) => {
+      if (!settled && code !== 0) {
+        finish({
+          status: "error",
+          stdout: "",
+          stderr: `worker exited with code ${code}`,
+          exitCode: code,
+          truncated: false,
+          rawStdoutBytes: 0,
+          rawStderrBytes: 0,
+        });
+      }
+    });
+  });
+}
+function normalizeWorkerMessage(message) {
+  return {
+    status: isJqRunStatus(message?.status) ? message.status : "error",
+    stdout: typeof message?.stdout === "string" ? message.stdout : "",
+    stderr: typeof message?.stderr === "string" ? message.stderr : "",
+    exitCode: Number.isInteger(message?.exitCode) ? Number(message.exitCode) : null,
+    truncated: Boolean(message?.truncated),
+    rawStdoutBytes: Number.isFinite(message?.rawStdoutBytes) ? Number(message.rawStdoutBytes) : 0,
+    rawStderrBytes: Number.isFinite(message?.rawStderrBytes) ? Number(message.rawStderrBytes) : 0,
+    errorMessage: typeof message?.errorMessage === "string" ? message.errorMessage : undefined,
+  };
+}
+function isJqRunStatus(value) {
+  return value === "success" || value === "error" || value === "timed_out" || value === "output_limit_exceeded";
+}
+function assessJqProof(proof, run, timeoutMs, outputBytes) {
+  const combined = `${run.stdout}\n${run.stderr}\n${run.errorMessage ?? ""}`;
+  switch (proof) {
+    case "env_access_denied":
+      return !combined.includes(SECRET_SENTINEL) && !combined.includes("process.env");
+    case "home_access_denied":
+      return !combined.includes(process.env.HOME ?? "__no_home__") && !combined.match(/PRIVATE KEY|\.ssh/);
+    case "repo_access_denied":
+      return !combined.includes("@hassangameryt/freeflow") && !combined.includes("package.json");
+    case "vault_access_denied":
+      return !combined.includes("ffout_") && !combined.includes("ffrec_");
+    case "network_access_denied":
+      return run.exitCode !== 0 && combined.includes("network unavailable");
+    case "input_read_only":
+      return run.exitCode !== 0 && combined.includes("module not found");
+    case "output_escape_denied":
+      return run.exitCode !== 0 && combined.includes("module not found");
+    case "stdout_stderr_bounded":
+      return (
+        run.status !== "error" &&
+        run.truncated &&
+        run.outputBytes <= outputBytes &&
+        run.stdoutBytes > 0 &&
+        run.stderrBytes > 0 &&
+        run.rawStdoutBytes > outputBytes &&
+        run.rawStderrBytes > outputBytes
+      );
+    case "timeout_enforced":
+      return run.status === "timed_out" && run.durationMs < timeoutMs * 5;
+  }
+}
+function runtimeInfo(runtime) {
+  return { name: runtime.packageName, version: `${runtime.packageVersion} entry:${runtime.entrySha256.slice(0, 12)}` };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}

package/router/dist/sandbox/quickjs-wasi-adapter.d.ts

@@ -0,0 +1,13 @@
+import type { ScriptSandboxAdapter } from "./script-sandbox.js";
+export declare const QUICKJS_WASI_ROOT_ENV = "FREEFLOW_QUICKJS_WASI_ROOT";
+export interface QuickJsWasiSandboxAdapterOptions {
+  packageRoot: string;
+  id?: string;
+  version?: string;
+}
+export declare function discoverQuickJsWasiSandboxAdaptersFromEnv(
+  env?: NodeJS.ProcessEnv,
+): Promise<ScriptSandboxAdapter[]>;
+export declare function createQuickJsWasiSandboxAdapter(
+  options: QuickJsWasiSandboxAdapterOptions,
+): Promise<ScriptSandboxAdapter>;