@1agh/maude 0.55.0 → 0.57.0

package/apps/studio/test/cloud-connect-note.test.ts

@@ -0,0 +1,135 @@
+// The sentence a person reads after pressing Connect.
+//
+// It used to be computed once, from the ATTACH RESPONSE, at the instant the
+// confirm dialog closed — and never again. The attach response reports an
+// intention (`{ syncing: true }` means `runtime.start()` did not throw and one
+// local canvas qualified), so the sentence claimed success before a socket
+// existed and then sat there through every outcome, including total failure.
+//
+// These cases are one per row of the plan's states/copy table, plus the two
+// degradations that must never take the note away entirely: no live payload,
+// and a payload from a server that predates the counts.
+
+import { describe, expect, test } from 'bun:test';
+
+import { connectOutcomeNote } from '../client/panels/CloudBar.jsx';
+import type { SyncStatusLike } from '../sync/presentation.ts';
+
+const live = (over: SyncStatusLike): SyncStatusLike => ({
+  state: 'online',
+  queuedOps: 0,
+  lastSyncAt: null,
+  offlineSince: null,
+  flash: null,
+  updatedAt: 0,
+  ...over,
+});
+
+const started = { syncing: true, canvases: 75 };
+
+describe('with a live payload — the sentence moves', () => {
+  test('connecting: nothing has settled yet, and it does not pretend otherwise', () => {
+    const n = connectOutcomeNote(
+      'alligators',
+      started,
+      live({ state: 'connecting', docs: { synced: 0, pending: 75, rejected: 0 } })
+    );
+    expect(n.text).toContain('Connecting to alligators');
+    expect(n.text).not.toContain('Synced');
+  });
+
+  test('syncing: real progress, drawn from settled handshakes', () => {
+    const n = connectOutcomeNote(
+      'alligators',
+      started,
+      live({ docs: { synced: 40, pending: 35, rejected: 0 } })
+    );
+    expect(n.text).toContain('40 of 75');
+  });
+
+  test('synced: names what arrived and tells the person to go open it', () => {
+    const n = connectOutcomeNote(
+      'alligators',
+      started,
+      live({
+        docs: { synced: 75, pending: 0, rejected: 0 },
+        pulled: { names: ['ui-welcome'], count: 3 },
+      })
+    );
+    expect(n.text).toContain('Synced with alligators');
+    expect(n.text).toContain('3 came down');
+    // Deliberately not an imperative to open it: a pulled canvas is hub-authored
+    // TSX, and "open this" inside our own green success sentence is the
+    // strongest endorsement we could give content we do not vouch for.
+    expect(n.title).toContain('new to this machine');
+    expect(n.title).not.toContain('Open one');
+  });
+
+  test('refused: the state that cannot fix itself says so, and says what to do', () => {
+    // The reported shape, at its worst: the attach response says syncing, the
+    // socket is up, and every single document is going nowhere.
+    const n = connectOutcomeNote(
+      'alligators',
+      started,
+      live({ state: 'online', docs: { synced: 0, pending: 0, rejected: 75 } })
+    );
+    expect(n.text).toContain('refused');
+    expect(n.title).toContain('Reconnect');
+  });
+
+  test('unreachable: queued, not lost — and explicitly nothing to do', () => {
+    const n = connectOutcomeNote(
+      'alligators',
+      started,
+      live({ state: 'offline', queuedOps: 2, docs: { synced: 75, pending: 0, rejected: 0 } })
+    );
+    expect(n.text).toContain('Not reachable');
+    expect(n.text).toContain('queued');
+    expect(n.title).toContain('resumes by itself');
+  });
+
+  test('the live payload beats the attach response, not the other way round', () => {
+    // `sync.syncing` is true here and the link is in fact dead. Whichever wins
+    // decides whether this whole change did anything.
+    const n = connectOutcomeNote('alligators', started, live({ state: 'offline' }));
+    expect(n.text).toContain('Not reachable');
+  });
+});
+
+describe('without a live payload — degrade, never vanish', () => {
+  test('first render falls back to the attach response, phrased as in-flight', () => {
+    const n = connectOutcomeNote('alligators', started, undefined);
+    expect(n.text).toContain('Connecting to alligators');
+    expect(n.text).toContain('75 canvases');
+  });
+
+  test('an unlinked live payload does not swallow the note', () => {
+    // `syncPresentation` returns null for `{linked:false}`; the note must fall
+    // through to the attach response rather than render nothing at all.
+    const n = connectOutcomeNote('alligators', started, { linked: false });
+    expect(n.text).toContain('alligators');
+  });
+
+  test('nothing syncable keeps its own copy', () => {
+    const n = connectOutcomeNote('alligators', {
+      syncing: false,
+      reason: 'nothing-syncable',
+      detail: 'No canvases in this project are syncable yet.',
+    });
+    expect(n.text).toContain('nothing to sync yet');
+  });
+
+  test('a failed start reports the reason it was given', () => {
+    const n = connectOutcomeNote('alligators', {
+      syncing: false,
+      reason: 'error',
+      detail: 'Syncing could not start: hub refused the handshake',
+    });
+    expect(n.text).toContain('hub refused the handshake');
+  });
+
+  test('a missing project name never renders as undefined', () => {
+    const n = connectOutcomeNote(null, started, undefined);
+    expect(n.text).toContain('the workspace');
+  });
+});

package/apps/studio/test/cloud-endpoints.test.ts

@@ -10,6 +10,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import {
+  connectOutcomeNote,
   isDisplayableUrl,
   localIdentityHint,
   parseDeepLink,
@@ -322,6 +323,48 @@ describe('localIdentityHint — only an exact, corroborated agreement is silent'
   });
 });
 
+describe('connectOutcomeNote — what the rail says after Connect', () => {
+  test('no live payload yet: an in-flight state, not a claimed result', () => {
+    // This used to assert "Syncing with alligators — 12 canvases." and a hover
+    // pointing at the status bar. Both were wrong: the attach response reports
+    // that `runtime.start()` did not throw, which is an INTENTION, and the slot
+    // it sent people to was itself keying off `state` alone. See DDR-214 — the
+    // sentence now derives from the live payload, and this is only the fallback
+    // for the first render (and for a server too old to send one.)
+    const n = connectOutcomeNote('alligators', { syncing: true, canvases: 12 });
+    expect(n.text).toBe('Connecting to alligators — 12 canvases…');
+    expect(n.title).toContain('updates as they settle');
+    expect(n.text).not.toContain('hub sync');
+    expect(connectOutcomeNote('alligators', { syncing: true, canvases: 1 }).text).toContain(
+      '1 canvas…'
+    );
+  });
+
+  test('linked but nothing syncable says so — and never claims a restart would help', () => {
+    const n = connectOutcomeNote('alligators', {
+      syncing: false,
+      canvases: 0,
+      reason: 'nothing-syncable',
+      detail: 'no canvases found under .design.',
+    });
+    expect(n.text).toBe('Connected to alligators — nothing to sync yet.');
+    expect(n.title).toContain('no canvases found');
+    expect(n.text).not.toMatch(/restart/i);
+  });
+
+  test('any other refusal repeats the server’s own reason', () => {
+    const n = connectOutcomeNote('alligators', {
+      syncing: false,
+      canvases: 0,
+      reason: 'no-credential',
+      detail: 'No sign-in for this workspace is stored on this machine yet.',
+    });
+    expect(n.text).toContain('No sign-in for this workspace');
+    // Never the old sentence: there is no studio server a person can see.
+    expect(n.text).not.toContain('studio server');
+  });
+});
+
 describe('attachCode — the maude:// lane end to end (stubbed)', () => {
   test('a valid code links: hub credential stored, linkedHub written token-free', async () => {
     const { createCloudEndpoints } = await import('../cloud/endpoints.ts');
@@ -375,6 +418,65 @@ describe('attachCode — the maude:// lane end to end (stubbed)', () => {
     expect(r.status).toBe(200);
   });
 
+  test('linking STARTS syncing — the outcome is reported, not homework', async () => {
+    // The bug this closes: the panel used to answer a successful Connect with
+    // "restart the studio server to start syncing" — a task, naming a thing
+    // the desktop user cannot see. The attach lane now cycles the runtime and
+    // reports what happened.
+    const { createCloudEndpoints } = await import('../cloud/endpoints.ts');
+    const designRoot = join(scratch, '.design-sync');
+    const { mkdirSync } = await import('node:fs');
+    mkdirSync(designRoot, { recursive: true });
+    writeFileSync(join(designRoot, 'config.json'), '{}\n');
+
+    const handed: unknown[] = [];
+    const apiEndpoints = createCloudEndpoints({
+      paths: { repoRoot: scratch, designRoot },
+      syncControl: {
+        restart: async (linkedHub) => {
+          handed.push(linkedHub);
+          return { syncing: true, canvases: 4 };
+        },
+      },
+    });
+    const r = await apiEndpoints.attachCode(`mhc_${'a'.repeat(64)}`);
+    expect(r.status).toBe(200);
+    expect((r.json as any).sync).toEqual({ syncing: true, canvases: 4 });
+    expect((r.json as any).note).toBe('Linked — syncing 4 canvases.');
+
+    // The supervisor is handed the value BY VALUE — the same object written to
+    // config.json — so nothing that touches that committed file in between can
+    // steer the socket.
+    const cfg = JSON.parse(readFileSync(join(designRoot, 'config.json'), 'utf8'));
+    expect(handed).toEqual([cfg.linkedHub]);
+  });
+
+  test('a TSX opt-out survives a re-link — only the restrictive direction carries', async () => {
+    // `syncTsx: false` means "do not upload canvas bodies to this hub"
+    // (DDR-072/DDR-079). Re-linking used to overwrite linkedHub wholesale,
+    // which silently re-enabled it — harmless while nothing synced until a
+    // restart, a real disclosure now that Connect starts syncing immediately.
+    const { createCloudEndpoints } = await import('../cloud/endpoints.ts');
+    const designRoot = join(scratch, '.design-opt-out');
+    const { mkdirSync } = await import('node:fs');
+    mkdirSync(designRoot, { recursive: true });
+    writeFileSync(
+      join(designRoot, 'config.json'),
+      JSON.stringify({ linkedHub: { url: 'https://old.example', linkedAt: 1, syncTsx: false } })
+    );
+
+    const apiEndpoints = createCloudEndpoints({ paths: { repoRoot: scratch, designRoot } });
+    const r = await apiEndpoints.attachCode(`mhc_${'a'.repeat(64)}`);
+    expect(r.status).toBe(200);
+    const cfg = JSON.parse(readFileSync(join(designRoot, 'config.json'), 'utf8'));
+    expect(cfg.linkedHub.syncTsx).toBe(false);
+    expect(cfg.linkedHub.url).toContain('127.0.0.1');
+    // No supervisor wired (a plain embedder): still linked, and the note says
+    // what is left to do instead of claiming success.
+    expect((r.json as any).sync.syncing).toBe(false);
+    expect((r.json as any).note).toMatch(/Restart Maude/);
+  });
+
   test('a malformed or dead code never reaches the network', async () => {
     const { createCloudEndpoints } = await import('../cloud/endpoints.ts');
     const apiEndpoints = createCloudEndpoints({

package/apps/studio/test/cloud-shell-surfaces.test.ts

@@ -64,8 +64,11 @@ describe('the cloud shell offers nothing it cannot honour', () => {
     // `=== null`, not falsiness. `cloud` is undefined until `/_config` answers,
     // and treating unknown as "not cloud" mounted this bar for one frame in
     // every cloud tab — long enough to fire the one request the cell refuses.
-    expect(APP).toContain('{cloud === null ? <CloudBar /> : null}');
-    expect(APP).not.toContain('{cloud ? null : <CloudBar />}');
+    // Matched on the GUARD rather than the whole element, so adding a prop to
+    // CloudBar (DDR-214 drilled the live sync payload in) does not read as a
+    // regression in a rule that is entirely about `=== null`.
+    expect(APP).toMatch(/\{cloud === null \? <CloudBar[^>]*\/> : null\}/);
+    expect(APP).not.toMatch(/\{cloud \? null : <CloudBar/);
   });
 
   test('the local export queue does not hydrate before the shell is known', () => {

package/apps/studio/test/csrf-write-guard.test.ts

@@ -36,14 +36,31 @@ describe('CSRF Origin guard — sameOriginWrite (DDR-105)', () => {
     expect(sameOriginWrite(post('http://localhost:4399.evil.example'))).toBe(false);
     // Right host, wrong port is still cross-origin.
     expect(sameOriginWrite(post('http://localhost:4400'))).toBe(false);
-    // Right host:port, wrong scheme is still cross-origin.
-    expect(sameOriginWrite(post('https://localhost:4399'))).toBe(false);
   });
 
   test('allows the legit same-origin shell Origin', () => {
     expect(sameOriginWrite(post(SELF))).toBe(true);
   });
 
+  test('a matching host on a different SCHEME is same-origin — TLS terminates at the cell proxy', () => {
+    // The second half of the inspector-edits RCA. In a cell the browser sends
+    // `https://<host>` but the studio serves plaintext and computes `req.url` as
+    // `http://<host>`, so a scheme-strict compare 403'd every legitimate shell
+    // write. Host+port still pins it; a cross-site page has a different host.
+    const cell = 'https://alligators.cloud.maude.sh';
+    const cellReq = (origin?: string) =>
+      new Request('http://alligators.cloud.maude.sh/_api/edit-css', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', ...(origin ? { origin } : {}) },
+        body: '{}',
+      });
+    expect(sameOriginWrite(cellReq(cell))).toBe(true); // https Origin ↔ http req.url, same host
+    // But a genuinely different host is still rejected, scheme notwithstanding.
+    expect(sameOriginWrite(cellReq('https://evil.cloud.maude.sh'))).toBe(false);
+    // And the port still discriminates when present.
+    expect(sameOriginWrite(post('https://localhost:4400'))).toBe(false);
+  });
+
   test('allows a request with no Origin header (curl / programmatic / bun:test)', () => {
     expect(sameOriginWrite(post())).toBe(true);
   });

package/apps/studio/test/fixtures/mock-acp-agent-slow.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env bun
+// A mock ACP agent that streams SEVERAL updates with a gap between them, so a
+// test can close the socket MID-turn and assert the turn still completes
+// (feature-acp-write-path-scope Addendum, Task 8 — bridges outlive their socket).
+//
+// The pacing is the whole point: `mock-acp-agent-permission.mjs` and friends
+// settle in one tick, which leaves no window in which "mid-turn" is a real
+// state. Six chunks at ~120 ms give a test room to observe the first one, yank
+// the socket, and still have the rest arrive with nobody attached.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+const CHUNKS = Number(process.env.MAUDE_TEST_SLOW_CHUNKS || 6);
+const GAP_MS = Number(process.env.MAUDE_TEST_SLOW_GAP_MS || 120);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-slow' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-slow-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    for (let i = 0; i < CHUNKS; i++) {
+      await ctx.client.notify('session/update', {
+        sessionId: ctx.params.sessionId,
+        update: {
+          sessionUpdate: 'agent_message_chunk',
+          // Numbered so a test can tell WHICH chunks it received, not just how
+          // many — the difference between "no duplicates" and "no gaps".
+          content: { type: 'text', text: `chunk-${i}\n` },
+        },
+      });
+      await sleep(GAP_MS);
+    }
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);

package/apps/studio/test/fixtures/mock-acp-agent-write.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env bun
+// feature-acp-write-path-scope Task 1 — the RECORDED SHAPE of a write tool's
+// permission request, replayed as a mock ACP agent.
+//
+// This is not an invented shape. It reproduces, field for field, what
+// `@agentclientprotocol/claude-agent-acp@0.57.0` actually puts on the wire for
+// `Write`/`Edit`/`NotebookEdit`, read out of its own `dist/` on 2026-08-07:
+//
+//   • `dist/acp-agent.js:2270-2286` builds the permission request's `toolCall`
+//     as `{ toolCallId, rawInput, ...toolInfoFromToolUse(name, input, id) }` —
+//     note there is NO tool NAME anywhere in that object.
+//   • `dist/tools.js` `case "Write"` / `case "Edit"` set
+//     `locations: input?.file_path ? [{ path: input.file_path }] : []` — the
+//     model's string VERBATIM. No normalization, no absolutization, despite the
+//     ACP schema (`types.gen.d.ts:568-572`) describing the field as "The
+//     absolute file path being accessed or modified".
+//   • `NotebookEdit` has NO case at all — it falls through to `case "Other"`,
+//     which emits no `locations` whatsoever. Its target lives only on
+//     `rawInput.notebook_path`.
+//   • `dist/acp-agent.js:3808-3829` (`toolCallNotification`) is the ONLY carrier
+//     of the tool name: `_meta.claudeCode.toolName` on the streamed `tool_call`.
+//   • `requestPermissionFromClient` (`:2134-2141`) AWAITS `ensureToolCallEmitted`
+//     before issuing the request, so that notification is guaranteed to be on
+//     the wire FIRST. The bridge's gate depends on exactly that ordering, so the
+//     fixture reproduces it rather than assuming it.
+//
+// Driven by env so one fixture covers every case:
+//   MAUDE_TEST_WRITE_PATH  — the `file_path` the "model" emitted (required)
+//   MAUDE_TEST_WRITE_TOOL  — Write (default) | Edit | NotebookEdit | Read
+//   MAUDE_TEST_OMIT_TOOL_CALL=1 — skip the `tool_call` notification, i.e.
+//        simulate an adapter that reorders or drops it. The gate must fail
+//        CLOSED here (prompt), never auto-approve.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+const TOOL = process.env.MAUDE_TEST_WRITE_TOOL || 'Write';
+const FILE_PATH = process.env.MAUDE_TEST_WRITE_PATH || '/tmp/unset';
+const OMIT_TOOL_CALL = process.env.MAUDE_TEST_OMIT_TOOL_CALL === '1';
+const TOOL_CALL_ID = 'tc-write-1';
+
+// Mirrors `toolInfoFromToolUse`'s per-tool branches. NotebookEdit deliberately
+// yields NO `locations` key — that is the adapter's real behaviour, and the case
+// that makes the rawInput fallback mandatory rather than decorative.
+function toolInfo() {
+  if (TOOL === 'NotebookEdit') {
+    return { title: 'NotebookEdit', kind: 'other', content: [] };
+  }
+  if (TOOL === 'Read') {
+    return {
+      title: `Read ${FILE_PATH}`,
+      kind: 'read',
+      content: [],
+      locations: [{ path: FILE_PATH, line: 1 }],
+    };
+  }
+  return {
+    title: `${TOOL} ${FILE_PATH}`,
+    kind: 'edit',
+    content: [],
+    locations: [{ path: FILE_PATH }],
+  };
+}
+
+function rawInput() {
+  if (TOOL === 'NotebookEdit') return { notebook_path: FILE_PATH, new_source: 'x' };
+  if (TOOL === 'Write') return { file_path: FILE_PATH, content: 'x' };
+  if (TOOL === 'Read') return { file_path: FILE_PATH };
+  return { file_path: FILE_PATH, old_string: 'a', new_string: 'b' };
+}
+
+acp
+  .agent({ name: 'mock-acp-agent-write' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: 'mock-write-session-1' }))
+  .onRequest('session/prompt', async (ctx) => {
+    // (1) The `tool_call` notification — the tool NAME's only carrier.
+    if (!OMIT_TOOL_CALL) {
+      await ctx.client.notify('session/update', {
+        sessionId: ctx.params.sessionId,
+        update: {
+          _meta: { claudeCode: { toolName: TOOL } },
+          toolCallId: TOOL_CALL_ID,
+          sessionUpdate: 'tool_call',
+          rawInput: rawInput(),
+          status: 'pending',
+          ...toolInfo(),
+        },
+      });
+    }
+    // (2) THEN the permission request, with the adapter's real option set for a
+    //     routine tool call (`acp-agent.js:2271-2278`) — note `allow_always` is
+    //     listed FIRST, which is what Decision D's filter has to contend with.
+    const outcome = await ctx.client.request(acp.methods.client.session.requestPermission, {
+      sessionId: ctx.params.sessionId,
+      toolCall: { toolCallId: TOOL_CALL_ID, rawInput: rawInput(), ...toolInfo() },
+      options: [
+        { optionId: 'allow_always', name: 'Always Allow', kind: 'allow_always' },
+        { optionId: 'allow', name: 'Allow', kind: 'allow_once' },
+        { optionId: 'reject', name: 'Reject', kind: 'reject_once' },
+      ],
+    });
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: `outcome=${JSON.stringify(outcome.outcome)}` },
+      },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);