@1agh/maude 0.55.0 → 0.57.0

package/apps/studio/test/gemma-models.test.ts

@@ -0,0 +1,245 @@
+// gemma-models.test.ts — the pure helpers behind the Gemma scout's two runtimes
+// (feature-scene-aware-keyframes / DDR-183). The download spawn + the live probes
+// are soft-dep gates covered by manual runs; this covers what a security review
+// found load-bearing: the copy/paste install command the user pastes UNREAD, and
+// the loopback pin that keeps the scout egress-free.
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import {
+  getOllamaModel,
+  isLoopbackHostname,
+  listScoutModels,
+  mlxInstallCommand,
+  mlxSetup,
+  mlxVenvDir,
+  ollamaHost,
+  ollamaSetupOptions,
+  pickOllamaGemmaTag,
+} from '../generation/gemma-models.ts';
+
+const ENV_KEYS = ['XDG_CACHE_HOME', 'OLLAMA_HOST', 'MAUDE_OLLAMA_MODEL'] as const;
+const saved = new Map<string, string | undefined>();
+function setEnv(key: (typeof ENV_KEYS)[number], value: string | undefined) {
+  if (!saved.has(key)) saved.set(key, process.env[key]);
+  if (value === undefined) delete process.env[key];
+  else process.env[key] = value;
+}
+afterEach(() => {
+  for (const [k, v] of saved) {
+    if (v === undefined) delete process.env[k];
+    else process.env[k] = v;
+  }
+  saved.clear();
+});
+
+describe('mlxVenvDir / mlxInstallCommand', () => {
+  test('honors XDG_CACHE_HOME, else ~/.maude', () => {
+    setEnv('XDG_CACHE_HOME', '/tmp/xdg');
+    expect(mlxVenvDir()).toBe('/tmp/xdg/maude/mlx-venv');
+    setEnv('XDG_CACHE_HOME', undefined);
+    expect(mlxVenvDir()).toMatch(/\/\.maude\/mlx-venv$/);
+  });
+
+  test('the shown command targets the SAME path the probe checks', () => {
+    setEnv('XDG_CACHE_HOME', '/tmp/xdg');
+    const cmd = mlxInstallCommand();
+    expect(cmd).toContain(mlxVenvDir());
+    expect(cmd).toContain('python3 -m venv');
+    expect(cmd).toContain('install -U mlx-vlm');
+  });
+
+  test('single-quotes the path so shell metacharacters cannot execute', () => {
+    setEnv('XDG_CACHE_HOME', '/tmp/$(touch /tmp/pwned)/`id`/"x"');
+    const cmd = mlxInstallCommand() ?? '';
+    // The dangerous characters are present only INSIDE single quotes — the shell
+    // expands nothing there.
+    expect(cmd).toContain('\'/tmp/$(touch /tmp/pwned)/`id`/"x"/maude/mlx-venv\'');
+    expect(cmd).not.toMatch(/"\/tmp\/\$\(/); // never inside double quotes
+  });
+
+  test('escapes an embedded single quote by closing, escaping, reopening', () => {
+    setEnv('XDG_CACHE_HOME', "/tmp/it's");
+    const cmd = mlxInstallCommand() ?? '';
+    expect(cmd).toContain(`'/tmp/it'\\''s/maude/mlx-venv'`);
+  });
+
+  test('refuses to build a command when the path holds a control char', () => {
+    setEnv('XDG_CACHE_HOME', '/tmp/a\nrm -rf ~');
+    expect(mlxInstallCommand()).toBe(null);
+  });
+});
+
+describe('ollamaHost — loopback pin (DDR-183 egress-free)', () => {
+  test('defaults to loopback and accepts loopback forms', () => {
+    setEnv('OLLAMA_HOST', undefined);
+    expect(ollamaHost()).toBe('http://127.0.0.1:11434');
+    setEnv('OLLAMA_HOST', '127.0.0.1:11434');
+    expect(ollamaHost()).toBe('http://127.0.0.1:11434');
+    setEnv('OLLAMA_HOST', 'http://localhost:11434/');
+    expect(ollamaHost()).toBe('http://localhost:11434');
+  });
+
+  test('refuses every non-loopback host rather than uploading frames to it', () => {
+    for (const host of [
+      '0.0.0.0:11434',
+      '192.168.1.20:11434',
+      'http://169.254.169.254',
+      'http://ollama.example.com',
+      'not a url',
+    ]) {
+      setEnv('OLLAMA_HOST', host);
+      expect(ollamaHost()).toBe(null);
+    }
+  });
+
+  test('isLoopbackHostname accepts only literal loopback', () => {
+    expect(isLoopbackHostname('127.0.0.1')).toBe(true);
+    expect(isLoopbackHostname('127.1.2.3')).toBe(true);
+    expect(isLoopbackHostname('::1')).toBe(true);
+    expect(isLoopbackHostname('localhost')).toBe(true);
+    expect(isLoopbackHostname('127.0.0.1.evil.com')).toBe(false);
+    expect(isLoopbackHostname('10.0.0.1')).toBe(false);
+  });
+});
+
+// The card must never show an instruction this machine can't follow — the whole
+// point of probing brew/python3/curl rather than hardcoding an install line.
+describe('ollamaSetupOptions', () => {
+  const notInstalled = { available: false, model: null, tags: [], installed: false };
+
+  test('installed but not running → start it, never "install it" again', () => {
+    const opts = ollamaSetupOptions({ ...notInstalled, installed: true });
+    expect(opts.map((o) => o.id)).toEqual(['start']);
+    expect(opts[0].command).toBe('ollama serve');
+  });
+
+  test('running → the only thing missing is a model', () => {
+    const opts = ollamaSetupOptions({ available: true, model: null, tags: [], installed: true });
+    expect(opts.map((o) => o.id)).toEqual(['pull']);
+    expect(opts[0].command).toContain('ollama pull');
+  });
+
+  test('not installed → always offers a route, and a download link as the floor', () => {
+    const opts = ollamaSetupOptions(notInstalled);
+    expect(opts.length).toBeGreaterThan(0);
+    const download = opts.find((o) => o.id === 'download');
+    expect(download?.kind).toBe('link');
+    expect(download?.url).toBe('https://ollama.com/download');
+    // Whatever routes are offered, each is actionable as-is.
+    for (const o of opts) expect(o.kind === 'command' ? o.command : o.url).toBeTruthy();
+  });
+
+  test('on macOS/Linux the brew-free script route comes before brew', () => {
+    if (process.platform !== 'darwin' && process.platform !== 'linux') return;
+    const ids = ollamaSetupOptions(notInstalled).map((o) => o.id);
+    if (ids.includes('script') && ids.includes('brew'))
+      expect(ids.indexOf('script')).toBeLessThan(ids.indexOf('brew'));
+  });
+});
+
+// The model list has to be actionable on whatever runtime the machine has —
+// a dead "Needs mlx-vlm" on an Ollama box was the bug this replaced.
+describe('listScoutModels', () => {
+  const offline = { available: false, model: null, tags: [], installed: false };
+  const running = {
+    available: true,
+    model: 'gemma3:4b',
+    tags: ['gemma3:4b', 'llama3:8b'],
+    installed: true,
+  };
+
+  test('every model declares the runtime that can download it', () => {
+    for (const m of listScoutModels(offline)) expect(['mlx', 'ollama']).toContain(m.runtime);
+  });
+
+  test('Ollama models sort first when Ollama is the runtime that can act', () => {
+    expect(listScoutModels(running)[0].runtime).toBe('ollama');
+    expect(listScoutModels(offline)[0].runtime).toBe('mlx');
+  });
+
+  test('an Ollama model counts as downloaded only on an EXACT tag match', () => {
+    const rows = listScoutModels(running).filter((m) => m.runtime === 'ollama');
+    expect(rows.find((m) => m.id === 'ollama:gemma3:4b')?.downloaded).toBe(true);
+    expect(rows.find((m) => m.id === 'ollama:gemma3:12b')?.downloaded).toBe(false);
+    // A near-miss tag is a different pull, not the same model.
+    const nearMiss = listScoutModels({ ...running, tags: ['gemma3:4b-it-q4_K_M'] });
+    expect(nearMiss.find((m) => m.id === 'ollama:gemma3:4b')?.downloaded).toBe(false);
+  });
+
+  test('getOllamaModel only resolves allowlisted ids (the pull target is frozen)', () => {
+    expect(getOllamaModel('ollama:gemma3:4b')?.tag).toBe('gemma3:4b');
+    expect(getOllamaModel('gemma-4-e4b-it-4bit')).toBe(null);
+    expect(getOllamaModel('ollama:../../evil')).toBe(null);
+    expect(getOllamaModel('ollama:llama3:8b')).toBe(null);
+  });
+});
+
+describe('mlxSetup', () => {
+  test('either a usable command or a stated reason — never a silent dead end', () => {
+    const s = mlxSetup();
+    if (s.supported) {
+      expect(s.command).toContain('mlx-vlm');
+      expect(s.reason).toBeUndefined();
+    } else {
+      expect(s.reason).toBeTruthy();
+      expect(s.command).toBeUndefined();
+    }
+  });
+});
+
+// The CLI (bin/_smart-frames.mjs, pure JS — no .ts imports) deliberately carries
+// its OWN copy of these helpers. That duplication is an accepted constraint, so
+// the drift it invites needs a guard: a review already caught the two copies
+// disagreeing about the bare `gemma3` tag.
+describe('CLI ↔ server helper parity', () => {
+  test('pickOllamaGemmaTag agrees on every tag shape', async () => {
+    const cli = await import('../bin/_smart-frames.mjs');
+    setEnv('MAUDE_OLLAMA_MODEL', undefined);
+    for (const tags of [
+      ['gemma3:4b'],
+      ['gemma3'],
+      ['gemma3:1b'],
+      ['gemma3n:e4b'],
+      ['llama3:8b', 'gemma3:12b'],
+      [],
+    ]) {
+      expect(cli.pickOllamaGemmaTag(tags, {})).toBe(pickOllamaGemmaTag(tags));
+    }
+  });
+
+  test('ollamaHost agrees on loopback acceptance and refusal', async () => {
+    const cli = await import('../bin/_smart-frames.mjs');
+    for (const host of [
+      '127.0.0.1:11434',
+      'http://localhost:11434/',
+      '[::1]:11434',
+      '0.0.0.0:11434',
+      '192.168.1.20:11434',
+      'http://ollama.example.com',
+    ]) {
+      setEnv('OLLAMA_HOST', host);
+      expect(cli.ollamaHost({ OLLAMA_HOST: host })).toBe(ollamaHost());
+    }
+  });
+
+  test('the venv path the CLI probes is the one the server installs into', async () => {
+    const cli = await import('../bin/_smart-frames.mjs');
+    setEnv('XDG_CACHE_HOME', '/tmp/xdg');
+    expect(cli.mlxVenvPython({ XDG_CACHE_HOME: '/tmp/xdg' })).toBe(`${mlxVenvDir()}/bin/python3`);
+  });
+});
+
+describe('pickOllamaGemmaTag', () => {
+  test('picks a vision-capable gemma3 tag, skips text-only ones', () => {
+    setEnv('MAUDE_OLLAMA_MODEL', undefined);
+    expect(pickOllamaGemmaTag(['llama3:8b', 'gemma3:4b'])).toBe('gemma3:4b');
+    expect(pickOllamaGemmaTag(['gemma3'])).toBe('gemma3');
+    expect(pickOllamaGemmaTag(['gemma3:1b'])).toBe(null);
+    expect(pickOllamaGemmaTag(['gemma3n:e4b'])).toBe(null);
+  });
+
+  test('$MAUDE_OLLAMA_MODEL wins verbatim', () => {
+    setEnv('MAUDE_OLLAMA_MODEL', 'gemma3:27b');
+    expect(pickOllamaGemmaTag(['gemma3:4b'])).toBe('gemma3:27b');
+  });
+});

package/apps/studio/test/hmr-broadcast.test.ts

@@ -3,7 +3,13 @@
 import { describe, expect, test } from 'bun:test';
 
 import { type Context, createBus } from '../context.ts';
-import { createHmrBroadcaster, HMR_DEBOUNCE_MS, type HmrMessage } from '../hmr-broadcast.ts';
+import {
+  createContainerWriteBridge,
+  createHmrBroadcaster,
+  HMR_DEBOUNCE_MS,
+  type HmrMessage,
+  SYNTHETIC_FS_DELAY_MS,
+} from '../hmr-broadcast.ts';
 
 function mkCtx(): Context {
   const bus = createBus();
@@ -150,3 +156,53 @@ describe('hmr-broadcast / stop', () => {
     expect(got).toHaveLength(0);
   });
 });
+
+describe('container write bridge — synthesises fs:any the container fs.watch misses', () => {
+  const collect = (ctx: Context) => {
+    const got: string[] = [];
+    ctx.bus.on('fs:any', (rel: string) => got.push(rel));
+    return got;
+  };
+
+  test('activity:suppress → a synthetic fs:any lands after the delay', async () => {
+    const ctx = mkCtx();
+    const got = collect(ctx);
+    const bridge = createContainerWriteBridge(ctx);
+    ctx.bus.emit('activity:suppress', 'ui/Home.tsx');
+    expect(got).toHaveLength(0); // not immediate — the write must settle first
+    await new Promise((r) => setTimeout(r, SYNTHETIC_FS_DELAY_MS + 30));
+    expect(got).toEqual(['ui/Home.tsx']);
+    bridge.stop();
+  });
+
+  test('a no-op / failed edit disarms via activity:unsuppress — no reload for peers', async () => {
+    const ctx = mkCtx();
+    const got = collect(ctx);
+    const bridge = createContainerWriteBridge(ctx);
+    ctx.bus.emit('activity:suppress', 'ui/Home.tsx');
+    ctx.bus.emit('activity:unsuppress', 'ui/Home.tsx'); // delta 0 / threw
+    await new Promise((r) => setTimeout(r, SYNTHETIC_FS_DELAY_MS + 30));
+    expect(got).toHaveLength(0);
+    bridge.stop();
+  });
+
+  test('backslash paths are normalised so they match the watcher/classifier shape', async () => {
+    const ctx = mkCtx();
+    const got = collect(ctx);
+    const bridge = createContainerWriteBridge(ctx);
+    ctx.bus.emit('activity:suppress', 'ui\\Home.tsx');
+    await new Promise((r) => setTimeout(r, SYNTHETIC_FS_DELAY_MS + 30));
+    expect(got).toEqual(['ui/Home.tsx']);
+    bridge.stop();
+  });
+
+  test('stop() cancels a pending emit', async () => {
+    const ctx = mkCtx();
+    const got = collect(ctx);
+    const bridge = createContainerWriteBridge(ctx);
+    ctx.bus.emit('activity:suppress', 'ui/Home.tsx');
+    bridge.stop();
+    await new Promise((r) => setTimeout(r, SYNTHETIC_FS_DELAY_MS + 30));
+    expect(got).toHaveLength(0);
+  });
+});

package/apps/studio/test/input-router.test.ts

@@ -7,8 +7,10 @@ import {
   classify,
   crossedDragThreshold,
   DRAG_THRESHOLD_PX,
+  isArtboardDragChrome,
   isEditableTarget,
   type Tool,
+  yieldsToArtboardDrag,
 } from '../input-router.tsx';
 
 const base = (over: Partial<ClassifyInput>): ClassifyInput => ({
@@ -457,6 +459,99 @@ describe('input-router / isEditableTarget', () => {
   });
 });
 
+// issue-71 — a bare (no-modifier) pointerdown/mousedown on an artboard's own
+// drag chrome (the label strip + border, OUTSIDE `.dc-artboard-body`) must
+// still be identified so useInputRouter can skip stopImmediatePropagation and
+// let use-artboard-drag.tsx's own bubble-phase onPointerDown arm its
+// pending→dragging state machine — otherwise no artboard could ever be
+// repositioned by dragging its header (the router's capture-phase claim
+// killed the event before it reached that listener).
+describe('input-router / isArtboardDragChrome', () => {
+  // `closest(sel)` here mimics Element.closest: return a truthy stub for any
+  // selector this fake node "matches" (is, or is a descendant of), null else.
+  const fakeTarget = (memberOf: string[]): EventTarget =>
+    ({
+      closest: (sel: string) => (memberOf.includes(sel) ? {} : null),
+    }) as unknown as EventTarget;
+
+  test('null target → false', () => {
+    expect(isArtboardDragChrome(null)).toBe(false);
+  });
+
+  test('target with no closest() (non-Element) → false', () => {
+    expect(isArtboardDragChrome({} as EventTarget)).toBe(false);
+  });
+
+  test('outside any artboard → false', () => {
+    expect(isArtboardDragChrome(fakeTarget([]))).toBe(false);
+  });
+
+  test('the label strip / border chrome (inside an artboard, not its body) → true', () => {
+    expect(isArtboardDragChrome(fakeTarget(['[data-dc-screen]']))).toBe(true);
+  });
+
+  test('inside .dc-artboard-body (the canvas content, not chrome) → false', () => {
+    expect(isArtboardDragChrome(fakeTarget(['[data-dc-screen]', '.dc-artboard-body']))).toBe(false);
+  });
+});
+
+// issue-71 — the actual regression: before this fix, useInputRouter's
+// pointerdown/mousedown handlers called `stopImmediatePropagation()` on EVERY
+// claimed action, including a bare click on an artboard's own drag chrome —
+// which killed the event before use-artboard-drag.tsx's bubble-phase
+// onPointerDown (bound to that same artboard) ever saw it, so dragging an
+// artboard by its header did nothing in either the Move or the (former)
+// always-select tool state. `yieldsToArtboardDrag` is the exact decision the
+// handlers now gate `stopImmediatePropagation` on.
+describe('input-router / yieldsToArtboardDrag', () => {
+  const chrome = (): EventTarget =>
+    ({
+      closest: (sel: string) => (sel === '[data-dc-screen]' ? {} : null),
+    }) as unknown as EventTarget;
+  const body = (): EventTarget => ({ closest: () => ({}) }) as unknown as EventTarget; // matches every selector, incl. .dc-artboard-body
+
+  test('bare click on artboard chrome (the reported bug) → true (let the drag hook see it)', () => {
+    const action = classify({ type: 'pointerdown', activeTool: 'move', button: 0 });
+    expect(yieldsToArtboardDrag(action, chrome(), { metaKey: false, ctrlKey: false })).toBe(true);
+  });
+
+  test('shift+click on artboard chrome (multi-select-and-drag) → true', () => {
+    const action = classify({
+      type: 'pointerdown',
+      activeTool: 'move',
+      button: 0,
+      shiftKey: true,
+    });
+    expect(yieldsToArtboardDrag(action, chrome(), { metaKey: false, ctrlKey: false })).toBe(true);
+  });
+
+  test('cmd+click on artboard chrome (deep-select, not a drag) → false', () => {
+    const action = classify({
+      type: 'pointerdown',
+      activeTool: 'move',
+      button: 0,
+      metaKey: true,
+    });
+    expect(yieldsToArtboardDrag(action, chrome(), { metaKey: true, ctrlKey: false })).toBe(false);
+  });
+
+  test('bare click on .dc-artboard-body content (not chrome) → false', () => {
+    const action = classify({ type: 'pointerdown', activeTool: 'move', button: 0 });
+    expect(yieldsToArtboardDrag(action, body(), { metaKey: false, ctrlKey: false })).toBe(false);
+  });
+
+  test('bare click outside any artboard → false (nothing to yield to)', () => {
+    const action = classify({ type: 'pointerdown', activeTool: 'move', button: 0 });
+    const outside = { closest: () => null } as unknown as EventTarget;
+    expect(yieldsToArtboardDrag(action, outside, { metaKey: false, ctrlKey: false })).toBe(false);
+  });
+
+  test('right-click (context-menu) on chrome → false — not a select at all', () => {
+    const action = classify({ type: 'pointerdown', activeTool: 'move', button: 2 });
+    expect(yieldsToArtboardDrag(action, chrome(), { metaKey: false, ctrlKey: false })).toBe(false);
+  });
+});
+
 // T25 — Drag-vs-click threshold. Centralized here so every drag-class gesture
 // (artboard drag, artboard marquee, element marquee, annotation pen/rect/etc.)
 // reads the same value. Microsoft Win32 SM_CXDRAG default + d3-drag convention.