@hraness/dawg 0.0.0-stage → 0.3.0

package/core/sdk/eval-child.ts

@@ -0,0 +1,113 @@
+/**
+ * Runs inside the evaluation subprocess (`bun --no-addons --no-install
+ * --smol eval-child.ts <project>`): imports the project's `song.ts`, fills
+ * sample hashes, and prints one JSON line. Never imported by dawg itself.
+ */
+
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const MAX_SAMPLE_FILE_BYTES = 50 * 1024 * 1024;
+
+type Diagnostic = {
+  message: string;
+  file?: string;
+  line?: number;
+  col?: number;
+};
+
+async function main(): Promise<void> {
+  const project = realpathSync(resolve(process.argv[2] ?? "."));
+  const entry = join(project, "song.ts");
+  let output: unknown;
+  try {
+    const module = (await import(pathToFileURL(entry).href)) as {
+      default?: unknown;
+    };
+    const song = module.default;
+    if (typeof song !== "object" || song === null)
+      throw new Error("song.ts must `export default song({...})`");
+    output = { ok: true, score: await withSampleHashes(song, project) };
+  } catch (error) {
+    output = { ok: false, error: diagnostic(error, project) };
+  }
+  process.stdout.write(`${JSON.stringify(output)}\n`);
+}
+
+function diagnostic(error: unknown, project: string): Diagnostic {
+  if (typeof error !== "object" || error === null)
+    return { message: String(error) };
+  let record = error as Record<string, unknown>;
+  // Bun wraps build errors in an AggregateError; the first one has the position.
+  if (Array.isArray(record.errors) && record.errors.length > 0) {
+    const first: unknown = record.errors[0];
+    if (typeof first === "object" && first !== null)
+      record = first as Record<string, unknown>;
+  }
+  const message =
+    typeof record.message === "string" ? record.message : String(error);
+  const out: Diagnostic = { message };
+  // Bun's BuildMessage/ResolveMessage carry a position.
+  const position = record.position as Record<string, unknown> | undefined;
+  if (position && typeof position.file === "string") {
+    out.file = relative(project, position.file) || position.file;
+    if (typeof position.line === "number") out.line = position.line;
+    if (typeof position.column === "number") out.col = position.column;
+    return out;
+  }
+  const stack = typeof record.stack === "string" ? record.stack : "";
+  for (const line of stack.split("\n")) {
+    const match = line.match(
+      /\(?((?:\/|file:\/\/)[^\s()]+?):(\d+):(\d+)\)?\s*$/,
+    );
+    if (!match) continue;
+    const file = match[1]!.replace(/^file:\/\//, "");
+    const rel = relative(project, file);
+    if (rel.startsWith("..") || isAbsolute(rel) || rel.startsWith(".dawg"))
+      continue;
+    out.file = rel;
+    out.line = Number(match[2]);
+    out.col = Number(match[3]);
+    break;
+  }
+  return out;
+}
+
+/** Adds `sha256` to sampler voices whose file exists and is within the size limit. */
+async function withSampleHashes(
+  song: object,
+  project: string,
+): Promise<unknown> {
+  const plain = JSON.parse(JSON.stringify(song)) as Record<string, unknown>;
+  const tracks = Array.isArray(plain.tracks) ? plain.tracks : [];
+  for (const track of tracks) {
+    if (typeof track !== "object" || track === null) continue;
+    const sampler = (track as Record<string, unknown>).sampler;
+    if (typeof sampler !== "object" || sampler === null) continue;
+    const voices = (sampler as Record<string, unknown>).voices;
+    if (typeof voices !== "object" || voices === null) continue;
+    for (const voice of Object.values(voices as Record<string, unknown>)) {
+      if (typeof voice !== "object" || voice === null) continue;
+      const ref = voice as Record<string, unknown>;
+      if (typeof ref.src !== "string" || typeof ref.sha256 === "string")
+        continue;
+      const path = resolve(project, ref.src);
+      if (relative(project, path).startsWith("..")) continue;
+      try {
+        const info = await stat(path);
+        if (!info.isFile() || info.size > MAX_SAMPLE_FILE_BYTES) continue;
+        ref.sha256 = createHash("sha256")
+          .update(await readFile(path))
+          .digest("hex");
+      } catch {
+        // Missing sample: left for `dawg check` to report.
+      }
+    }
+  }
+  return plain;
+}
+
+await main();

package/core/sdk/eval.ts

@@ -0,0 +1,257 @@
+/**
+ * Evaluates a project's `song.ts` in a sandboxed Bun subprocess and parses
+ * the result from `unknown` into a validated `TrackScore`.
+ *
+ * The child runs `eval-child.ts` with a scrubbed environment, the project as
+ * its working directory, no native addons or auto-install, a 10 second
+ * budget and a 1 MiB output bound. Anything it prints that is not the
+ * expected JSON line is a diagnostic.
+ */
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { decodeLoopDocument } from "../loop.ts";
+import { ScoreValidationError, TrackScore } from "../score.ts";
+
+export const EVAL_TIMEOUT_MS = 10_000;
+export const EVAL_MAX_OUTPUT_BYTES = 1024 * 1024;
+
+/** A problem in a project file; `file` is project-relative when known. */
+export type Diagnostic = Readonly<{
+  message: string;
+  file?: string;
+  line?: number;
+  col?: number;
+}>;
+
+export type EvalResult =
+  | Readonly<{ ok: true; score: TrackScore; ms: number }>
+  | Readonly<{ ok: false; diagnostics: readonly Diagnostic[]; ms: number }>;
+
+/** How the evaluator starts its child; tests inject a scripted one. */
+export type EvalSpawn = (
+  args: readonly string[],
+  options: Readonly<{
+    cwd: string;
+    env: Readonly<Record<string, string>>;
+    timeoutMs: number;
+    maxOutputBytes: number;
+  }>,
+) => Promise<
+  Readonly<{ code: number; stdout: string; stderr: string; killed: boolean }>
+>;
+
+export type EvalOptions = Readonly<{
+  spawn?: EvalSpawn;
+  timeoutMs?: number;
+}>;
+
+const CHILD = join(dirname(fileURLToPath(import.meta.url)), "eval-child.ts");
+
+/** Evaluates `<project>/song.ts`; never throws for project errors. */
+export async function evaluateProject(
+  project: string,
+  options: EvalOptions = {},
+): Promise<EvalResult> {
+  const started = performance.now();
+  const spawn = options.spawn ?? bunSpawn;
+  const env: Record<string, string> = {};
+  for (const key of ["PATH", "HOME", "TMPDIR"]) {
+    const value = process.env[key];
+    if (value !== undefined) env[key] = value;
+  }
+  env.NO_COLOR = "1";
+  const done = (result: EvalResult): EvalResult => result;
+  let run: Awaited<ReturnType<EvalSpawn>>;
+  try {
+    run = await spawn(
+      [
+        process.execPath,
+        "--no-addons",
+        "--no-install",
+        "--smol",
+        CHILD,
+        project,
+      ],
+      {
+        cwd: project,
+        env,
+        timeoutMs: options.timeoutMs ?? EVAL_TIMEOUT_MS,
+        maxOutputBytes: EVAL_MAX_OUTPUT_BYTES,
+      },
+    );
+  } catch (error) {
+    return done(
+      failure(started, [{ message: `could not start bun: ${text(error)}` }]),
+    );
+  }
+  if (run.killed)
+    return done(
+      failure(started, [
+        {
+          file: "song.ts",
+          message: "evaluation timed out (10 s); song.ts must be pure",
+        },
+      ]),
+    );
+  const line = lastJsonLine(run.stdout);
+  if (line === undefined) {
+    const detail = (run.stderr || run.stdout)
+      .trim()
+      .split("\n")
+      .slice(0, 8)
+      .join("\n");
+    return done(
+      failure(started, [
+        {
+          file: "song.ts",
+          message: detail
+            ? `evaluation exited with code ${run.code}: ${detail}`
+            : `evaluation exited with code ${run.code}`,
+        },
+      ]),
+    );
+  }
+  return done(parseChildOutput(line, started));
+}
+
+/** Parses the child's JSON line from `unknown`; exported for tests. */
+export function parseChildOutput(
+  line: string,
+  started = performance.now(),
+): EvalResult {
+  let value: unknown;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return failure(started, [
+      { file: "song.ts", message: "evaluation printed invalid JSON" },
+    ]);
+  }
+  if (typeof value !== "object" || value === null)
+    return failure(started, [
+      { file: "song.ts", message: "evaluation printed no result" },
+    ]);
+  const record = value as Record<string, unknown>;
+  if (record.ok !== true) {
+    const error =
+      typeof record.error === "object" && record.error !== null
+        ? (record.error as Record<string, unknown>)
+        : {};
+    const diagnostic: {
+      message: string;
+      file?: string;
+      line?: number;
+      col?: number;
+    } = {
+      message:
+        typeof error.message === "string" && error.message.length > 0
+          ? error.message.slice(0, 2000)
+          : "song.ts threw",
+    };
+    if (typeof error.file === "string")
+      diagnostic.file = error.file.slice(0, 512);
+    if (typeof error.line === "number" && Number.isInteger(error.line))
+      diagnostic.line = error.line;
+    if (typeof error.col === "number" && Number.isInteger(error.col))
+      diagnostic.col = error.col;
+    return failure(started, [diagnostic]);
+  }
+  try {
+    const score = decodeLoopDocument(record.score);
+    return { ok: true, score, ms: elapsed(started) };
+  } catch (error) {
+    return failure(started, [
+      {
+        file: "song.ts",
+        message:
+          error instanceof ScoreValidationError
+            ? `invalid score: ${error.message}`
+            : `invalid score: ${text(error)}`,
+      },
+    ]);
+  }
+}
+
+/** `file:line:col message` for humans; file-less diagnostics print the message alone. */
+export function formatDiagnostic(diagnostic: Diagnostic): string {
+  if (!diagnostic.file) return diagnostic.message;
+  const where =
+    diagnostic.line === undefined
+      ? diagnostic.file
+      : `${diagnostic.file}:${diagnostic.line}:${diagnostic.col ?? 1}`;
+  return `${where} ${diagnostic.message}`;
+}
+
+function failure(
+  started: number,
+  diagnostics: readonly Diagnostic[],
+): EvalResult {
+  return {
+    ok: false,
+    diagnostics: Object.freeze(diagnostics.map((d) => Object.freeze({ ...d }))),
+    ms: elapsed(started),
+  };
+}
+
+function elapsed(started: number): number {
+  return Math.round(performance.now() - started);
+}
+
+function text(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function lastJsonLine(stdout: string): string | undefined {
+  const lines = stdout.split("\n").map((line) => line.trim());
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index]!;
+    if (line.startsWith('{"ok":')) return line;
+  }
+  return undefined;
+}
+
+/** Default spawner: `Bun.spawn` with the given env only (no inheritance). */
+export const bunSpawn: EvalSpawn = async (args, options) => {
+  const child = Bun.spawn([...args], {
+    cwd: options.cwd,
+    env: options.env,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  let killed = false;
+  const timer = setTimeout(() => {
+    killed = true;
+    child.kill();
+  }, options.timeoutMs);
+  const read = async (stream: ReadableStream<Uint8Array> | null) => {
+    if (!stream) return "";
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    const reader = stream.getReader();
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done || !value) break;
+      if (total + value.byteLength > options.maxOutputBytes) {
+        killed = true;
+        child.kill();
+        break;
+      }
+      chunks.push(value);
+      total += value.byteLength;
+    }
+    reader.releaseLock();
+    return Buffer.concat(chunks).toString("utf8");
+  };
+  try {
+    const [stdout, stderr, code] = await Promise.all([
+      read(child.stdout),
+      read(child.stderr),
+      child.exited,
+    ]);
+    return { code, stdout, stderr, killed };
+  } finally {
+    clearTimeout(timer);
+  }
+};