@1agh/maude 0.30.0 → 0.31.0

package/apps/studio/test/acp-bridge.test.ts

@@ -0,0 +1,127 @@
+// End-to-end bridge test against a mock ACP agent (test/fixtures/mock-acp-agent.mjs)
+// so no real `claude` install is needed. Proves: spawn + handshake + streamed
+// update + turn completion, AND that ANTHROPIC_API_KEY never reaches the child
+// (DDR-123 guardrail #1, verified end-to-end — the mock echoes its own env).
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import { join } from 'node:path';
+
+import { AcpBridge } from '../acp/bridge.ts';
+import { probeAcpAvailability } from '../acp/probe.ts';
+
+const FIXTURE = join(import.meta.dir, 'fixtures', 'mock-acp-agent.mjs');
+const TEST_ENV_KEYS = [
+  'ANTHROPIC_API_KEY',
+  'MAUDE_ACP_ADAPTER_ENTRY',
+  'MAUDE_ACP_RUNTIME',
+  'MAUDE_CLAUDE_BIN',
+];
+
+afterEach(() => {
+  for (const key of TEST_ENV_KEYS) delete process.env[key];
+});
+
+describe('AcpBridge — round-trip + subscription guardrail', () => {
+  test('connects, streams an update, completes a turn, and scrubs ANTHROPIC_API_KEY', async () => {
+    process.env.ANTHROPIC_API_KEY = 'sk-must-be-scrubbed';
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath; // run the mock under this bun
+    process.env.MAUDE_CLAUDE_BIN = process.execPath; // satisfy the claude-present check
+
+    const updates: unknown[] = [];
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: (u) => updates.push(u) });
+    try {
+      const result = await bridge.prompt('hello', 'c1');
+      expect(bridge.connected).toBe(true);
+      expect(bridge.sessionId).toBe('mock-session-1');
+      expect(result.stopReason).toBe('end_turn');
+
+      // The mock streamed its own ANTHROPIC_API_KEY — it must read `<unset>`,
+      // proving scrubAgentEnv stripped it from the child env before spawn.
+      const streamed = JSON.stringify(updates);
+      expect(streamed).toContain('apiKey=<unset>');
+      expect(streamed).not.toContain('sk-must-be-scrubbed');
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('setConfig passes model + effort to the child env (ANTHROPIC_MODEL / MAX_THINKING_TOKENS)', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+
+    const updates: unknown[] = [];
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: (u) => updates.push(u) });
+    try {
+      bridge.setConfig('opus', 'thorough');
+      await bridge.prompt('hi', 'c1');
+      const first = JSON.stringify(updates);
+      expect(first).toContain('model=opus');
+      expect(first).toContain('thinking=31999');
+
+      // Changing the config re-spawns with the new env on the next prompt.
+      updates.length = 0;
+      bridge.setConfig(null, 'fast');
+      await bridge.prompt('again', 'c1');
+      const second = JSON.stringify(updates);
+      expect(second).toContain('model=<unset>'); // null model → ANTHROPIC_MODEL not set
+      expect(second).toContain('thinking=0'); // fast → thinking disabled
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('a second prompt reuses the same live session', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
+    try {
+      await bridge.prompt('first', 'c1');
+      const sid = bridge.sessionId;
+      await bridge.prompt('second', 'c1');
+      expect(bridge.sessionId).toBe(sid);
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+
+  test('different chat ids get separate claude sessions; same id reuses its own', async () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_ACP_RUNTIME = process.execPath;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+
+    const bridge = new AcpBridge({ repoRoot: process.cwd(), onUpdate: () => {} });
+    try {
+      await bridge.prompt('a', 'chatA');
+      const sa = bridge.sessionId;
+      await bridge.prompt('b', 'chatB');
+      const sb = bridge.sessionId;
+      expect(sa).not.toBe(sb); // separate per-chat contexts
+      await bridge.prompt('a again', 'chatA');
+      expect(bridge.sessionId).toBe(sa); // chatA reuses its own session
+    } finally {
+      await bridge.stop();
+    }
+  }, 15000);
+});
+
+describe('probeAcpAvailability — not-connected detection', () => {
+  test('reports not-available with a Claude-Code reason when the CLI is absent', () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_CLAUDE_BIN = join(import.meta.dir, 'no-such-claude-bin');
+    const probe = probeAcpAvailability();
+    expect(probe.available).toBe(false);
+    expect(probe.reason ?? '').toMatch(/Claude Code/i);
+  });
+
+  test('reports available when both the adapter and a claude binary resolve', () => {
+    process.env.MAUDE_ACP_ADAPTER_ENTRY = FIXTURE;
+    process.env.MAUDE_CLAUDE_BIN = process.execPath;
+    const probe = probeAcpAvailability();
+    expect(probe.available).toBe(true);
+    expect(probe.adapterEntry).toBe(FIXTURE);
+  });
+});

package/apps/studio/test/acp-env.test.ts

@@ -0,0 +1,65 @@
+// DDR-123 guardrail #1 — the single load-bearing detail that keeps the chat
+// panel on the user's Pro/Max subscription instead of metered API billing.
+
+import { describe, expect, test } from 'bun:test';
+
+import { SUBSCRIPTION_SCRUBBED_ENV_KEYS, scrubAgentEnv } from '../acp/env.ts';
+
+describe('scrubAgentEnv — subscription guardrail', () => {
+  test('strips the billing-switching keys, keeps everything else', () => {
+    const out = scrubAgentEnv({
+      PATH: '/usr/bin',
+      HOME: '/Users/x',
+      ANTHROPIC_API_KEY: 'sk-live-xxx',
+      ANTHROPIC_AUTH_TOKEN: 'tok-xxx',
+      UNDEFINED_VAR: undefined,
+    });
+    expect(out.PATH).toBe('/usr/bin');
+    expect(out.HOME).toBe('/Users/x');
+    expect('ANTHROPIC_API_KEY' in out).toBe(false);
+    expect('ANTHROPIC_AUTH_TOKEN' in out).toBe(false);
+    // undefined values are dropped (Bun.spawn env wants Record<string,string>)
+    expect('UNDEFINED_VAR' in out).toBe(false);
+  });
+
+  test('pins exactly the two precedence-relevant keys', () => {
+    expect([...SUBSCRIPTION_SCRUBBED_ENV_KEYS].sort()).toEqual([
+      'ANTHROPIC_API_KEY',
+      'ANTHROPIC_AUTH_TOKEN',
+    ]);
+  });
+
+  test('scrubs the whole provider/billing namespace, not just the two keys (F1)', () => {
+    const out = scrubAgentEnv({
+      PATH: '/usr/bin',
+      ANTHROPIC_BASE_URL: 'https://evil.example/v1',
+      ANTHROPIC_MODEL: 'attacker-pinned',
+      ANTHROPIC_BEDROCK_BASE_URL: 'https://evil',
+      CLAUDE_CODE_USE_BEDROCK: '1',
+      CLAUDE_CODE_USE_VERTEX: '1',
+      AWS_BEARER_TOKEN_BEDROCK: 'tok',
+      claude_session: 'keep-me', // not a provider redirect → kept
+    });
+    expect(out.PATH).toBe('/usr/bin');
+    expect('ANTHROPIC_BASE_URL' in out).toBe(false);
+    expect('ANTHROPIC_MODEL' in out).toBe(false); // re-added by the bridge from a validated value
+    expect('ANTHROPIC_BEDROCK_BASE_URL' in out).toBe(false);
+    expect('CLAUDE_CODE_USE_BEDROCK' in out).toBe(false);
+    expect('CLAUDE_CODE_USE_VERTEX' in out).toBe(false);
+    expect('AWS_BEARER_TOKEN_BEDROCK' in out).toBe(false);
+    expect(out.claude_session).toBe('keep-me');
+  });
+
+  test('never mutates the source (process.env stays intact for the parent)', () => {
+    const src: Record<string, string | undefined> = { ANTHROPIC_API_KEY: 'sk', PATH: '/bin' };
+    const out = scrubAgentEnv(src);
+    expect(src.ANTHROPIC_API_KEY).toBe('sk');
+    expect(out).not.toBe(src);
+  });
+
+  test('defaults to process.env when called with no argument', () => {
+    // Smoke: doesn't throw, returns a string map without the scrubbed keys.
+    const out = scrubAgentEnv();
+    expect('ANTHROPIC_API_KEY' in out).toBe(false);
+  });
+});

package/apps/studio/test/acp-origin-gate.test.ts

@@ -0,0 +1,78 @@
+// ACP bridge origin gate (DDR-123). The agent bridge spawns the user's `claude`
+// and can drive file edits, so it lives ONLY on the main (privileged) origin and
+// only over loopback. This proves:
+//   (1) GET /_api/acp/status serves on the main origin;
+//   (2) it is 403'd on the untrusted canvas origin (off CANVAS_SAFE_API +
+//       startCanvasServer routes — the dual-allowlist rule);
+//   (3) /_ws/acp is wired on the main origin (upgrade-without-headers → 400);
+//   (4) the loopback guard that fronts /_ws/acp rejects non-loopback hosts.
+
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { isLoopbackHost } from '../ws.ts';
+import { bootServer, killProc, makeSandbox, nextPort } from './_helpers.ts';
+
+async function readCanvasOrigin(designRoot: string): Promise<string> {
+  for (let i = 0; i < 40; i++) {
+    try {
+      const info = JSON.parse(readFileSync(join(designRoot, '_server.json'), 'utf8'));
+      if (info.canvasOrigin) return info.canvasOrigin as string;
+    } catch {
+      /* not written yet */
+    }
+    await Bun.sleep(50);
+  }
+  throw new Error('canvasOrigin never appeared in _server.json');
+}
+
+describe('ACP bridge origin gate', () => {
+  test('status is main-origin only; /_ws/acp wired on main', async () => {
+    const { root, designRoot } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port, { MAUDE_CANVAS_ORIGIN_SPLIT: '1' });
+    try {
+      const main = `http://localhost:${port}`;
+      const canvas = await readCanvasOrigin(designRoot);
+      const status = async (base: string, path: string) =>
+        (await fetch(base + path, { signal: AbortSignal.timeout(2000) })).status;
+
+      // (1) main origin exposes the readiness probe
+      const probe = await fetch(`${main}/_api/acp/status`, { signal: AbortSignal.timeout(2000) });
+      expect(probe.status).toBe(200);
+      expect(typeof (await probe.json()).available).toBe('boolean');
+
+      // (2) the untrusted canvas origin must NOT reach the probe
+      expect(await status(canvas, '/_api/acp/status')).toBe(403);
+
+      // (3) /_ws/acp is wired on the main origin — a plain GET (no Upgrade
+      // headers) passes the loopback guard then fails the WS upgrade → 400,
+      // which proves the route branch exists (a 404 would mean it's unwired).
+      expect(await status(main, '/_ws/acp')).toBe(400);
+
+      // (4) /_api/acp/focus (the /design:chat hook) — POST-only on the main
+      // origin, 403 on the canvas origin.
+      const focusPost = await fetch(`${main}/_api/acp/focus`, {
+        method: 'POST',
+        signal: AbortSignal.timeout(2000),
+      });
+      expect(focusPost.status).toBe(200);
+      expect((await focusPost.json()).ok).toBe(true);
+      expect(await status(main, '/_api/acp/focus')).toBe(405); // GET not allowed
+      expect(await status(canvas, '/_api/acp/focus')).toBe(403); // off the canvas origin
+    } finally {
+      await killProc(proc);
+    }
+  }, 15000);
+
+  test('the loopback guard fronting /_ws/acp rejects non-loopback hosts', () => {
+    // Same guard server.ts applies before upgrading the acp socket.
+    expect(isLoopbackHost('127.0.0.1:4399')).toBe(true);
+    expect(isLoopbackHost('localhost:4399')).toBe(true);
+    expect(isLoopbackHost('[::1]:4399')).toBe(true);
+    expect(isLoopbackHost('evil.example.com')).toBe(false);
+    expect(isLoopbackHost('10.0.0.5:4399')).toBe(false);
+    expect(isLoopbackHost(null)).toBe(false);
+  });
+});

package/apps/studio/test/acp-transcript.test.ts

@@ -0,0 +1,112 @@
+// acp/transcript — repo-level chat list + raw-transcript → clean-messages.
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { deleteChat, listChats, readChatMessages } from '../acp/transcript.ts';
+
+let root: string;
+afterEach(() => {
+  if (root) rmSync(root, { recursive: true, force: true });
+});
+
+function seed(chatId: string, lines: object[]): string {
+  root = mkdtempSync(join(tmpdir(), 'acp-tx-'));
+  const dir = join(root, '_chat');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${chatId}.jsonl`), lines.map((l) => JSON.stringify(l)).join('\n'));
+  return root;
+}
+
+describe('readChatMessages — raw → clean turns', () => {
+  test('aggregates agent updates into one assistant message; drops noise', () => {
+    const designRoot = seed('c1', [
+      { ts: 1, role: 'user', text: 'make the button red' },
+      {
+        ts: 2,
+        role: 'agent',
+        update: { sessionUpdate: 'available_commands_update', availableCommands: [] },
+      },
+      {
+        ts: 3,
+        role: 'agent',
+        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Sure, ' } },
+      },
+      {
+        ts: 4,
+        role: 'agent',
+        update: {
+          sessionUpdate: 'tool_call',
+          toolCallId: 't1',
+          title: 'Edit Button.tsx',
+          kind: 'edit',
+          status: 'pending',
+        },
+      },
+      {
+        ts: 5,
+        role: 'agent',
+        update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'done.' } },
+      },
+      {
+        ts: 6,
+        role: 'agent',
+        update: { sessionUpdate: 'tool_call_update', toolCallId: 't1', status: 'completed' },
+      },
+      { ts: 7, role: 'agent', update: { sessionUpdate: 'usage_update', used: 10 } },
+      { ts: 8, role: 'stop', stopReason: 'end_turn' },
+    ]);
+
+    const msgs = readChatMessages(designRoot, 'c1');
+    expect(msgs.length).toBe(2);
+    expect(msgs[0]).toEqual({
+      role: 'user',
+      parts: [{ type: 'text', text: 'make the button red' }],
+    });
+    expect(msgs[1].role).toBe('assistant');
+    // text parts merged across the tool call boundary order-preserving
+    const texts = msgs[1].parts.filter((p) => p.type === 'text').map((p) => p.text);
+    expect(texts.join('')).toBe('Sure, done.');
+    const tool = msgs[1].parts.find((p) => p.type === 'tool');
+    expect(tool?.toolName).toBe('Edit Button.tsx');
+    expect(tool?.done).toBe(true);
+    // noise (available_commands_update / usage_update) is not rendered
+    expect(JSON.stringify(msgs)).not.toContain('availableCommands');
+    expect(JSON.stringify(msgs)).not.toContain('usage');
+  });
+
+  test('missing chat → empty', () => {
+    const designRoot = seed('c1', [{ ts: 1, role: 'user', text: 'hi' }]);
+    expect(readChatMessages(designRoot, 'nope')).toEqual([]);
+  });
+});
+
+describe('listChats', () => {
+  test('lists chats with a title derived from the first user line', () => {
+    const designRoot = seed('chat-7', [
+      { ts: 1, role: 'user', text: 'redesign the pricing page please' },
+      { ts: 2, role: 'stop', stopReason: 'end_turn' },
+    ]);
+    const chats = listChats(designRoot);
+    expect(chats.length).toBe(1);
+    expect(chats[0].id).toBe('chat-7');
+    expect(chats[0].title).toBe('redesign the pricing page please');
+  });
+
+  test('no _chat dir → empty', () => {
+    root = mkdtempSync(join(tmpdir(), 'acp-tx-'));
+    expect(listChats(root)).toEqual([]);
+  });
+});
+
+describe('deleteChat', () => {
+  test('removes the transcript; missing → false', () => {
+    const designRoot = seed('gone', [{ ts: 1, role: 'user', text: 'bye' }]);
+    expect(listChats(designRoot).length).toBe(1);
+    expect(deleteChat(designRoot, 'gone')).toBe(true);
+    expect(listChats(designRoot).length).toBe(0);
+    expect(deleteChat(designRoot, 'gone')).toBe(false);
+  });
+});

package/apps/studio/test/canvas-create-api.test.ts

@@ -122,6 +122,71 @@ describe('/_api/canvas — POST round-trip', () => {
     }
   });
 
+  test('create + delete emit canvas-list-update over the inspector WS (Phase 30)', async () => {
+    const { root } = makeSandbox();
+    const port = nextPort();
+    const proc = await bootServer(root, port);
+    let socket: WebSocket | null = null;
+    try {
+      const messages: Array<{ type: string; payload?: { action?: string; slug?: string } }> = [];
+      const sock = new WebSocket(`ws://localhost:${port}/_ws`);
+      socket = sock;
+      await new Promise<void>((res, rej) => {
+        sock.addEventListener('open', () => res());
+        sock.addEventListener('error', () => rej(new Error('ws error')));
+        setTimeout(() => rej(new Error('ws open timeout')), 2000);
+      });
+      sock.addEventListener('message', (ev) => {
+        try {
+          messages.push(JSON.parse(String(ev.data)));
+        } catch {
+          /* ignore non-JSON */
+        }
+      });
+
+      const waitFor = async (pred: (m: (typeof messages)[number]) => boolean) => {
+        const deadline = Date.now() + 2000;
+        while (Date.now() < deadline) {
+          const hit = messages.find(pred);
+          if (hit) return hit;
+          await Bun.sleep(25);
+        }
+        return undefined;
+      };
+
+      const created = await fetch(`http://localhost:${port}/_api/canvas`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'Live Add', kind: 'brief-board' }),
+      });
+      expect(created.status).toBe(201);
+      const cj = (await created.json()) as { rel: string };
+
+      const added = await waitFor(
+        (m) => m.type === 'canvas-list-update' && m.payload?.action === 'added'
+      );
+      expect(added?.payload?.slug).toBe('ui-live_add');
+
+      const del = await fetch(
+        `http://localhost:${port}/_api/canvas?file=${encodeURIComponent(cj.rel)}`,
+        { method: 'DELETE' }
+      );
+      expect(del.status).toBe(200);
+
+      const removed = await waitFor(
+        (m) => m.type === 'canvas-list-update' && m.payload?.action === 'removed'
+      );
+      expect(removed?.payload?.slug).toBe('ui-live_add');
+    } finally {
+      try {
+        socket?.close();
+      } catch {
+        /* ignore */
+      }
+      await killProc(proc);
+    }
+  }, 10_000);
+
   test('defaults kind to brief-board when omitted', async () => {
     const { root } = makeSandbox();
     const port = nextPort();
@@ -284,6 +349,10 @@ describe('/_api/canvas — DELETE (soft-delete)', () => {
         join(designRoot, `${created.slug}.annotations.svg`),
         '<svg xmlns="http://www.w3.org/2000/svg" data-mdcc-annotations="1"></svg>'
       );
+      // Seed the per-machine camera view file (DDR-115) to prove it's swept too.
+      mkdirSync(join(designRoot, '_canvas-state'), { recursive: true });
+      const viewAbs = join(designRoot, '_canvas-state', `${created.slug}.view.json`);
+      writeFileSync(viewAbs, JSON.stringify({ viewport: { x: 1, y: 2, zoom: 1 } }));
       const tsx = join(designRoot, 'ui', 'Trash Me.tsx');
       expect(existsSync(tsx)).toBe(true);
 
@@ -293,14 +362,17 @@ describe('/_api/canvas — DELETE (soft-delete)', () => {
       expect(j.ok).toBe(true);
       expect(j.trashed.some((t) => t.endsWith('Trash Me.tsx'))).toBe(true);
       expect(j.trashed.some((t) => t.endsWith('.annotations.svg'))).toBe(true);
+      expect(j.trashed.some((t) => t.endsWith('.view.json'))).toBe(true);
 
       // Gone from the group; present (recoverable) under _trash/ with a manifest.
       expect(existsSync(tsx)).toBe(false);
       expect(existsSync(join(designRoot, `${created.slug}.annotations.svg`))).toBe(false);
+      expect(existsSync(viewAbs)).toBe(false);
       const trashDirs = readdirSync(join(designRoot, '_trash'));
       expect(trashDirs.length).toBe(1);
       const td = join(designRoot, '_trash', trashDirs[0] as string);
       expect(existsSync(join(td, 'Trash Me.tsx'))).toBe(true);
+      expect(existsSync(join(td, `_canvas-state__${created.slug}.view.json`))).toBe(true);
       expect(existsSync(join(td, '_trash-manifest.json'))).toBe(true);
     } finally {
       await killProc(proc);