agentgui 1.0.906 → 1.0.907

package/package.json

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

package/test.js

@@ -14,10 +14,12 @@ import { maskKey, buildSystemPrompt } from './lib/provider-config.js';
 import { buildBaseUrl, isRemoteRequest, encodeOAuthState, decodeOAuthState } from './lib/oauth-common.js';
 import { compareVersions } from './lib/tool-version-check.js';
 import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descriptors.js';
+import { createACPProtocolHandler } from './lib/acp-protocol.js';
+import { sendJSON, compressAndSend, acceptsEncoding } from './lib/http-utils.js';
+import { JsonlParser } from './lib/jsonl-parser.js';
 const require = createRequire(import.meta.url);
 let Database;
 try { Database = (await import('bun:sqlite')).default; } catch { Database = require('better-sqlite3'); }
-
 let passed = 0, failed = 0;
 const ok = (name, fn) => Promise.resolve().then(fn).then(
   () => { console.log(`ok — ${name}`); passed++; },
@@ -25,26 +27,26 @@ const ok = (name, fn) => Promise.resolve().then(fn).then(
 function inMemDb() {
   const db = new Database(':memory:');
   if (db.pragma) db.pragma('foreign_keys = ON'); else db.run('PRAGMA foreign_keys = ON');
-  const origLog = console.log, origWarn = console.warn;
-  console.log = () => {}; console.warn = () => {};
+  const oL = console.log, oW = console.warn; console.log = () => {}; console.warn = () => {};
   try { initSchema(db); migrateConversationColumns(db); migrateACPSchema(db); }
-  finally { console.log = origLog; console.warn = origWarn; }
+  finally { console.log = oL; console.warn = oW; }
   const gid = (p) => `${p}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
   return { db, prep: (sql) => db.prepare(sql), gid };
 }
+function mockRes() {
+  const r = { headers: {}, body: null, statusCode: 0 };
+  r.writeHead = (s, h) => { r.statusCode = s; r.headers = h; };
+  r.end = (b) => { r.body = b; };
+  return r;
+}
 const run = async () => {
 await ok('codec: roundtrip + binary', () => {
-  const obj = { a: 1, b: 'str', c: [1, 2, 3], d: { nested: true } };
-  assert.deepEqual(decode(encode(obj)), obj);
-  const round = decode(encode({ bin: Buffer.from([1, 2, 3, 4]) }));
-  assert.deepEqual(Array.from(round.bin), [1, 2, 3, 4]);
+  assert.deepEqual(decode(encode({ a: 1, b: 'str', c: [1, 2, 3], d: { nested: true } })), { a: 1, b: 'str', c: [1, 2, 3], d: { nested: true } });
+  assert.deepEqual(Array.from(decode(encode({ bin: Buffer.from([1, 2, 3, 4]) })).bin), [1, 2, 3, 4]);
 });
-
 await ok('db: init schema creates conversations table', () => {
-  const { db } = inMemDb();
-  assert.ok(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='conversations'").get());
+  assert.ok(inMemDb().db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='conversations'").get());
 });
-
 await ok('db-queries: createConversation round-trip', () => {
   const { db, prep, gid } = inMemDb();
   const q = createQueries(db, prep, gid);
@@ -52,7 +54,6 @@ await ok('db-queries: createConversation round-trip', () => {
   assert.equal(q.getConversation(c.id).title, 'Test');
   assert.equal(q.getConversation(c.id).status, 'active');
 });
-
 await ok('db-queries: archive + restore + streaming flag', () => {
   const { db, prep, gid } = inMemDb();
   const q = createQueries(db, prep, gid);
@@ -62,7 +63,6 @@ await ok('db-queries: archive + restore + streaming flag', () => {
   q.setIsStreaming(c.id, true); assert.equal(q.getIsStreaming(c.id), true);
   q.setIsStreaming(c.id, false); assert.equal(q.getIsStreaming(c.id), false);
 });
-
 await ok('acp-queries: thread crud + search', () => {
   const { db, prep, gid } = inMemDb();
   const q = createQueries(db, prep, gid);
@@ -73,13 +73,11 @@ await ok('acp-queries: thread crud + search', () => {
   q.createThread({ kind: 'b' });
   assert.equal(q.searchThreads({}).total, 2);
 });
-
 await ok('WsRouter: dispatch + 404 + error + legacy', async () => {
   const router = new WsRouter();
   router.handle('ping', async (p) => ({ pong: p.n }));
   router.handle('boom', async () => { throw Object.assign(new Error('kaboom'), { code: 422 }); });
-  let legacy = null;
-  router.onLegacy((m) => { legacy = m; });
+  let legacy = null; router.onLegacy((m) => { legacy = m; });
   const replies = [];
   const ws = { readyState: 1, send: (b) => replies.push(decode(b)), clientId: 'c' };
   await router.onMessage(ws, encode({ r: 1, m: 'ping', p: { n: 7 } }));
@@ -87,11 +85,8 @@ await ok('WsRouter: dispatch + 404 + error + legacy', async () => {
   await router.onMessage(ws, encode({ r: 3, m: 'boom', p: {} }));
   await router.onMessage(ws, encode({ type: 'subscribe', id: 'x' }));
   assert.deepEqual(replies[0], { r: 1, d: { pong: 7 } });
-  assert.equal(replies[1].e.c, 404);
-  assert.equal(replies[2].e.c, 422);
-  assert.equal(legacy.type, 'subscribe');
+  assert.equal(replies[1].e.c, 404); assert.equal(replies[2].e.c, 422); assert.equal(legacy.type, 'subscribe');
 });
-
 await ok('machines: tool-install + execution + acp-server lifecycle', () => {
   assert.ok(tim.getMachineActors() instanceof Map);
   assert.equal(exm.snapshot('nonexistent-conv-id'), null);
@@ -102,99 +97,102 @@ await ok('machines: tool-install + execution + acp-server lifecycle', () => {
   assert.equal(asm.isHealthy('test-tool'), true);
   asm.stopAll();
 });
-
 await ok('workflow-plugin + agent-registry hermes', async () => {
   const wp = await import('./lib/plugins/workflow-plugin.js');
   assert.deepEqual(wp.default.dependencies, ['database']);
   const { registry } = await import('./lib/claude-runner-agents.js');
   const h = registry.get('hermes');
-  assert.equal(h.protocol, 'acp');
-  assert.deepEqual(h.buildArgs(), ['acp']);
+  assert.equal(h.protocol, 'acp'); assert.deepEqual(h.buildArgs(), ['acp']);
 });
-
 await ok('delete-all: soft-deletes + wipes related', () => {
   const { db, prep, gid } = inMemDb();
   const q = createQueries(db, prep, gid);
   const c1 = q.createConversation('claude-code', 'A');
   q.createConversation('claude-code', 'B');
-  q.createSession(c1.id);
-  q.createMessage(c1.id, 'user', 'hello');
-  const origLog = console.log; console.log = () => {};
-  try { q.deleteAllConversations(); } finally { console.log = origLog; }
-  const rows = db.prepare('SELECT status, count(*) as c FROM conversations GROUP BY status').all();
-  assert.deepEqual(rows, [{ status: 'deleted', c: 2 }]);
+  q.createSession(c1.id); q.createMessage(c1.id, 'user', 'hello');
+  const oL = console.log; console.log = () => {};
+  try { q.deleteAllConversations(); } finally { console.log = oL; }
+  assert.deepEqual(db.prepare('SELECT status, count(*) as c FROM conversations GROUP BY status').all(), [{ status: 'deleted', c: 2 }]);
   assert.equal(db.prepare('SELECT count(*) as c FROM messages').get().c, 0);
   assert.equal(q.getConversationsList().length, 0);
 });
-
 await ok('provider-config: maskKey + buildSystemPrompt', () => {
-  assert.equal(maskKey(''), '****');
-  assert.equal(maskKey('short'), '****');
-  assert.equal(maskKey('sk-abcd1234efgh'), '****efgh');
+  assert.equal(maskKey(''), '****'); assert.equal(maskKey('short'), '****'); assert.equal(maskKey('sk-abcd1234efgh'), '****efgh');
   assert.equal(buildSystemPrompt('claude-code'), '');
   assert.equal(buildSystemPrompt('opencode', 'sonnet'), 'Use opencode subagent for all tasks. Model: sonnet.');
   assert.equal(buildSystemPrompt('foo-·-bar', null, 'sub'), 'Use foo subagent for all tasks. Subagent: sub.');
 });
-
 await ok('oauth-common: state codec + url helpers', () => {
-  const enc = encodeOAuthState('csrf-tok', 'https://relay.test/cb');
-  const dec = decodeOAuthState(enc);
-  assert.equal(dec.csrfToken, 'csrf-tok');
-  assert.equal(dec.relayUrl, 'https://relay.test/cb');
-  const fallback = decodeOAuthState('not-base64-json');
-  assert.equal(fallback.csrfToken, 'not-base64-json');
-  assert.equal(fallback.relayUrl, null);
+  const dec = decodeOAuthState(encodeOAuthState('csrf-tok', 'https://relay.test/cb'));
+  assert.equal(dec.csrfToken, 'csrf-tok'); assert.equal(dec.relayUrl, 'https://relay.test/cb');
+  const fb = decodeOAuthState('not-base64-json');
+  assert.equal(fb.csrfToken, 'not-base64-json'); assert.equal(fb.relayUrl, null);
   const reqRemote = { headers: { 'x-forwarded-host': 'a.com', 'x-forwarded-proto': 'https' }, socket: {} };
-  assert.equal(buildBaseUrl(reqRemote, 3000), 'https://a.com');
-  assert.equal(isRemoteRequest(reqRemote), true);
+  assert.equal(buildBaseUrl(reqRemote, 3000), 'https://a.com'); assert.equal(isRemoteRequest(reqRemote), true);
   assert.equal(buildBaseUrl({ headers: {}, socket: {} }, 3000), 'http://127.0.0.1:3000');
   assert.equal(isRemoteRequest({ headers: {} }), false);
 });
-
 await ok('tool-version-check: compareVersions', () => {
-  assert.equal(compareVersions('1.0.0', '1.0.1'), true);
-  assert.equal(compareVersions('1.0.1', '1.0.0'), false);
-  assert.equal(compareVersions('1.0.0', '1.0.0'), false);
-  assert.equal(compareVersions('1.2', '1.2.1'), true);
+  assert.equal(compareVersions('1.0.0', '1.0.1'), true); assert.equal(compareVersions('1.0.1', '1.0.0'), false);
+  assert.equal(compareVersions('1.0.0', '1.0.0'), false); assert.equal(compareVersions('1.2', '1.2.1'), true);
   assert.equal(compareVersions('2.0.0', '1.99.99'), false);
-  assert.equal(compareVersions(null, '1.0.0'), false);
-  assert.equal(compareVersions('1.0.0', null), false);
+  assert.equal(compareVersions(null, '1.0.0'), false); assert.equal(compareVersions('1.0.0', null), false);
 });
-
 await ok('agent-descriptors: initialize + cache', () => {
-  const n = initializeDescriptors([{ id: 'claude-code', name: 'Claude Code', path: '/x' }]);
-  assert.equal(n, 1);
+  assert.equal(initializeDescriptors([{ id: 'claude-code', name: 'Claude Code', path: '/x' }]), 1);
   const d = getAgentDescriptor('claude-code');
   assert.equal(d.metadata.ref.name, 'Claude Code');
-  assert.ok(d.specs.input.properties.model);
-  assert.ok(d.specs.thread_state.properties.sessionId);
+  assert.ok(d.specs.input.properties.model); assert.ok(d.specs.thread_state.properties.sessionId);
   assert.equal(getAgentDescriptor('nope'), null);
 });
-
 await ok('ws-optimizer: high-priority flushes immediately', () => {
-  const opt = new WSOptimizer();
-  const sent = [];
+  const opt = new WSOptimizer(); const sent = [];
   const ws = { readyState: 1, clientId: 'c1', send: (b) => sent.push(decode(b)) };
   opt.sendToClient(ws, { type: 'streaming_start', id: 1 });
-  assert.equal(sent.length, 1);
-  assert.equal(sent[0].type, 'streaming_start');
-  opt.removeClient(ws);
-  assert.equal(opt.getStats().clients, 0);
+  assert.equal(sent.length, 1); assert.equal(sent[0].type, 'streaming_start');
+  opt.removeClient(ws); assert.equal(opt.getStats().clients, 0);
 });
-
 await ok('ws-optimizer: low-priority batches via timer', async () => {
-  const opt = new WSOptimizer();
-  const sent = [];
+  const opt = new WSOptimizer(); const sent = [];
   const ws = { readyState: 1, clientId: 'c2', latencyTier: 'excellent', send: (b) => sent.push(decode(b)) };
-  opt.sendToClient(ws, { type: 'tts_audio', n: 1 });
-  opt.sendToClient(ws, { type: 'tts_audio', n: 2 });
+  opt.sendToClient(ws, { type: 'tts_audio', n: 1 }); opt.sendToClient(ws, { type: 'tts_audio', n: 2 });
   assert.equal(sent.length, 0);
   await new Promise(r => setTimeout(r, 40));
-  assert.equal(sent.length, 1);
-  assert.equal(sent[0].length, 2);
+  assert.equal(sent.length, 1); assert.equal(sent[0].length, 2);
   opt.removeClient(ws);
 });
-
+await ok('acp-protocol: session/update + result + error mapping', () => {
+  const h = createACPProtocolHandler(); const ctx = { sessionId: 's1' };
+  assert.equal(h(null, ctx), null);
+  const chunk = h({ method: 'session/update', params: { sessionId: 's1', update: { sessionUpdate: 'agent_message_chunk', content: 'hi' } } }, ctx);
+  assert.equal(chunk.type, 'assistant'); assert.equal(chunk.message.content[0].text, 'hi');
+  const tc = h({ method: 'session/update', params: { sessionId: 's1', update: { sessionUpdate: 'tool_call', toolCallId: 'x', kind: 'read', rawInput: { p: 1 } } } }, ctx);
+  assert.equal(tc.message.content[0].type, 'tool_use');
+  assert.equal(h({ id: 1, result: { stopReason: 'end_turn', usage: {} } }, ctx).type, 'result');
+  assert.equal(h({ method: 'error', error: { message: 'x' } }, ctx).type, 'error');
+  assert.equal(h({ method: 'session/update', params: { sessionId: 's1', update: { sessionUpdate: 'unknown' } } }, ctx), null);
+});
+await ok('http-utils: sendJSON + compressAndSend size threshold', () => {
+  const req = { headers: { 'accept-encoding': 'gzip, deflate' } };
+  assert.equal(acceptsEncoding(req, 'gzip'), true); assert.equal(acceptsEncoding({ headers: {} }, 'gzip'), false);
+  const small = mockRes(); sendJSON(req, small, 200, { ok: 1 });
+  assert.equal(small.statusCode, 200); assert.equal(small.headers['Content-Type'], 'application/json');
+  assert.ok(!small.headers['Content-Encoding']);
+  const big = mockRes(); compressAndSend(req, big, 200, 'text/plain', 'x'.repeat(2000));
+  assert.equal(big.headers['Content-Encoding'], 'gzip');
+  const noGz = mockRes(); compressAndSend({ headers: {} }, noGz, 200, 'text/html', 'y'.repeat(2000));
+  assert.equal(noGz.headers['Cache-Control'], 'no-store'); assert.ok(!noGz.headers['Content-Encoding']);
+});
+await ok('jsonl-parser: register + remove + clear', () => {
+  const calls = []; const fakeQ = { getConversationByClaudeSessionId: () => null };
+  const p = new JsonlParser({ broadcastSync: (m) => calls.push(m), queries: fakeQ });
+  p.registerSession('claude-1', 'conv-1', 'db-sess-1');
+  assert.equal(p._convMap.get('claude-1'), 'conv-1'); assert.equal(p._sessions.get('claude-1'), 'db-sess-1');
+  p.removeSid('claude-1');
+  assert.equal(p._convMap.has('claude-1'), false); assert.equal(p._sessions.has('claude-1'), false);
+  p.registerSession('s2', 'c2', 'd2'); p.clear();
+  assert.equal(p._convMap.size, 0); assert.equal(p._sessions.size, 0); assert.equal(calls.length, 0);
+});
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);
 }; run();