@wjarka/cezarion 0.15.1 → 0.16.0

package/scripts/mock-codex-reverse-steer.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+// #486 review round 2: buffers each `turn/steer` RPC response and writes it AFTER
+// the following `turn/completed` (or `turn/failed`) notification. Codex reads
+// stdout with `for await`, so microtasks run between those lines: the completed
+// boundary settles before startOrSteerTurn sees the steer result.
+// Do not wrap mock:steer-race / mock:steer-strand — those already emit completed
+// then the steer response; this wrapper would hold that response until a later turn.
+//
+// Default (unread): drop the in-turn userMessage/agentMessage echo of the held
+// steer so the follow-up was accepted and never read. CEZ_MOCK_REVERSE_ECHO=1
+// keeps those echoes (read-in-turn) and still delays the steer response.
+// CEZ_MOCK_DELAY_TURN_STARTED_MS holds stdout after a follow-up turn/start
+// response so turn/started arrives later (review round 4).
+//
+// A steer that lands after this turn already completed (release() before the
+// RPC was on the wire) must not be held for a later completed that never
+// comes — that deadlocked holdsHumanInput() until teardown (#486 round 5).
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const echoInTurn = process.env.CEZ_MOCK_REVERSE_ECHO === '1';
+const delayTurnStartedMs = Number.parseInt(process.env.CEZ_MOCK_DELAY_TURN_STARTED_MS ?? '0', 10) || 0;
+const child = spawn(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'mock-codex-app-server.mjs'), ...process.argv.slice(2)], {
+  stdio: ['pipe', 'pipe', 'inherit'],
+  env: process.env,
+});
+const steerIds = new Set();
+const steeredClientIds = new Set();
+const steeredTexts = new Set();
+const followUpStartIds = new Set();
+let turnStartCount = 0;
+let forwardedCompleted = false;
+let stdinBuf = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  child.stdin.write(chunk);
+  stdinBuf += chunk;
+  let idx;
+  while ((idx = stdinBuf.indexOf('\n')) >= 0) {
+    const line = stdinBuf.slice(0, idx);
+    stdinBuf = stdinBuf.slice(idx + 1);
+    try {
+      const msg = JSON.parse(line);
+      if (msg.method === 'turn/steer' && typeof msg.id === 'number') {
+        steerIds.add(msg.id);
+        const clientId = msg.params?.clientUserMessageId;
+        if (typeof clientId === 'string') steeredClientIds.add(clientId);
+        const text = msg.params?.input?.map?.((part) => part.text ?? '').join('\n') ?? '';
+        if (text) steeredTexts.add(text);
+      } else if (msg.method === 'turn/start' && typeof msg.id === 'number') {
+        turnStartCount += 1;
+        if (turnStartCount > 1) followUpStartIds.add(msg.id);
+      }
+    } catch { /* ignore a partial or non-JSON line */ }
+  }
+});
+process.stdin.on('end', () => child.stdin.end());
+
+let outBuf = '';
+const held = [];
+let stdoutPaused = false;
+const pausedChunks = [];
+let resumeTimer;
+const resumeStdout = () => {
+  stdoutPaused = false;
+  resumeTimer = undefined;
+  const pending = pausedChunks.splice(0);
+  for (const chunk of pending) process.stdout.write(chunk);
+};
+child.stdout.setEncoding('utf8');
+child.stdout.on('data', chunk => {
+  outBuf += chunk;
+  let idx;
+  while ((idx = outBuf.indexOf('\n')) >= 0) {
+    const line = outBuf.slice(0, idx + 1);
+    outBuf = outBuf.slice(idx + 1);
+    if (stdoutPaused) {
+      pausedChunks.push(line);
+      continue;
+    }
+    let msg;
+    try { msg = JSON.parse(line); } catch { process.stdout.write(line); continue; }
+    if (typeof msg.id === 'number' && steerIds.has(msg.id) && (msg.result !== undefined || msg.error !== undefined)) {
+      steerIds.delete(msg.id);
+      if (forwardedCompleted) {
+        process.stdout.write(line);
+        continue;
+      }
+      held.push(line);
+      continue;
+    }
+    if (held.length && isSteerEcho(msg)) {
+      if (echoInTurn) process.stdout.write(line);
+      continue;
+    }
+    if ((msg.method === 'turn/completed' || msg.method === 'turn/failed') && held.length) {
+      forwardedCompleted = true;
+      process.stdout.write(line + held.splice(0).join(''));
+      continue;
+    }
+    if (msg.method === 'turn/completed' || msg.method === 'turn/failed') forwardedCompleted = true;
+    if (msg.method === 'turn/started') forwardedCompleted = false;
+    process.stdout.write(line);
+    if (delayTurnStartedMs > 0 && typeof msg.id === 'number' && followUpStartIds.has(msg.id) && msg.result !== undefined) {
+      followUpStartIds.delete(msg.id);
+      stdoutPaused = true;
+      resumeTimer = setTimeout(resumeStdout, delayTurnStartedMs);
+    }
+  }
+});
+child.on('exit', (code, signal) => {
+  if (resumeTimer) clearTimeout(resumeTimer);
+  // A killed follow-up whose turn/started is still paused must not flush into a
+  // closing runner; with the hold fix the delay elapses before close.
+  if (!stdoutPaused) {
+    if (outBuf) process.stdout.write(outBuf);
+    if (held.length) process.stdout.write(held.join(''));
+  }
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 0);
+});
+
+function isSteerEcho(msg) {
+  const item = msg.params?.item;
+  if (!item || typeof item !== 'object') return false;
+  if (item.type === 'userMessage' && typeof item.clientId === 'string' && steeredClientIds.has(item.clientId)) return true;
+  if (item.type === 'agentMessage' && typeof item.text === 'string' && steeredTexts.has(item.text)) return true;
+  return false;
+}

package/scripts/mock-cursor-acp.mjs

@@ -14,6 +14,13 @@ function watchdogStall(prompt) {
   if (prompt.includes('held-pipe')) {
     watchdogSpawn(process.execPath, ['-e', 'setTimeout(() => {}, 5000)'], { stdio: ['ignore', process.stdout, process.stderr] });
   }
+  if (prompt.includes('leftover')) {
+    // hearsay-tools/cezarion#890: one child stays in the session's process group and ignores
+    // SIGTERM; one leaves the group with setsid. Both exit on their own as a cleanup backstop.
+    const leftover = (file) => `process.on('SIGTERM',()=>{}); require('fs').writeFileSync(${JSON.stringify(file)}, String(process.pid)); setTimeout(()=>{},20000)`;
+    watchdogSpawn(process.execPath, ['-e', leftover('leftover-group.pid')], { stdio: 'ignore' });
+    watchdogSpawn(process.execPath, ['-e', leftover('leftover-session.pid')], { stdio: 'ignore', detached: true }).unref();
+  }
   return true;
 }
 
@@ -28,6 +35,15 @@ async function afterParityPark(prompt) {
   if (!gate) throw new Error('post-park scenario requires a release path');
   while (!parityGateFs.existsSync(gate)) await new Promise(resolve => setTimeout(resolve, 10));
 }
+async function waitForMockRelease(fallbackMs) {
+  const file = process.env.CEZ_MOCK_RELEASE_FILE;
+  if (!file) { if (fallbackMs) await new Promise(r => setTimeout(r, fallbackMs)); return; }
+  const deadline = Date.now() + 15_000;
+  while (!parityGateFs.existsSync(file)) {
+    if (Date.now() > deadline) throw new Error('CEZ_MOCK_RELEASE_FILE was not created');
+    await new Promise(r => setTimeout(r, 10));
+  }
+}
 
 const record = (file, value) => { if (file) appendFileSync(file, `${JSON.stringify(value, (key, value) => key === 'env' && Array.isArray(value) ? value.map(item => item.name?.startsWith('CEZ_TOOL_') ? { ...item, value: '[redacted]' } : item) : value)}\n`); };
 record(process.env.CEZ_MOCK_ARGS_FILE, process.argv.slice(2));
@@ -66,6 +82,45 @@ const question = { id: 'tests', prompt: 'Which test runner?', options: [{ id: 'v
 async function prompt(id, content) {
   const input = content.filter(b => b.type === 'text').map(b => b.text).join('\n');
   prompts += 1;
+  if (input.includes('mock:autonomous') || input.startsWith('Continue working autonomously until the task is fully complete.')) {
+    const { autonomousReply } = await import('./mock-autonomous.mjs');
+    text(autonomousReply(input)); complete(id); return;
+  }
+  if (input.includes('mock:silent-tail') || input.includes('mock:tool-tail') || input.includes('Your last turn ended without a message to the user.')) {
+    const silent = await import('./mock-silent-tail.mjs');
+    silent.noteSilentTailPrompt(input);
+    if (silent.isFinalMessageNudge(input)) {
+      const kind = silent.finalMessageNudgeKind();
+      if (kind === 'ack-only') return;
+      if (kind === 'late') await silent.sleep(silent.LATE_REPLY_MS);
+      if (kind === 'silent') update({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: silent.SILENT_TAIL_REASONING } });
+      else {
+        if (kind === 'slow-done') {
+          text(silent.SLOW_DONE_PREFIX);
+          await silent.sleep(silent.SLOW_DONE_TAIL_MS);
+        }
+        text(kind === 'standing' ? silent.FINAL_MESSAGE_STANDING : silent.SILENT_TAIL_DONE);
+      }
+      complete(id); return;
+    }
+    if (silent.isSilentTailScenario(input)) {
+      text(silent.SILENT_TAIL_OPENING);
+      update({ sessionUpdate: 'tool_call', toolCallId: 'silent-gh', title: 'Create issue', kind: 'execute', status: 'in_progress', rawInput: { command: 'gh issue create' } });
+      update({ sessionUpdate: 'tool_call_update', toolCallId: 'silent-gh', status: 'completed', content: [{ type: 'content', content: { type: 'text', text: 'created' } }] });
+      update({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: silent.SILENT_TAIL_REASONING } });
+      complete(id); return;
+    }
+    if (silent.isToolTailScenario(input)) {
+      text(silent.TOOL_TAIL_OPENING);
+      update({ sessionUpdate: 'tool_call', toolCallId: 'tool-tail-git', title: 'git status', kind: 'execute', status: 'in_progress', rawInput: { command: 'git status --short' } });
+      update({ sessionUpdate: 'tool_call_update', toolCallId: 'tool-tail-git', status: 'completed', content: [{ type: 'content', content: { type: 'text', text: ' M src/example.ts' } }] });
+      complete(id); return;
+    }
+  }
+  if (input.includes('mock:crash-stderr')) {
+    const { crashWithStderr } = await import('./mock-runner-crash.mjs');
+    if (crashWithStderr(input, '{"method":"session/update","params":')) return;
+  }
   if (input.includes('mock:ci-wait')) { const { ciPrompt } = await import('./mock-ci-tool.mjs'); text(await ciPrompt('cursor', ciWire, input)); complete(id); return; }
   if (resumeDone) { resumeDone = false; text('Resumed work finished.\nCEZ:DONE'); complete(id); return; }
   if (watchdogStall(input)) return;
@@ -73,6 +128,20 @@ async function prompt(id, content) {
     for (let i = 0; i < 24; i++) { text('working\n'); await new Promise(r => setTimeout(r, 100)); }
     complete(id); return;
   }
+  if (input.includes('mock:hold-done')) {
+    await waitForMockRelease(400);
+    text('parity hold-done: content after the pause\nCEZ:DONE'); complete(id); return;
+  }
+  if (input.includes('mock:hold-ask')) {
+    await waitForMockRelease(400);
+    text('Pick one.\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}');
+    complete(id); return;
+  }
+  if (input.includes('mock:hold-gated')) {
+    await waitForMockRelease(500);
+    text('parity hold-gated: content after the pause');
+    complete(id); return;
+  }
   if (input.includes('mock:hold')) await new Promise(r => setTimeout(r, 500));
   if (input.includes('mock:rpc-error')) { emit({ id, error: { code: -32603, message: 'Provider rejected request' } }); return; }
   // #443 provider-error envelopes: the specific scenarios must be matched BEFORE the
@@ -95,8 +164,13 @@ async function prompt(id, content) {
   if (input.includes('mock:provider-error-verbose')) { text(`\n\nError: usage limit reached. The request ${'x'.repeat(600)} could not be completed, try again at ${new Date(Date.now() + 6 * 3600000).toISOString()}.`); complete(id); return; }
   if (input.includes('mock:provider-error') && !input.includes('mock:provider-error-')) { text('\n\nError: [unauthenticated] Backend rejected authentication.'); complete(id); return; }
   // #401: ACP has chunks only, so completion must flush the same text to v1/v2.
+  if (input.includes('mock:turn-messages:')) {
+    const { turnMessages } = await import('./mock-turn-messages.mjs');
+    for (const message of turnMessages(input)) text(message + '\n');
+    complete(id); return;
+  }
   if (input.includes('mock:ask-snapshot')) {
-    text('Using the CEZ:ASK structured question format instead:\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}'); complete(id); return;
+    text(input.includes('mock:ask-snapshot-bad') ? 'CEZ:ASK {not valid json' : 'Using the CEZ:ASK structured question format instead:\n\nCEZ:ASK {"questions":[{"header":"Library","question":"Which test library?","options":[{"label":"Vitest"},{"label":"Node test"}]}]}'); complete(id); return;
   }
   if (input.includes('mock:ask-prose')) { text('Use `CEZ:ASK {"questions":[]}` in your reply.\n> CEZ:ASK {not valid json'); complete(id); return; }
   if (input.includes('mock:ask-bad')) { pendingAsk = { id }; emit({ id: 'bad-question', method: 'cursor/ask_question', params: { questions: [] } }); return; }