@1agh/maude 1.0.9 → 1.2.0

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

@@ -1,42 +0,0 @@
-#!/usr/bin/env bun
-// Mock ACP agent that sends a `mode:'url'` elicitation request — proves
-// AcpBridge.unstable_createElicitation rejects it structurally (declines
-// without ever calling onElicitationRequest) even though the adapter/agent
-// side ignored the client's declared `elicitation:{form:{}}`-only capability
-// (ethical-hacker finding — capability negotiation is advisory, not
-// enforced; the client must reject what it never advertised, not just hope
-// the other side honors it).
-
-import { Readable, Writable } from 'node:stream';
-
-import * as acp from '@agentclientprotocol/sdk';
-
-const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-
-let n = 0;
-
-acp
-  .agent({ name: 'mock-acp-agent-elicit-url' })
-  .onRequest('initialize', () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false },
-  }))
-  .onRequest('session/new', () => ({ sessionId: `mock-elicit-url-session-${++n}` }))
-  .onRequest('session/prompt', async (ctx) => {
-    const response = await ctx.client.request(acp.methods.client.elicitation.create, {
-      mode: 'url',
-      sessionId: ctx.params.sessionId,
-      message: 'Confirm you have completed verification',
-      url: 'https://example.com/verify',
-      elicitationId: 'elicit-url-1',
-    });
-    await ctx.client.notify('session/update', {
-      sessionId: ctx.params.sessionId,
-      update: {
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: `response=${JSON.stringify(response)}` },
-      },
-    });
-    return { stopReason: 'end_turn' };
-  })
-  .connect(stream);

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

@@ -1,63 +0,0 @@
-#!/usr/bin/env bun
-// Mock ACP agent exercising the elicitation-form gate (feature-acp-ask-user-
-// question) — session/prompt calls back INTO the client via a REAL
-// `elicitation/create` request, shaped exactly like
-// `askUserQuestionsToCreateRequest`'s single-question output (confirmed on
-// disk against the installed `@agentclientprotocol/claude-agent-acp` — a
-// titled `oneOf` enum plus its sibling `_custom` free-text field), before
-// streaming its final reply. Mirrors mock-acp-agent-permission.mjs's shape.
-// No real `claude` needed.
-
-import { Readable, Writable } from 'node:stream';
-
-import * as acp from '@agentclientprotocol/sdk';
-
-const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-
-let n = 0;
-
-acp
-  .agent({ name: 'mock-acp-agent-elicit' })
-  .onRequest('initialize', () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false },
-  }))
-  .onRequest('session/new', () => ({ sessionId: `mock-elicit-session-${++n}` }))
-  .onRequest('session/prompt', async (ctx) => {
-    // `ctx.client` (AgentContext) only exposes the generic request()/notify() —
-    // no typed convenience method — so call the raw ACP method via
-    // `acp.methods.client.elicitation.create` (confirmed on disk: acp.js's
-    // `methods.client.elicitation.create === schema.CLIENT_METHODS.elicitation_create`).
-    const response = await ctx.client.request(acp.methods.client.elicitation.create, {
-      mode: 'form',
-      sessionId: ctx.params.sessionId,
-      toolCallId: 'tc-elicit-1',
-      message: 'Which color do you like?',
-      requestedSchema: {
-        type: 'object',
-        properties: {
-          question_0: {
-            type: 'string',
-            oneOf: [
-              { const: 'Red', title: 'Red' },
-              { const: 'Blue', title: 'Blue' },
-            ],
-          },
-          question_0_custom: {
-            type: 'string',
-            title: 'Other',
-            description: 'Type your own answer instead of choosing an option above (optional).',
-          },
-        },
-      },
-    });
-    await ctx.client.notify('session/update', {
-      sessionId: ctx.params.sessionId,
-      update: {
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: `response=${JSON.stringify(response)}` },
-      },
-    });
-    return { stopReason: 'end_turn' };
-  })
-  .connect(stream);

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

@@ -1,51 +0,0 @@
-#!/usr/bin/env bun
-// Mock ACP agent proving the MAX_PENDING_PERMISSIONS cap (SECURITY /
-// ethical-hacker finding, retroactive review of Milestone B — a single agent
-// turn can legitimately issue several tool calls back to back, so "one per
-// tool call" is not a natural rate limit). Fires MORE than the cap
-// concurrently, without waiting for each one, and reports which ones actually
-// round-tripped to the client vs. were denied immediately by the bridge's
-// own cap.
-
-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 FLOOD_COUNT = 13; // > MAX_PENDING_PERMISSIONS (10) in acp/bridge.ts
-
-let n = 0;
-
-acp
-  .agent({ name: 'mock-acp-agent-permission-flood' })
-  .onRequest('initialize', () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false },
-  }))
-  .onRequest('session/new', () => ({ sessionId: `mock-perm-flood-session-${++n}` }))
-  .onRequest('session/prompt', async (ctx) => {
-    const requests = Array.from({ length: FLOOD_COUNT }, (_, i) =>
-      ctx.client.request(acp.methods.client.session.requestPermission, {
-        sessionId: ctx.params.sessionId,
-        toolCall: { toolCallId: `tc${i}`, title: `Flood tool call ${i}`, kind: 'edit' },
-        options: [
-          { optionId: 'allow-once', name: 'Allow once', kind: 'allow_once' },
-          { optionId: 'reject-once', name: 'Reject', kind: 'reject_once' },
-        ],
-      })
-    );
-    const outcomes = await Promise.all(requests);
-    await ctx.client.notify('session/update', {
-      sessionId: ctx.params.sessionId,
-      update: {
-        sessionUpdate: 'agent_message_chunk',
-        content: {
-          type: 'text',
-          text: `outcomes=${JSON.stringify(outcomes.map((o) => o.outcome))}`,
-        },
-      },
-    });
-    return { stopReason: 'end_turn' };
-  })
-  .connect(stream);

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

@@ -1,50 +0,0 @@
-#!/usr/bin/env bun
-// Mock ACP agent exercising the permission approve/deny gate (Milestone B,
-// retires DDR-125 F2) — session/prompt calls back INTO the client via
-// `ctx.client.requestPermission(...)` (a real request, not a notification)
-// before streaming its final reply, mirroring how claude-agent-acp asks for
-// tool authorization mid-turn. No real `claude` needed.
-
-import { Readable, Writable } from 'node:stream';
-
-import * as acp from '@agentclientprotocol/sdk';
-
-const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-
-let n = 0;
-
-acp
-  .agent({ name: 'mock-acp-agent-permission' })
-  .onRequest('initialize', () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false },
-  }))
-  .onRequest('session/new', () => ({ sessionId: `mock-perm-session-${++n}` }))
-  .onRequest('session/prompt', async (ctx) => {
-    // `ctx.client` (AgentContext) only exposes the generic request()/notify() —
-    // no typed `.requestPermission()` convenience method — so call the raw ACP
-    // method via `acp.methods.client.session.requestPermission`.
-    const outcome = await ctx.client.request(acp.methods.client.session.requestPermission, {
-      sessionId: ctx.params.sessionId,
-      toolCall: {
-        toolCallId: 'tc1',
-        title: 'Write file',
-        kind: 'edit',
-        rawInput: { path: '/tmp/x' },
-      },
-      options: [
-        { optionId: 'allow-once', name: 'Allow once', kind: 'allow_once' },
-        { optionId: 'allow-always', name: 'Allow always', kind: 'allow_always' },
-        { optionId: 'reject-once', 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);

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

@@ -1,45 +0,0 @@
-#!/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-usage.mjs

@@ -1,56 +0,0 @@
-#!/usr/bin/env bun
-// Mock ACP agent emitting `usage_update` notifications (Milestone D) — one
-// after the prompt result (context/cost), and one carrying the thin
-// `_meta["_claude/rateLimit"]` rate-limit signal (mirrors the real adapter's
-// `rate_limit_event` forwarding, acp-agent.js:1768-1776). No real `claude` needed.
-
-import { Readable, Writable } from 'node:stream';
-
-import * as acp from '@agentclientprotocol/sdk';
-
-const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-
-let n = 0;
-
-acp
-  .agent({ name: 'mock-acp-agent-usage' })
-  .onRequest('initialize', () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false },
-  }))
-  .onRequest('session/new', () => ({ sessionId: `mock-usage-session-${++n}` }))
-  .onRequest('session/prompt', async (ctx) => {
-    await ctx.client.notify('session/update', {
-      sessionId: ctx.params.sessionId,
-      update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'ok' } },
-    });
-    await ctx.client.notify('session/update', {
-      sessionId: ctx.params.sessionId,
-      update: {
-        sessionUpdate: 'usage_update',
-        used: 4200,
-        size: 200000,
-        cost: { amount: 0.0123, currency: 'USD' },
-      },
-    });
-    if (ctx.params.prompt?.[0]?.text === 'trigger-rate-limit') {
-      await ctx.client.notify('session/update', {
-        sessionId: ctx.params.sessionId,
-        update: {
-          sessionUpdate: 'usage_update',
-          used: 4200,
-          size: 200000,
-          _meta: {
-            '_claude/rateLimit': {
-              status: 'allowed_warning',
-              rateLimitType: 'five_hour',
-              utilization: 82,
-              resetsAt: 1234567890,
-            },
-          },
-        },
-      });
-    }
-    return { stopReason: 'end_turn' };
-  })
-  .connect(stream);

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

@@ -1,37 +0,0 @@
-#!/usr/bin/env bun
-// A mock ACP agent that WEDGES on the FIRST turn only (issue-82): its
-// `session/prompt` handler never resolves for call #1 — simulating a
-// `claude` subprocess that has hung — and it never implements
-// `session/cancel` at all, so a bridge that only sends the cooperative ACP
-// `session/cancel` request and trusts it will hang forever, exactly like the
-// reported "I clicked STOP and nothing happened" bug.
-//
-// Every call AFTER the first resolves normally and quickly — this lets a
-// test start a second, overlapping `prompt()` on the same bridge/chat (the
-// ethical-hacker's "no reentrancy guard" finding) and confirm that turn's
-// ordinary completion doesn't blind `cancel()` to the still-wedged first one.
-
-import { Readable, Writable } from 'node:stream';
-
-import * as acp from '@agentclientprotocol/sdk';
-
-const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-
-let promptCalls = 0;
-
-acp
-  .agent({ name: 'mock-acp-agent-wedged' })
-  .onRequest('initialize', () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: false },
-  }))
-  .onRequest('session/new', () => ({ sessionId: 'mock-wedged-session' }))
-  .onRequest('session/prompt', () => {
-    promptCalls += 1;
-    if (promptCalls === 1) return new Promise(() => {}); // never resolves, never rejects
-    return Promise.resolve({ stopReason: 'end_turn' });
-  })
-  // Deliberately NO `session/cancel` handler — an agent that never
-  // implemented turn-cancellation at all, the other real-world shape of
-  // "Stop does nothing".
-  .connect(stream);

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

@@ -1,118 +0,0 @@
-#!/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);

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

@@ -1,69 +0,0 @@
-#!/usr/bin/env bun
-// Mock ACP agent for acp/bridge.test.ts. Stands in for `claude-agent-acp` so the
-// bridge can be exercised without a real `claude` install. Implements the
-// minimal handshake (initialize + session/new + session/prompt) and streams one
-// `agent_message_chunk` whose text echoes whether ANTHROPIC_API_KEY survived
-// into the child env — it MUST read `<unset>`, proving scrubAgentEnv (DDR-123
-// guardrail #1) stripped it before spawn.
-//
-// session/load simulates the REAL adapter's cross-restart resume (this is a
-// fresh subprocess per test, so it has no memory of a prior session/new call —
-// exactly like the real claude-agent-acp adapter after an app restart, whose
-// resume is backed by the underlying `claude` CLI's own on-disk store, not its
-// own process memory). Any sessionId resolves EXCEPT the `not-found` sentinel
-// (simulates a pruned/unresumable session), so a test controls resume
-// success/failure by choosing which id it persists. It also emits one replay
-// `session/update` BEFORE resolving, mirroring claude-agent-acp's
-// `replaySessionHistory` — bridge.ts must not forward or re-transcript it.
-
-import { Readable, Writable } from 'node:stream';
-
-import * as acp from '@agentclientprotocol/sdk';
-
-const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
-
-acp
-  .agent({ name: 'mock-acp-agent' })
-  .onRequest('initialize', () => ({
-    protocolVersion: acp.PROTOCOL_VERSION,
-    agentCapabilities: { loadSession: true },
-  }))
-  .onRequest(
-    'session/new',
-    (() => {
-      let n = 0;
-      return () => ({ sessionId: `mock-session-${++n}` });
-    })()
-  )
-  .onRequest('session/load', async (ctx) => {
-    if (ctx.params.sessionId === 'not-found') {
-      throw new Error('session not found');
-    }
-    await ctx.client.notify('session/update', {
-      sessionId: ctx.params.sessionId,
-      update: {
-        sessionUpdate: 'agent_message_chunk',
-        content: { type: 'text', text: 'REPLAYED-HISTORY-SHOULD-NOT-SURFACE' },
-      },
-    });
-    return {};
-  })
-  .onRequest('session/prompt', async (ctx) => {
-    // The per-request handler context exposes the client connection at `.client`.
-    await ctx.client.notify('session/update', {
-      sessionId: ctx.params.sessionId,
-      update: {
-        sessionUpdate: 'agent_message_chunk',
-        content: {
-          type: 'text',
-          text:
-            `apiKey=${process.env.ANTHROPIC_API_KEY ?? '<unset>'} ` +
-            `model=${process.env.ANTHROPIC_MODEL ?? '<unset>'} ` +
-            `thinking=${process.env.MAX_THINKING_TOKENS ?? '<unset>'} ` +
-            `claudeExe=${process.env.CLAUDE_CODE_EXECUTABLE ?? '<unset>'}`,
-        },
-      },
-    });
-    return { stopReason: 'end_turn' };
-  })
-  .connect(stream);