@1agh/maude 0.40.0 → 0.42.0

package/apps/studio/exporters/svg.ts

@@ -13,10 +13,11 @@ import path from 'node:path';
 import JSZip from 'jszip';
 
 import { getBrowserBundle } from './_browser-bundles.ts';
-import { exportShimPath, resolveExportRuntime } from './_runtime.ts';
+import { exportShimPath, runShim } from './_runtime.ts';
 import {
   canvasShellUrl,
   type ExportContext,
+  type ExportHooks,
   type ExportOptions,
   type ExportResult,
 } from './index.ts';
@@ -30,7 +31,8 @@ async function captureSvg(
   ctx: ExportContext,
   outDir: string,
   timeoutSec: number,
-  bundlePath: string
+  bundlePath: string,
+  hooks?: ExportHooks
 ): Promise<string[]> {
   const args = [
     SVG_PLAYWRIGHT,
@@ -55,31 +57,20 @@ async function captureSvg(
   // Run via a resolved node/bun runtime so the shim's `import 'playwright'`
   // resolves against dev-server/node_modules (playwright is a devDep). `npm exec`
   // doesn't bridge the module path for ESM imports — confirmed against npm 10.x.
-  // resolveExportRuntime() replaces a hardcoded `'node'` so a compiled binary
-  // without `node` on PATH surfaces an actionable error, not `posix_spawn 'node'`.
-  const proc = Bun.spawn([resolveExportRuntime(), ...args], {
+  // runShim resolves the runtime internally so a compiled binary without
+  // `node` on PATH surfaces an actionable error, not `posix_spawn 'node'`.
+  return runShim(args, {
     cwd: path.dirname(SVG_PLAYWRIGHT),
-    stdout: 'pipe',
-    stderr: 'pipe',
+    signal: hooks?.signal,
+    onProgress: hooks?.onProgress,
   });
-  const [stdout, stderr] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ]);
-  const code = await proc.exited;
-  if (code !== 0) {
-    throw new Error(`_svg-playwright exited ${code}: ${stderr.trim() || stdout.trim()}`);
-  }
-  return stdout
-    .split('\n')
-    .map((s) => s.trim())
-    .filter(Boolean);
 }
 
 export async function run(
   targets: Target[],
   options: ExportOptions,
-  ctx: ExportContext
+  ctx: ExportContext,
+  hooks?: ExportHooks
 ): Promise<ExportResult> {
   if (!targets.length) {
     return { filename: 'export.svg', contentType: 'image/svg+xml', body: new Uint8Array(0) };
@@ -96,9 +87,10 @@ export async function run(
 
   try {
     const written: string[] = [];
-    for (const t of elementTargets) {
-      const paths = await captureSvg(t, ctx, tmp, timeoutSec, bundlePath);
+    for (let i = 0; i < elementTargets.length; i += 1) {
+      const paths = await captureSvg(elementTargets[i], ctx, tmp, timeoutSec, bundlePath, hooks);
       written.push(...paths);
+      hooks?.onProgress?.({ current: i + 1, total: elementTargets.length });
     }
     if (!written.length) {
       return { filename: 'export.svg', contentType: 'image/svg+xml', body: new Uint8Array(0) };

package/apps/studio/exporters/video.ts

@@ -20,10 +20,11 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 
 import { getEncodeLibBundle, getWebRendererBundle } from './_browser-bundles.ts';
-import { exportShimPath, resolveExportRuntime } from './_runtime.ts';
+import { exportShimPath, runShim } from './_runtime.ts';
 import {
   canvasShellUrl,
   type ExportContext,
+  type ExportHooks,
   type ExportOptions,
   type ExportResult,
 } from './index.ts';
@@ -47,7 +48,8 @@ async function runVideo(
   format: VideoFormat,
   targets: Target[],
   options: ExportOptions,
-  ctx: ExportContext
+  ctx: ExportContext,
+  hooks?: ExportHooks
 ): Promise<ExportResult> {
   const el = targets.find((t): t is Extract<Target, { kind: 'element' }> => t.kind === 'element');
   if (!el) {
@@ -119,25 +121,18 @@ async function runVideo(
   }
 
   try {
-    const proc = Bun.spawn([resolveExportRuntime(), ...args], {
+    const stdoutLines = await runShim(args, {
       cwd: path.dirname(VIDEO_PLAYWRIGHT),
-      stdout: 'pipe',
-      stderr: 'pipe',
+      signal: hooks?.signal,
+      // No MAUDE_PROGRESS line from this shim yet — frame-count progress is a
+      // follow-up (video scope is always a single artboard, never multi).
     });
-    const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-    ]);
-    const code = await proc.exited;
-    if (code !== 0) {
-      throw new Error(`_video-playwright exited ${code}: ${stderr.trim() || stdout.trim()}`);
-    }
     const body = new Uint8Array(readFileSync(outPath));
     // The container can differ from the request (mp4 → webm fallback when the
     // browser has no H.264 encoder). Read the summary line for the real ext.
     let ext: string = format;
     try {
-      const lastLine = stdout.trim().split('\n').filter(Boolean).pop() ?? '{}';
+      const lastLine = stdoutLines.at(-1) ?? '{}';
       const summary = JSON.parse(lastLine) as { container?: string };
       if (summary.container) ext = summary.container;
     } catch {
@@ -174,11 +169,14 @@ function resolveFrames(options: ExportOptions, fps: number | undefined): number
 }
 
 export const mp4 = {
-  run: (t: Target[], o: ExportOptions, c: ExportContext) => runVideo('mp4', t, o, c),
+  run: (t: Target[], o: ExportOptions, c: ExportContext, h?: ExportHooks) =>
+    runVideo('mp4', t, o, c, h),
 };
 export const webm = {
-  run: (t: Target[], o: ExportOptions, c: ExportContext) => runVideo('webm', t, o, c),
+  run: (t: Target[], o: ExportOptions, c: ExportContext, h?: ExportHooks) =>
+    runVideo('webm', t, o, c, h),
 };
 export const gif = {
-  run: (t: Target[], o: ExportOptions, c: ExportContext) => runVideo('gif', t, o, c),
+  run: (t: Target[], o: ExportOptions, c: ExportContext, h?: ExportHooks) =>
+    runVideo('gif', t, o, c, h),
 };

package/apps/studio/git/service.ts

@@ -211,7 +211,9 @@ function isMaudeRuntimeState(p: string): boolean {
   return (
     /(^|\/)_(?:server|active|sync|preflight|locator|export-history)\.json$/.test(p) ||
     /(^|\/)_server\.(?:lock|log)$/.test(p) ||
-    /(^|\/)_(?:history|trash|draw|smoke|canvas-state|state|chat|comments|untrusted)(?:\/|$)/.test(p)
+    /(^|\/)_(?:history|trash|draw|smoke|canvas-state|state|chat|comments|untrusted|export-jobs)(?:\/|$)/.test(
+      p
+    )
   );
 }
 

package/apps/studio/history.ts

@@ -6,11 +6,24 @@
 
 import type { Dirent } from 'node:fs';
 import { existsSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
+import { readdir, unlink } from 'node:fs/promises';
 import path from 'node:path';
 
 import type { Context } from './context.ts';
 
+/**
+ * Per-slug snapshot cap (G3 security, DDR-152). The structural-edit routes
+ * (delete / insert / resize-artboard) each write a WHOLE-FILE snapshot here, and
+ * an untrusted active canvas can drive them in a loop — so `_history/<slug>/`
+ * was the uncapped disk-fill surface the adversarial review flagged. Pruning the
+ * oldest pairs bounds disk regardless of edit rate; 300 pairs is still a deep
+ * rollback runway for real work. Read lazily so tests can tune it via env.
+ */
+function maxSnapshotsPerSlug(): number {
+  const env = Number(process.env.MAUDE_MAX_SNAPSHOTS);
+  return Number.isFinite(env) && env > 0 ? Math.floor(env) : 300;
+}
+
 export interface Snapshot {
   slug: string;
   ts: string; // ISO
@@ -92,9 +105,42 @@ export function createHistory(ctx: Context): History {
     };
     await Bun.write(contentPath, contentBytes);
     await Bun.write(meta.metaPath, JSON.stringify({ ...meta, file }, null, 2));
+    await pruneSnapshots(slug).catch(() => {
+      /* pruning is best-effort — never fail a snapshot over it */
+    });
     return meta;
   }
 
+  /**
+   * Keep only the newest MAX_SNAPSHOTS_PER_SLUG snapshot pairs for a slug,
+   * unlinking the oldest content-blob + `.json` sidecar beyond the cap.
+   * Filenames are ts-derived (`tsForFilename`) so a lexical sort is chronological.
+   */
+  async function pruneSnapshots(slug: string): Promise<void> {
+    const dir = path.join(ctx.paths.historyDir, slug);
+    let names: string[];
+    try {
+      names = await readdir(dir);
+    } catch {
+      return; // no dir yet
+    }
+    const stems = names
+      .filter((n) => n.endsWith('.json'))
+      .map((n) => n.slice(0, -'.json'.length))
+      .sort();
+    const excess = stems.length - maxSnapshotsPerSlug();
+    if (excess <= 0) return;
+    for (const stem of stems.slice(0, excess)) {
+      for (const n of names) {
+        // The meta (`<stem>.json`) and its content blob (`<stem>.<ext>`) share
+        // the stem; the fixed-length ISO stem is never a prefix of another.
+        if (n === `${stem}.json` || n.startsWith(`${stem}.`)) {
+          await unlink(path.join(dir, n)).catch(() => {});
+        }
+      }
+    }
+  }
+
   async function listSnapshots(file: string): Promise<Snapshot[]> {
     const slug = fileSlug(file, ctx.paths.designRel);
     const dir = path.join(ctx.paths.historyDir, slug);