agentgui 1.0.923 → 1.0.925

package/bin/gmgui.cjs

@@ -43,7 +43,8 @@ async function gmgui(args = []) {
 
     const port = process.env.PORT || 3000;
     const baseUrl = process.env.BASE_URL || '/gm';
-    const runtime = 'node';
+    const bunAvailable = (() => { try { return spawnSync('bun', ['--version'], { shell: true }).status === 0; } catch { return false; } })();
+    const runtime = bunAvailable ? 'bun' : 'node';
 
     return new Promise((resolve, reject) => {
       const ps = spawn(runtime, [path.join(projectRoot, 'server.js')], {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.923",
+  "version": "1.0.925",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",
@@ -16,9 +16,9 @@
   },
   "homepage": "https://github.com/AnEntrypoint/agentgui#readme",
   "scripts": {
-    "start": "node server.js",
+    "start": "bun server.js || node server.js",
     "dev": "node server.js --watch",
-    "postinstall": "node scripts/patch-fsbrowse.js && node scripts/copy-vendor.js",
+    "postinstall": "node scripts/patch-fsbrowse.js && node scripts/copy-vendor.js && (cd node_modules/better-sqlite3 && node-gyp rebuild 2>/dev/null) || true",
     "electron": "electron electron/main.js",
     "electron:dev": "PORT=3000 electron electron/main.js"
   },
@@ -28,7 +28,7 @@
     "@google/gemini-cli": "latest",
     "@kilocode/cli": "latest",
     "@lanmower/ccf": "^1.0.4",
-    "better-sqlite3": "^12.6.2",
+    "better-sqlite3": "^12.9.0",
     "busboy": "^1.6.0",
     "ccfollow": "^1.0.7",
     "execa": "^9.6.1",

package/test.js

@@ -131,21 +131,13 @@ await ok('agent-descriptors: initialize + cache', () => {
   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 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);
-});
-await ok('ws-optimizer: low-priority batches via timer', async () => {
-  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 });
-  assert.equal(sent.length, 0);
-  await new Promise(r => setTimeout(r, 40));
-  assert.equal(sent.length, 1); assert.equal(sent[0].length, 2);
-  opt.removeClient(ws);
+await ok('ws-optimizer: high-priority flush + low-priority batch', async () => {
+  const opt = new WSOptimizer(); const s1 = []; const s2 = [];
+  const w1 = { readyState: 1, clientId: 'c1', send: (b) => s1.push(decode(b)) };
+  const w2 = { readyState: 1, clientId: 'c2', latencyTier: 'excellent', send: (b) => s2.push(decode(b)) };
+  opt.sendToClient(w1, { type: 'streaming_start', id: 1 }); assert.equal(s1.length, 1); opt.removeClient(w1); assert.equal(opt.getStats().clients, 0);
+  opt.sendToClient(w2, { type: 'tts_audio', n: 1 }); opt.sendToClient(w2, { type: 'tts_audio', n: 2 }); assert.equal(s2.length, 0);
+  await new Promise(r => setTimeout(r, 40)); assert.equal(s2.length, 1); assert.equal(s2[0].length, 2); opt.removeClient(w2);
 });
 await ok('acp-protocol: session/update + result + error mapping', () => {
   const h = createACPProtocolHandler(); const ctx = { sessionId: 's1' };
@@ -161,23 +153,47 @@ await ok('acp-protocol: session/update + result + error mapping', () => {
 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']);
+  const sm = mockRes(); sendJSON(req, sm, 200, { ok: 1 }); assert.equal(sm.statusCode, 200); assert.equal(sm.headers['Content-Type'], 'application/json');
+  const big = mockRes(); compressAndSend(req, big, 200, 'text/plain', 'x'.repeat(2000)); assert.equal(big.headers['Content-Encoding'], 'gzip');
+  const ng = mockRes(); compressAndSend({ headers: {} }, ng, 200, 'text/html', 'y'.repeat(2000)); assert.equal(ng.headers['Cache-Control'], 'no-store');
 });
 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);
+  const p = new JsonlParser({ broadcastSync: () => {}, queries: { getConversationByClaudeSessionId: () => null } });
+  p.registerSession('s1', 'c1', 'd1'); assert.equal(p._convMap.get('s1'), 'c1');
+  p.removeSid('s1'); assert.equal(p._convMap.has('s1'), false);
+  p.registerSession('s2', 'c2', 'd2'); p.clear(); assert.equal(p._convMap.size, 0);
+});
+await okDb('conv-routes+thread-routes+auth-config+util-routes', async () => {
+  const [{ register: rC }, { register: rT }, { register: rA }, { register: rU }] = await Promise.all(['./lib/routes-conversations.js','./lib/routes-threads.js','./lib/routes-auth-config.js','./lib/routes-util.js'].map(m => import(m)));
+  const { db: d2, prep: p2, gid: g2 } = inMemDb(); const q2 = createQueries(d2, p2, g2);
+  const sj2 = (req, res, c, data) => { res.statusCode = c; res.body = JSON.stringify(data); };
+  const pb2 = async (req) => req?._b || {}; const mr = () => mockRes();
+  const cR = rC({ sendJSON: sj2, parseBody: pb2, queries: q2, activeExecutions: new Map(), broadcastSync: () => {} });
+  const c1 = q2.createConversation('claude-code', 'T');
+  const lr = mr(); await cR['GET /api/conversations'](null, lr); assert.equal(lr.statusCode, 200);
+  const cr = mr(); await cR['POST /api/conversations']({ _b: { agentId: 'claude-code', title: 'N' } }, cr);
+  assert.equal(cr.statusCode, 201); const nid = JSON.parse(cr.body).conversation.id;
+  const gr = mr(); await cR._match('GET', `/api/conversations/${nid}`)(null, gr); assert.equal(gr.statusCode, 200);
+  const dr = mr(); await cR._match('DELETE', `/api/conversations/${nid}`)(null, dr); assert.equal(dr.statusCode, 200);
+  const nr = mr(); await cR._match('GET', '/api/conversations/nope')(null, nr); assert.equal(nr.statusCode, 404);
+  const ar = mr(); await cR._match('POST', `/api/conversations/${c1.id}/archive`)(null, ar); assert.equal(ar.statusCode, 200);
+  const rr = mr(); await cR._match('POST', `/api/conversations/${c1.id}/restore`)(null, rr); assert.equal(rr.statusCode, 200);
+  const tR = rT({ sendJSON: sj2, parseBody: pb2, queries: q2 });
+  const tr = mr(); await tR['POST /api/threads']({ _b: { metadata: { k: 1 } } }, tr); assert.equal(tr.statusCode, 201);
+  const tid = JSON.parse(tr.body).thread_id;
+  const tgr = mr(); await tR._match('GET', `/api/threads/${tid}`)(null, tgr); assert.equal(tgr.statusCode, 200);
+  const tpr = mr(); await tR._match('PATCH', `/api/threads/${tid}`)({ _b: { metadata: { k: 2 } } }, tpr); assert.equal(tpr.statusCode, 200);
+  const tsr = { statusCode: 0, writeHead: (c) => { tsr.statusCode = c; }, end: () => {} };
+  await tR._match('DELETE', `/api/threads/${tid}`)(null, tsr); assert.equal(tsr.statusCode, 204);
+  const ssr = mr(); await tR['POST /api/threads/search']({ _b: {} }, ssr); assert.equal(ssr.statusCode, 200);
+  const aR = rA({ sendJSON: sj2, parseBody: pb2, getProviderConfigs: () => ({ anthropic: { hasKey: false } }), saveProviderConfig: () => '/x' });
+  const agr = mr(); aR['GET /api/auth/configs'](null, agr); assert.equal(agr.statusCode, 200); assert.ok(JSON.parse(agr.body).anthropic !== undefined);
+  const br = mr(); await aR['POST /api/auth/save-config']({ _b: { providerId: '', apiKey: 'x' } }, br); assert.equal(br.statusCode, 400);
+  const sr = mr(); await aR['POST /api/auth/save-config']({ _b: { providerId: 'anthropic', apiKey: 'sk-123456789' } }, sr); assert.equal(sr.statusCode, 200);
+  const uR = rU({ sendJSON: sj2, parseBody: pb2, queries: q2, STARTUP_CWD: process.cwd(), PKG_VERSION: '1.0.0' });
+  const hr = mr(); await uR['GET /api/home'](null, hr); assert.equal(hr.statusCode, 200); assert.ok(JSON.parse(hr.body).home);
+  const vr = mr(); await uR['GET /api/version'](null, vr); assert.equal(vr.statusCode, 200);
+  const fr = mr(); await uR['POST /api/folders']({ _b: { path: process.cwd() } }, fr); assert.equal(fr.statusCode, 200); assert.ok(Array.isArray(JSON.parse(fr.body).folders));
 });
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);