agentgui 1.0.1118 → 1.0.1119

package/.gm/prd.yml

@@ -1,15 +1,10 @@
 - id: aaa-consolidate-acp-http-routing
   subject: Route chat.sendMessage's ACP prompt through acp-sdk-manager's already-running HTTP server instead of claude-runner-acp.js spawning a fresh stdio subprocess per turn
-  witness: 'Deep investigation this session established: (1) opencode acp --port serves REST+SSE (POST /session, POST /session/{id}/message, GET /event) -- LIVE confirmed via Explore agent''s GET /doc fetch. (2) This is a STRUCTURALLY DIFFERENT event shape than the stdio ACP JSON-RPC ''session/update'' notifications lib/acp-protocol.js''s acpProtocolHandler parses (opencode SSE emits ''session.updated''/''message.part.updated'' REST-shaped events, not ACP method=''session/update'' RPC notifications) -- consolidating requires a NEW event-normalizer for the SSE shape, not a reuse of acpProtocolHandler, and acpProtocolHandler is shared live-critical code for 14 other registered agents (gemini, goose, openhands, augment, cline, kimi, qwen, mistral, kiro, fast-agent, hermes, etc) so a wrong rewrite risks breaking all of them. (3) kilo''s exact SSE/event shape was NOT live-verified in this session (Bash tool backgrounding could not keep a kilo acp --port process alive across tool-call boundaries in this environment -- two attempts, both times the process was gone with zero log output on the next read).'
-  description: 'This row requires a dedicated focused session with a live, running opencode instance to iterate the SSE event-normalizer against real traffic (not guessable from static analysis) -- do NOT attempt a blind rewrite of claude-runner-acp.js''s runACP against unverified event-shape assumptions. Concrete next steps for that session: (1) spawn opencode acp --port in a way that survives across dispatches (e.g. via the gm skill''s exec_js/background-convert primitives, or a supervised child in server.js itself, rather than raw shell backgrounding), (2) POST /session + /session/{id}/message with a real prompt, (3) capture actual GET /event SSE frames, (4) write a NEW lib/acp-http-protocol.js normalizer mapping those frames to the same internal event shape acpProtocolHandler produces (assistant/tool_use/tool_result/result), (5) add an opt-in per-agent transport flag (e.g. tool.transport:''http-sse'') so opencode/kilo can migrate independently of the 12 other stdio-based ACP agents which must keep working unchanged, (6) only delete stdio spawn code for a given agent after its HTTP path is proven equivalent via side-by-side witness (same prompt, same final assistant text, over both transports).'
-  status: pending
-- id: aaa-codex-app-server-client
-  subject: Build a WebSocket app-server client for codex so Codex CLI is a genuinely working ACP-class agent again
-  witness: 'codex --help / codex app-server --help live output (this session): app-server exposes --remote ws://host:port style connections and its own --ws-auth capability-token/signed-bearer-token modes -- structurally different from the stdio JSON-RPC (claude-runner-acp.js) and HTTP-polling (acp-sdk-manager.js) transports this codebase already has clients for'
-  description: 'Implement lib/claude-runner-codex-appserver.js: spawn `codex app-server daemon` (or the correct non-daemon invocation per `codex app-server --help`), speak its WebSocket protocol (JSON-RPC-over-WS per the --remote ws:// contract, generate-ts/generate-json-schema subcommands can emit the exact schema), wire it into claude-runner-agents.js''s codex registration in place of the disabled acp stdio path, and into acp-sdk-manager.js if health/model discovery is meaningful for it. Read `codex app-server generate-json-schema` output first to get the real RPC method/param shapes rather than guessing.'
+  witness: 'MAJOR PROGRESS this session, sha f5e57db253: root-caused opencode''s HTTP server appearing unreachable (same stdin-EOF disposal bug as acp-sdk-manager.js, fixed by stdio:[''pipe'',''pipe'',''pipe'']); captured a full real POST /session -> POST /session/{id}/message -> GET /global/event round trip via a temporary in-process diagnostic route (LLM genuinely replied ''OK''); built and unit-verified lib/acp-http-protocol.js''s createACPHttpProtocolHandler(), which correctly normalizes the captured event shape into the same internal shape acp-protocol.js''s stdio handler produces, including correctly filtering the user''s own prompt echo via message-id-to-role tracking (verified against the exact real captured sequence).'
+  description: 'Remaining step: wire the verified normalizer into the live chat.sendMessage path. Concretely: (1) in lib/claude-runner-acp.js, add an HTTP-transport branch to runACP (or a new runACPHttp) that: ensures the opencode/kilo server is running via acp-sdk-manager.ensureRunning(agentId) [already exists], POSTs /session then /session/{id}/message against that port, opens GET /global/event with an AbortController, feeds each SSE frame through acpHttpProtocolHandler, and calls onEvent for each normalized result exactly like the stdio path does; (2) add a per-agent opt-in flag (e.g. registry entries for opencode/kilo get transport:''http'') so this only activates for the two live-verified agents, leaving the other 12 stdio-based ACP agents (gemini, goose, openhands, augment, cline, kimi, qwen, mistral, kiro, fast-agent, hermes) completely untouched; (3) side-by-side witness: send the SAME prompt through both the old stdio path and the new HTTP path for opencode, confirm identical final assistant text, before deleting any stdio code; (4) only after (3) passes, delete the stdio spawn/handshake for the converted agents and update AGENTS.md''s ACP CRITICAL rule to be literally true. This is a live chat-path change -- do not skip the side-by-side witness step even under time pressure.'
   status: pending
 - id: aaa-split-app-js-god-file
   subject: Extract site/app/js/app.js's mixed concerns into per-concern modules
-  witness: 'Slice 1/4 DONE and committed (sha d211f32cbd): chat-persistence extracted to site/app/js/chat-persistence.js via createChatPersistence(state, helpers) factory, live-witnessed via browser verb round-tripping a seeded localStorage chat through reload with zero page errors. Established working pattern for remaining slices: factory function closing over the shared `state` object + helper functions, called once at app.js module load, destructured to the SAME local names so every existing call site is untouched.'
-  description: '3 slices remain, cut in this order (per the original extraction-contract row): (2) keyboard shortcuts (SHORTCUTS array line ~628 renumbered after slice 1''s ~70-line removal, + global keydown handler, closes over render()/navTo()/state.showShortcuts/gPending/arm-timers -- more coupled than persistence, verify the escape-ladder order documented in AGENTS.md still holds after the cut), (3) hash-routing (HASH_KEYS/readHash/buildHash/writeHash/navTo, closes over render()), (4) settings/history (largest remaining, ~900 lines, most view()-tree coupling -- do last). After each cut: node --check both files, restart live server, browser-witness hasApp:true + zero page/console errors + the specific behavior moved (e.g. shortcuts overlay opens on ''?'', hash round-trips on navTo), commit that ONE slice, then start the next -- never batch.'
+  witness: 'Slice 1/4 DONE (chat-persistence, sha d211f32cbd, live-witnessed). Slice 2 (keyboard shortcuts, app.js:4649-4758 as of this commit) was investigated concretely: the global keydown handler references ~10 app.js-local functions across every feature area (navTo, closeFileDialog, filesMarked, clearFileSelection, cancelChat, newChat, previewNeighbours, openPreview, announce, render) plus state fields spanning chat/files/live/settings -- the highest cross-cutting coupling in the file. This is the exact code AGENTS.md flags as historically crash-prone under webjsx keying mistakes, and a rushed extraction threading 10 dependencies through a factory is a real correctness risk, not a mechanical move.'
+  description: 'Slice 2 (shortcuts) needs a dedicated pass: enumerate the full dependency list precisely (grep every identifier referenced inside the keydown handler + SHORTCUTS array + focusComposer/focusSearch/focusFilter), decide whether those ~10 functions move WITH the shortcuts module (turning it into a larger cut than ''just shortcuts'') or stay in app.js and get passed in (a large helpers object) -- this decision should be made deliberately, not improvised mid-edit. Slices 3 (hash-routing) and 4 (settings/history) still queued after. Do not attempt slice 2 without first re-reading the live current line numbers (they shift after every extraction) and re-running the same live-witness discipline (node --check, live browser reload+interaction witness, single-slice commit) slice 1 used.'
   status: pending

package/lib/acp-http-protocol.js

@@ -0,0 +1,91 @@
+// Normalizes opencode's REST+SSE event shape (POST /session, POST
+// /session/{id}/message, GET /global/event) into the SAME internal event
+// shape lib/acp-protocol.js's acpProtocolHandler produces for the stdio ACP
+// JSON-RPC transport (assistant/tool_use/tool_result/result), so a caller can
+// switch transports without caring which one produced the event.
+//
+// Live-captured event shapes this maps (opencode 1.2.15, acp --port, SSE
+// frames from GET /global/event during a real session/message round trip):
+//   {payload:{type:'message.part.updated', properties:{part:{type:'text',text,...}}}}
+//   {payload:{type:'message.part.updated', properties:{part:{type:'reasoning',text,...}}}}
+//   {payload:{type:'message.updated', properties:{info:{role,finish,...}}}}
+//   {payload:{type:'session.status', properties:{status:{type:'busy'|'idle'}}}}
+//   {payload:{type:'session.idle', properties:{...}}}
+
+function normalizePart(part, sessionId) {
+  if (!part || typeof part !== 'object') return null;
+  if (part.type === 'text' && typeof part.text === 'string') {
+    return { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: part.text }] }, session_id: sessionId };
+  }
+  if (part.type === 'tool' || part.type === 'tool-invocation') {
+    return {
+      type: 'assistant',
+      message: { role: 'assistant', content: [{ type: 'tool_use', id: part.id, name: part.tool || part.name || 'tool', input: part.input || part.args || {} }] },
+      session_id: sessionId,
+    };
+  }
+  // reasoning/step-start/step-finish parts carry no user-facing content in
+  // agentgui's chat surface today - dropped (return null), same as the stdio
+  // path drops ACP updates it doesn't recognize.
+  return null;
+}
+
+// A `message.part.updated` frame's `part` carries NO role of its own - live
+// capture confirmed the part's role lives on the earlier `message.updated`
+// frame for the SAME messageID (the prompt echo arrives as a role:"user"
+// message.updated immediately before its own message.part.updated). Each
+// createACPHttpProtocolHandler() call keeps its own messageId->role map so a
+// caller with one handler per session never leaks state across sessions.
+export function createACPHttpProtocolHandler() {
+  const roleByMessageId = new Map();
+
+  return function (frame, context) {
+    if (!frame || typeof frame !== 'object') return null;
+    const payload = frame.payload;
+    if (!payload || typeof payload !== 'object') return null;
+    const sid = context?.sessionId;
+
+    if (payload.type === 'message.updated') {
+      const info = payload.properties?.info;
+      if (!info) return null;
+      if (info.id) roleByMessageId.set(info.id, info.role);
+      if (info.role === 'assistant' && info.finish) {
+        return { type: 'result', result: '', stopReason: info.finish, usage: info.tokens ? { used: info.tokens.total } : undefined, session_id: info.sessionID || sid };
+      }
+      return null;
+    }
+
+    if (payload.type === 'message.part.updated') {
+      const part = payload.properties?.part;
+      if (!part) return null;
+      // The user's own prompt echoes back as a part on their own message -
+      // only forward parts belonging to an assistant-role message.
+      const role = part.messageID ? roleByMessageId.get(part.messageID) : undefined;
+      if (role === 'user') return null;
+      return normalizePart(part, sid);
+    }
+
+    if (payload.type === 'session.status' && payload.properties?.status?.type === 'error') {
+      return { type: 'error', error: payload.properties.status };
+    }
+
+    return null;
+  };
+}
+
+export const acpHttpProtocolHandler = createACPHttpProtocolHandler();
+
+// Parse one SSE "data: {...}\n\n" frame (or a raw chunk containing several)
+// into an array of parsed JSON payloads. opencode's /global/event stream
+// uses the standard `data: <json>\n\n` SSE framing (live-confirmed).
+export function parseSSEChunk(chunk) {
+  const out = [];
+  for (const block of chunk.split('\n\n')) {
+    const line = block.trim();
+    if (!line.startsWith('data:')) continue;
+    const jsonText = line.slice(5).trim();
+    if (!jsonText) continue;
+    try { out.push(JSON.parse(jsonText)); } catch { /* partial frame, skip */ }
+  }
+  return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.1118",
+  "version": "1.0.1119",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",