@1agh/maude 0.42.0 → 0.44.0

package/apps/studio/generation/gemini.test.ts

@@ -0,0 +1,350 @@
+// generation/gemini.test.ts — the Gemini adapter + download localizer proven
+// against a stubbed HTTP response (no real key, no network). A 1x1 PNG's base64
+// round-trips: adapter → GenResult.bytes → localizeGenAsset → a saveAsset call
+// that lands `assets/<sha8>.png`.
+
+import { afterEach, describe, expect, test } from 'bun:test';
+
+import { createGeminiAdapter, extractOperationName, extractVideoUri } from './adapters/gemini.ts';
+import { localizeGenAsset } from './download.ts';
+import { createAdapter, providersForModality } from './registry.ts';
+import type { AdapterContext } from './types.ts';
+
+// A real 1x1 transparent PNG (so a magic-byte sniff downstream would accept it).
+const PNG_1x1_B64 =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';
+
+const realFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+function stubFetch(body: unknown, status = 200): void {
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { 'content-type': 'application/json' },
+    })) as typeof fetch;
+}
+
+function ctxWith(overrides: Partial<AdapterContext> = {}): AdapterContext {
+  return {
+    apiKey: 'AIza-test-key',
+    localize: async () => 'assets/stub.png',
+    ...overrides,
+  };
+}
+
+describe('gemini adapter', () => {
+  test('a successful generateContent yields an already-done Job with PNG bytes', async () => {
+    stubFetch({
+      candidates: [
+        { content: { parts: [{ inlineData: { mimeType: 'image/png', data: PNG_1x1_B64 } }] } },
+      ],
+    });
+    const adapter = createGeminiAdapter(ctxWith());
+    const job = await adapter.submit({
+      modality: 'image',
+      provider: 'gemini',
+      prompt: 'a red circle',
+    });
+    const res = await job.result();
+    expect(job.status()).toBe('done');
+    expect(res.assets).toHaveLength(1);
+    expect(res.assets[0].kind).toBe('image');
+    expect(res.assets[0].bytes?.byteLength).toBeGreaterThan(0);
+  });
+
+  test('a missing key fails fast without a network call', async () => {
+    let called = false;
+    globalThis.fetch = (async () => {
+      called = true;
+      return new Response('{}');
+    }) as typeof fetch;
+    const adapter = createGeminiAdapter(ctxWith({ apiKey: null }));
+    const job = await adapter.submit({ modality: 'image', provider: 'gemini', prompt: 'x' });
+    await expect(job.result()).rejects.toThrow(/no Google Gemini key/);
+    expect(called).toBe(false);
+  });
+
+  test('an HTTP error surfaces the provider message, never the key', async () => {
+    stubFetch({ error: { message: 'quota exceeded' } }, 429);
+    const adapter = createGeminiAdapter(ctxWith());
+    const job = await adapter.submit({ modality: 'image', provider: 'gemini', prompt: 'x' });
+    await expect(job.result()).rejects.toThrow(/quota exceeded/);
+  });
+
+  test('a response with no image part is an error', async () => {
+    stubFetch({ candidates: [{ content: { parts: [{ text: 'I cannot do that' }] } }] });
+    const adapter = createGeminiAdapter(ctxWith());
+    const job = await adapter.submit({ modality: 'image', provider: 'gemini', prompt: 'x' });
+    await expect(job.result()).rejects.toThrow(/no image/);
+  });
+
+  // Task 1.2 — the maskless-edit flow reads the source asset into an inlineData
+  // part alongside the prompt (via the host-provided readSourceAsset).
+  test('an edit request sends the source image as an inlineData part', async () => {
+    let sentBody: {
+      contents?: Array<{
+        parts?: Array<{ text?: string; inlineData?: { mimeType?: string; data?: string } }>;
+      }>;
+    } | null = null;
+    globalThis.fetch = (async (_url: string, init: RequestInit) => {
+      sentBody = JSON.parse(String(init.body));
+      return new Response(
+        JSON.stringify({
+          candidates: [
+            { content: { parts: [{ inlineData: { mimeType: 'image/png', data: PNG_1x1_B64 } }] } },
+          ],
+        }),
+        { status: 200, headers: { 'content-type': 'application/json' } }
+      );
+    }) as typeof fetch;
+    const adapter = createGeminiAdapter(
+      ctxWith({
+        readSourceAsset: async () => ({
+          bytes: new Uint8Array([137, 80, 78, 71]),
+          mime: 'image/png',
+        }),
+      })
+    );
+    const job = await adapter.submit({
+      modality: 'image',
+      provider: 'gemini',
+      prompt: 'make the sky purple',
+      sourceAsset: 'assets/deadbeef.png',
+    });
+    await job.result();
+    const parts = sentBody?.contents?.[0]?.parts ?? [];
+    // Source image FIRST, then the instruction text (Gemini's edit order).
+    expect(parts[0]?.inlineData?.mimeType).toBe('image/png');
+    expect(typeof parts[0]?.inlineData?.data).toBe('string');
+    expect(parts[1]?.text).toBe('make the sky purple');
+  });
+
+  test('an edit request with no source-asset reader fails fast', async () => {
+    let called = false;
+    globalThis.fetch = (async () => {
+      called = true;
+      return new Response('{}');
+    }) as typeof fetch;
+    const adapter = createGeminiAdapter(ctxWith()); // no readSourceAsset
+    const job = await adapter.submit({
+      modality: 'image',
+      provider: 'gemini',
+      prompt: 'edit',
+      sourceAsset: 'assets/deadbeef.png',
+    });
+    await expect(job.result()).rejects.toThrow(/source-asset access/);
+    expect(called).toBe(false);
+  });
+
+  test('an edit whose source is not an image is rejected', async () => {
+    const adapter = createGeminiAdapter(
+      ctxWith({
+        readSourceAsset: async () => ({ bytes: new Uint8Array([0, 0, 0]), mime: 'video/mp4' }),
+      })
+    );
+    const job = await adapter.submit({
+      modality: 'image',
+      provider: 'gemini',
+      prompt: 'edit',
+      sourceAsset: 'assets/deadbeef.mp4',
+    });
+    await expect(job.result()).rejects.toThrow(/not an image/);
+  });
+
+  // security fan-out F2 — an env-poisoned non-default base is refused before the
+  // key-bearing request (unless MAUDE_GEN_ALLOW_CUSTOM_BASE is opted in).
+  test('a non-allowlisted MAUDE_GEMINI_API_BASE is refused without touching the network', async () => {
+    const prevBase = process.env.MAUDE_GEMINI_API_BASE;
+    const prevAllow = process.env.MAUDE_GEN_ALLOW_CUSTOM_BASE;
+    process.env.MAUDE_GEMINI_API_BASE = 'https://evil.example.com/v1beta';
+    delete process.env.MAUDE_GEN_ALLOW_CUSTOM_BASE;
+    // Re-import the module so the module-level base constant re-reads the env.
+    const mod = await import(`./adapters/gemini.ts?evilbase=${Date.now()}`);
+    let called = false;
+    globalThis.fetch = (async () => {
+      called = true;
+      return new Response('{}');
+    }) as typeof fetch;
+    try {
+      const adapter = mod.createGeminiAdapter(ctxWith());
+      const job = await adapter.submit({ modality: 'image', provider: 'gemini', prompt: 'x' });
+      await expect(job.result()).rejects.toThrow(/not allowlisted/);
+      expect(called).toBe(false);
+    } finally {
+      if (prevBase === undefined) delete process.env.MAUDE_GEMINI_API_BASE;
+      else process.env.MAUDE_GEMINI_API_BASE = prevBase;
+      if (prevAllow === undefined) delete process.env.MAUDE_GEN_ALLOW_CUSTOM_BASE;
+      else process.env.MAUDE_GEN_ALLOW_CUSTOM_BASE = prevAllow;
+    }
+  });
+
+  // security fan-out F1 — an oversized provider response is rejected before it
+  // is fully materialized + base64-decoded in RAM (OOM guard).
+  test('an over-cap response body is rejected (RAM DoS guard)', async () => {
+    const prev = process.env.MAUDE_GEMINI_MAX_RESPONSE_BYTES;
+    // The cap has a 1 MB floor, so drive the test with a >1 MB body at the floor.
+    process.env.MAUDE_GEMINI_MAX_RESPONSE_BYTES = String(1024 * 1024);
+    const mod = await import(`./adapters/gemini.ts?cap=${Date.now()}`);
+    globalThis.fetch = (async () =>
+      new Response('x'.repeat(2 * 1024 * 1024), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      })) as typeof fetch;
+    try {
+      const adapter = mod.createGeminiAdapter(ctxWith());
+      const job = await adapter.submit({ modality: 'image', provider: 'gemini', prompt: 'x' });
+      await expect(job.result()).rejects.toThrow(/too large|exceeded/);
+    } finally {
+      if (prev === undefined) delete process.env.MAUDE_GEMINI_MAX_RESPONSE_BYTES;
+      else process.env.MAUDE_GEMINI_MAX_RESPONSE_BYTES = prev;
+    }
+  });
+});
+
+describe('download localizer', () => {
+  test('inline bytes land via saveAsset and return the rel path', async () => {
+    const saved: Uint8Array[] = [];
+    const rel = await localizeGenAsset(
+      { kind: 'image', mime: 'image/png', bytes: new Uint8Array([137, 80, 78, 71]) },
+      {
+        saveAsset: async (bytes) => {
+          saved.push(bytes);
+          return { ok: true, path: 'assets/deadbeef.png' };
+        },
+      }
+    );
+    expect(rel).toBe('assets/deadbeef.png');
+    expect(saved).toHaveLength(1);
+  });
+
+  test('a rejected save throws', async () => {
+    await expect(
+      localizeGenAsset(
+        { kind: 'image', mime: 'image/png', bytes: new Uint8Array([1]) },
+        { saveAsset: async () => ({ ok: false, error: 'not an image' }) }
+      )
+    ).rejects.toThrow(/rejected on save/);
+  });
+
+  test('a URL result fails loud in Phase 0 (no unhardened egress)', async () => {
+    await expect(
+      localizeGenAsset(
+        { kind: 'image', mime: 'image/png', url: 'https://cdn.example/x.png' },
+        { saveAsset: async () => ({ ok: true, path: 'assets/x.png' }) }
+      )
+    ).rejects.toThrow(/Phase 1/);
+  });
+});
+
+describe('registry', () => {
+  test('gemini is registered for image and instantiable', () => {
+    expect(providersForModality('image').some((p) => p.id === 'gemini')).toBe(true);
+    const adapter = createAdapter('gemini', ctxWith());
+    expect(adapter.descriptor.id).toBe('gemini');
+  });
+
+  test('an unknown provider throws', () => {
+    expect(() => createAdapter('nope', ctxWith())).toThrow(/unknown provider/);
+  });
+});
+
+describe('veo video (Task 3.1 — async operation lifecycle)', () => {
+  // A minimal MP4 (ftyp box) so a magic-byte sniff downstream would accept it.
+  const MP4 = new Uint8Array([
+    0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x6d, 0x70, 0x34, 0x32, 0, 0, 0, 0, 0x6d, 0x70,
+    0x34, 0x32, 0x69, 0x73, 0x6f, 0x6d,
+  ]);
+
+  test('extractOperationName reads the start-response name', () => {
+    expect(extractOperationName({ name: 'operations/abc' })).toBe('operations/abc');
+    expect(extractOperationName({})).toBeNull();
+  });
+
+  test('extractVideoUri walks nested shapes for the first https uri', () => {
+    expect(
+      extractVideoUri({
+        response: {
+          generateVideoResponse: {
+            generatedSamples: [{ video: { uri: 'https://generativelanguage.googleapis.com/v/1' } }],
+          },
+        },
+      })
+    ).toBe('https://generativelanguage.googleapis.com/v/1');
+    expect(
+      extractVideoUri({
+        response: {
+          generatedVideos: [
+            { video: { fileUri: 'https://generativelanguage.googleapis.com/v/2' } },
+          ],
+        },
+      })
+    ).toBe('https://generativelanguage.googleapis.com/v/2');
+    expect(extractVideoUri({ response: {} })).toBeNull();
+  });
+
+  test('submit(video) drives start → poll(done) → download and yields MP4 bytes', async () => {
+    process.env.MAUDE_VEO_POLL_INTERVAL_MS = '1';
+    const calls: string[] = [];
+    globalThis.fetch = (async (url: string) => {
+      calls.push(String(url));
+      if (String(url).includes(':predictLongRunning'))
+        return new Response(JSON.stringify({ name: 'operations/xyz' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      if (String(url).includes('operations/xyz'))
+        return new Response(
+          JSON.stringify({
+            done: true,
+            response: {
+              generatedSamples: [
+                {
+                  video: {
+                    uri: 'https://generativelanguage.googleapis.com/v1beta/files/x:download',
+                  },
+                },
+              ],
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } }
+        );
+      // the video download
+      return new Response(MP4, { status: 200, headers: { 'content-type': 'video/mp4' } });
+    }) as typeof fetch;
+
+    const adapter = createGeminiAdapter(ctxWith());
+    const job = await adapter.submit({ modality: 'video', provider: 'gemini', prompt: 'a wave' });
+    const res = await job.result();
+    delete process.env.MAUDE_VEO_POLL_INTERVAL_MS;
+    expect(res.assets[0].kind).toBe('video');
+    expect(res.assets[0].bytes?.byteLength).toBe(MP4.byteLength);
+    expect(calls.some((u) => u.includes(':predictLongRunning'))).toBe(true);
+    expect(calls.some((u) => u.includes('operations/xyz'))).toBe(true);
+  });
+
+  test('a video URI off the Google host is rejected (no key exfil)', async () => {
+    process.env.MAUDE_VEO_POLL_INTERVAL_MS = '1';
+    globalThis.fetch = (async (url: string) => {
+      if (String(url).includes(':predictLongRunning'))
+        return new Response(JSON.stringify({ name: 'operations/xyz' }), { status: 200 });
+      return new Response(
+        JSON.stringify({ done: true, response: { video: { uri: 'https://evil.example/v.mp4' } } }),
+        { status: 200 }
+      );
+    }) as typeof fetch;
+    const job = await createGeminiAdapter(ctxWith()).submit({
+      modality: 'video',
+      provider: 'gemini',
+      prompt: 'x',
+    });
+    await expect(job.result()).rejects.toThrow(/host not allowlisted/);
+    delete process.env.MAUDE_VEO_POLL_INTERVAL_MS;
+  });
+
+  test('gemini is now registered for the video modality', () => {
+    expect(providersForModality('video').some((p) => p.id === 'gemini')).toBe(true);
+  });
+});

package/apps/studio/generation/jobs.test.ts

@@ -0,0 +1,128 @@
+// generation/jobs.test.ts — the generation job queue: enqueue → done/failed
+// transitions, history ledger, backpressure. Uses a tiny fake Bus + a tmp
+// designRoot so no real server or provider is involved.
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { createGenerationJobQueue, GenerationQueueFullError } from './jobs.ts';
+
+interface FakeBus {
+  emit(evt: string, payload?: unknown): void;
+  on(evt: string, fn: (p: unknown) => void): void;
+}
+
+function fakeBus(): { bus: FakeBus; events: Array<{ evt: string; payload: unknown }> } {
+  const events: Array<{ evt: string; payload: unknown }> = [];
+  return {
+    events,
+    bus: { emit: (evt, payload) => events.push({ evt, payload }), on: () => {} },
+  };
+}
+
+let dir: string;
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'maude-genq-'));
+});
+afterEach(() => rmSync(dir, { recursive: true, force: true }));
+
+describe('generation job queue', () => {
+  test('a successful job transitions queued→running→done and records assets', async () => {
+    const { bus, events } = fakeBus();
+    const q = createGenerationJobQueue(bus as never, dir);
+    const { id, result } = q.enqueue({
+      provider: 'gemini',
+      modality: 'image',
+      model: 'gemini-2.5-flash-image',
+      run: async () => ({ assets: ['assets/abc12345.png'], usage: { ms: 5 } }),
+    });
+    const job = await result;
+    expect(job.id).toBe(id);
+    expect(job.status).toBe('done');
+    expect(job.assets).toEqual(['assets/abc12345.png']);
+    const statuses = events
+      .filter((e) => e.evt === 'generate:job')
+      .map((e) => (e.payload as { status: string }).status);
+    expect(statuses).toContain('queued');
+    expect(statuses).toContain('running');
+    expect(statuses).toContain('done');
+  });
+
+  test('a failing run marks the job failed and captures the error', async () => {
+    const { bus } = fakeBus();
+    const q = createGenerationJobQueue(bus as never, dir);
+    const { result } = q.enqueue({
+      provider: 'gemini',
+      modality: 'image',
+      run: async () => {
+        throw new Error('provider exploded');
+      },
+    });
+    await expect(result).rejects.toThrow(/provider exploded/);
+    const job = q.list()[0];
+    expect(job.status).toBe('failed');
+    expect(job.error).toMatch(/provider exploded/);
+  });
+
+  test('finished jobs persist to the _generate-history.json ledger', async () => {
+    const { bus } = fakeBus();
+    const q = createGenerationJobQueue(bus as never, dir);
+    await q.enqueue({
+      provider: 'gemini',
+      modality: 'image',
+      run: async () => ({ assets: ['assets/deadbeef.png'] }),
+    }).result;
+    const ledger = JSON.parse(readFileSync(join(dir, '_generate-history.json'), 'utf8'));
+    expect(Array.isArray(ledger)).toBe(true);
+    expect(ledger[0].assets).toEqual(['assets/deadbeef.png']);
+    expect(ledger[0].status).toBe('done');
+  });
+
+  test('the ledger is re-seeded on a fresh queue (survives restart)', async () => {
+    const { bus } = fakeBus();
+    const q1 = createGenerationJobQueue(bus as never, dir);
+    await q1.enqueue({
+      provider: 'gemini',
+      modality: 'image',
+      run: async () => ({ assets: ['assets/seed0001.png'] }),
+    }).result;
+    const q2 = createGenerationJobQueue(bus as never, dir);
+    expect(q2.loadHistory().some((h) => h.assets?.includes('assets/seed0001.png'))).toBe(true);
+  });
+
+  test('backpressure — a flood past MAX_PENDING throws GenerationQueueFullError', async () => {
+    const prev = process.env.MAUDE_GENERATE_MAX_QUEUED;
+    const prevConc = process.env.MAUDE_GENERATE_MAX_CONCURRENT;
+    process.env.MAUDE_GENERATE_MAX_QUEUED = '2';
+    process.env.MAUDE_GENERATE_MAX_CONCURRENT = '1';
+    try {
+      const { bus } = fakeBus();
+      const q = createGenerationJobQueue(bus as never, dir);
+      // A run that never resolves until we let it, so jobs stay pending.
+      let release!: () => void;
+      const gate = new Promise<void>((r) => {
+        release = r;
+      });
+      const mk = () =>
+        q.enqueue({
+          provider: 'gemini',
+          modality: 'image',
+          run: async () => {
+            await gate;
+            return { assets: [] };
+          },
+        });
+      mk(); // running (holds the single concurrency slot)
+      mk(); // queued
+      expect(() => mk()).toThrow(GenerationQueueFullError); // over the cap
+      release();
+    } finally {
+      if (prev === undefined) delete process.env.MAUDE_GENERATE_MAX_QUEUED;
+      else process.env.MAUDE_GENERATE_MAX_QUEUED = prev;
+      if (prevConc === undefined) delete process.env.MAUDE_GENERATE_MAX_CONCURRENT;
+      else process.env.MAUDE_GENERATE_MAX_CONCURRENT = prevConc;
+    }
+  });
+});