groove-dev 0.27.210 → 0.27.212

package/node_modules/@groove-dev/daemon/test/axom-connector.test.js

@@ -463,6 +463,47 @@ describe('AxomConnector', () => {
     assert.ok(bridge.epochsSeen.includes('epoch-A')); // we did present the old epoch
   });
 
+  // Streaming answers: deltas are cosmetic chunks superseded by the terminal
+  // `resolution`. They must reach the GUI live but never enter the ring — the
+  // runtime omits them from its own replay, so a backfilled tab and a
+  // reconnecting one must see identical history.
+  it('delivers resolution deltas live but keeps them out of the replay ring', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.status === 'connected');
+    await waitFor(() => connector.status().endpoints[0]?.sessions[0]?.watching);
+
+    bridge.emit('s-test0001', envelope(1, 'pipeline_start'));
+    bridge.emit('s-test0001', envelope(2, 'resolution_delta', { firing_id: 'f1', content: 'Hello ', index: 0 }));
+    bridge.emit('s-test0001', envelope(3, 'resolution_delta', { firing_id: 'f1', content: 'world', index: 1 }));
+    bridge.emit('s-test0001', envelope(4, 'resolution', { content: 'Hello world.' }));
+
+    // Every delta still BROADCASTS — delivery is untouched.
+    await waitFor(() => daemon.broadcasts.filter((b) => b.type === 'axom:event').length === 4);
+    const kinds = daemon.broadcasts.filter((b) => b.type === 'axom:event').map((b) => b.envelope.kind);
+    assert.deepEqual(kinds, ['pipeline_start', 'resolution_delta', 'resolution_delta', 'resolution']);
+
+    // ...but the ring holds only the durable history.
+    const backfill = connector.events('local', 's-test0001');
+    assert.deepEqual(backfill.events.map((e) => e.kind), ['pipeline_start', 'resolution']);
+    // Excluded, not overflowed — dropping them is by design, not pressure.
+    assert.equal(connector.status().endpoints[0].sessions[0].overflow, 0);
+    // A known kind now, so it must not read as schema drift.
+    assert.equal(connector.status().endpoints[0].sessions[0].unknownKinds.resolution_delta, undefined);
+  });
+
+  it('a delta never breaks dedup for the events that follow it', async () => {
+    connect();
+    await waitFor(() => connector.status().endpoints[0]?.status === 'connected');
+    await waitFor(() => connector.status().endpoints[0]?.sessions[0]?.watching);
+    bridge.emit('s-test0001', envelope(1, 'resolution_delta', { firing_id: 'f1', content: 'x', index: 0 }));
+    bridge.emit('s-test0001', envelope(2, 'resolution', { content: 'x!' }));
+    await waitFor(() => daemon.broadcasts.filter((b) => b.type === 'axom:event').length === 2);
+    // Replaying an id at or below the delta's must still be suppressed.
+    bridge.emit('s-test0001', envelope(1, 'resolution_delta', { firing_id: 'f1', content: 'x', index: 0 }));
+    await new Promise((r) => setTimeout(r, 120));
+    assert.equal(daemon.broadcasts.filter((b) => b.type === 'axom:event').length, 2);
+  });
+
   it('recheck collapses a stale connected state the moment the runtime is gone', async () => {
     connect();
     await waitFor(() => connector.status().endpoints[0]?.status === 'connected');

package/node_modules/@groove-dev/daemon/test/chatstore.test.js

@@ -81,13 +81,16 @@ describe('ChatStore', () => {
     assert.equal(store.getAll()['ghost-id'][0].text, 'unresolvable');
   });
 
-  it('view() keys live agents by CURRENT id and parks the rest by name', () => {
+  it('view() keys live agents by CURRENT id and omits departed ones', () => {
     store.append('a1', { from: 'user', text: 'live', timestamp: 1 });
     store.history['departed-agent'] = [{ from: 'user', text: 'old', timestamp: 2 }];
     const v = store.view();
     assert.equal(v.a1[0].text, 'live');            // fullstack-1 → its live id
     assert.equal(v['fullstack-1'], undefined);
-    assert.equal(v['departed-agent'][0].text, 'old'); // no live agent — name key
+    // Departed agents stay on disk but are not shipped — the payload used to
+    // be 97% dead agents, which blew the browser's localStorage quota.
+    assert.equal(v['departed-agent'], undefined);
+    assert.equal(store.getAll()['departed-agent'][0].text, 'old');
   });
 
   it('merge() is a union — a sparse client can never truncate server history', () => {
@@ -176,3 +179,65 @@ describe('mergeMessages', () => {
     assert.equal(merged.length, 2);
   });
 });
+
+describe('ChatStore — agent-reply persistence regression', () => {
+  let dir, daemon, store;
+
+  beforeEach(() => {
+    dir = mkdtempSync(resolve(tmpdir(), 'groove-chat-reg-'));
+    daemon = makeDaemon([{ id: 'live1', name: 'fullstack-1' }]);
+    daemon.grooveDir = dir;
+    store = new ChatStore(daemon);
+  });
+  afterEach(() => {
+    store.stop();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('upserts a coalescing streamed reply instead of accumulating fragments', () => {
+    // The GUI grows one message as chunks stream in, keeping its id.
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'Part one', timestamp: 10 }]);
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'Part one\n\nPart two', timestamp: 11 }]);
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'Part one\n\nPart two\n\nPart three', timestamp: 12 }]);
+
+    const h = store.get('live1');
+    assert.equal(h.length, 1, 'one message, not one per chunk');
+    assert.equal(h[0].text, 'Part one\n\nPart two\n\nPart three');
+  });
+
+  it('never regresses a message to an earlier, shorter state', () => {
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'full long reply', timestamp: 20 }]);
+    store.merge('live1', [{ id: 'm1', from: 'agent', text: 'full', timestamp: 19 }]); // stale client
+    assert.equal(store.get('live1')[0].text, 'full long reply');
+  });
+
+  it('view() ships only live agents — dead buckets stay on disk but off the wire', () => {
+    store.append('live1', { id: 'a', from: 'agent', text: 'hi', timestamp: 1 });
+    store.history['long-gone-agent'] = [{ id: 'b', from: 'agent', text: 'old', timestamp: 2 }];
+
+    const v = store.view();
+    assert.deepEqual(Object.keys(v), ['live1'], 'payload carries live agents only');
+    assert.ok(store.getAll()['long-gone-agent'], 'but the data is retained on disk');
+  });
+
+  it('a respawned agent with the same name picks its history back up', () => {
+    store.append('live1', { id: 'a', from: 'agent', text: 'earlier work', timestamp: 1 });
+    // Agent dies and is later recreated with a different id, same name.
+    daemon.registry.delete('live1');
+    daemon.registry.set({ id: 'live1-new', name: 'fullstack-1' });
+    assert.equal(store.view()['live1-new'][0].text, 'earlier work');
+  });
+
+  it('prune() bounds dead buckets and never touches live agents', () => {
+    store.append('live1', { id: 'a', from: 'agent', text: 'keep me', timestamp: 999 });
+    for (let i = 0; i < 10; i++) {
+      store.history[`dead-${i}`] = [{ id: `d${i}`, from: 'agent', text: 'x', timestamp: i }];
+    }
+    const removed = store.prune(4);
+    assert.equal(removed, 6);
+    assert.equal(store.get('live1')[0].text, 'keep me');
+    assert.equal(Object.keys(store.getAll()).filter((k) => k.startsWith('dead-')).length, 4);
+    // The survivors are the most recently active dead buckets.
+    assert.ok(store.getAll()['dead-9'] && !store.getAll()['dead-0']);
+  });
+});

package/node_modules/@groove-dev/daemon/test/reach-hint.test.js

@@ -0,0 +1,100 @@
+// GROOVE — Agent reach hint (InnerChat discoverability)
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Spawn-prompt capabilities decay out of a long session, after which agents
+// deny they can contact anyone. These pin the per-turn hint that replaces it.
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { agentReachHint } from '../src/deliver.js';
+
+function daemonWith(agents, peers = []) {
+  return {
+    registry: { getAll: () => agents },
+    config: { innerchatPeers: peers },
+  };
+}
+
+const me = { name: 'fullstack-3', role: 'fullstack' };
+const roster = [me, { name: 'Integration-Manager', role: 'fullstack' }, { name: 'Axom-UX', role: 'frontend' }];
+
+describe('agentReachHint', () => {
+  it('always names the CLI verbs, even on an unrelated turn', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'refactor the token parser');
+    assert.match(hint, /groove ask/);
+    assert.match(hint, /groove who/);
+  });
+
+  it('rules out the built-in sub-agent tools that cannot reach GROOVE agents', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'anything');
+    assert.match(hint, /CANNOT reach them/i);
+  });
+
+  it('expands to a ready-to-run command naming the agent the user meant', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'ask Integration-Manager about the relay shape');
+    assert.match(hint, /groove ask Integration-Manager "your question here"/);
+    assert.doesNotMatch(hint, /<name>/, 'should not leave a placeholder to fill in');
+  });
+
+  it('falls back to the roster when intent is clear but the target is not', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'coordinate with the other agents on this');
+    assert.match(hint, /groove who/);
+    assert.match(hint, /Integration-Manager, Axom-UX/);
+  });
+
+  it('does not resolve a target from an ambiguous partial mention', () => {
+    const two = [me, { name: 'fullstack-1', role: 'x' }, { name: 'fullstack-2', role: 'x' }];
+    const hint = agentReachHint(daemonWith(two), me, 'ask fullstack about it');
+    assert.doesNotMatch(hint, /groove ask fullstack-1 "/);
+    assert.match(hint, /groove who/);
+  });
+
+  it('never suggests messaging yourself', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'ask fullstack-3 what it thinks');
+    assert.doesNotMatch(hint, /groove ask fullstack-3 "/);
+  });
+
+  it('mentions peer machines and the name@peer form when peers exist', () => {
+    const hint = agentReachHint(daemonWith(roster, [{ alias: 'spark' }]), me, 'ask someone about it');
+    assert.match(hint, /name@peer/);
+    assert.match(hint, /spark/);
+  });
+
+  it('stays silent when there is genuinely nobody to talk to', () => {
+    assert.equal(agentReachHint(daemonWith([me]), me, 'ask someone'), null);
+  });
+
+  // Naming the feature is an explicit request — the tier that must never rely
+  // on heuristics, because it is typically typed AFTER the agent has already
+  // claimed the capability does not exist.
+  it('re-sends the full reference when the user names InnerChat', () => {
+    for (const phrase of ['use innerChat', 'inner chat', 'inner-chat', 'InnerChat please', 'run groove ask']) {
+      const hint = agentReachHint({ port: 31415, ...daemonWith(roster) }, me, `${phrase} with the team`);
+      assert.match(hint, /Full reference/, `"${phrase}" should trigger the full block`);
+      assert.match(hint, /groove ask/);
+    }
+  });
+
+  it('tells the agent the feature is real when explicitly asked for it', () => {
+    const hint = agentReachHint({ port: 31415, ...daemonWith(roster) }, me, 'use innerchat');
+    assert.match(hint, /It exists, it is wired up/);
+    assert.match(hint, /Do not tell the user the feature is/);
+  });
+
+  it('still resolves the named target alongside the full reference', () => {
+    const hint = agentReachHint({ port: 31415, ...daemonWith(roster) }, me, 'use innerchat with Axom-UX');
+    assert.match(hint, /groove ask Axom-UX "your question here"/);
+    assert.match(hint, /Full reference/);
+  });
+
+  it('does not pay for the full reference on an ordinary turn', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'refactor the parser');
+    assert.doesNotMatch(hint, /Full reference/);
+    assert.ok(hint.length < 400, 'the always-on tier must stay cheap');
+  });
+
+  it('survives a broken registry rather than blocking delivery', () => {
+    const broken = { registry: { getAll() { throw new Error('boom'); } } };
+    assert.equal(agentReachHint(broken, me, 'ask someone'), null);
+  });
+});

package/node_modules/@groove-dev/daemon/test/tunnel-manager.test.js

@@ -0,0 +1,183 @@
+// GROOVE — TunnelManager Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Regression coverage for wake-from-sleep recovery. The failure these guard
+// against: an SSH tunnel cut by a laptop sleep leaves a local listener that
+// still ACCEPTS TCP connections but never forwards them. A TCP-connect probe
+// calls that healthy, so the dead tunnel was handed out forever and the remote
+// GUI loaded a port that hung instead of failing — a black window that only a
+// full app restart cleared.
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { resolve } from 'path';
+import { createServer } from 'net';
+import { TunnelManager } from '../src/tunnel-manager.js';
+
+function makeDaemon(grooveDir) {
+  const broadcasts = [];
+  return {
+    broadcasts,
+    grooveDir,
+    projectDir: process.cwd(),
+    audit: { log() {} },
+    broadcast(m) { broadcasts.push(m); },
+  };
+}
+
+// A tunnel wedged by sleep: the socket is accepted and then ignored forever.
+function startWedgedListener() {
+  const sockets = [];
+  const server = createServer((sock) => { sockets.push(sock); });
+  return new Promise((res) => {
+    server.listen(0, '127.0.0.1', () => {
+      res({
+        port: server.address().port,
+        close: () => { for (const s of sockets) s.destroy(); server.close(); },
+      });
+    });
+  });
+}
+
+// A tunnel that works — answers /api/health like the remote daemon would.
+function startHealthyListener() {
+  const server = createServer((sock) => {
+    sock.on('data', () => {
+      const body = '{"ok":true}';
+      sock.end(
+        'HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n'
+        + `Content-Length: ${body.length}\r\nConnection: close\r\n\r\n${body}`,
+      );
+    });
+  });
+  return new Promise((res) => {
+    server.listen(0, '127.0.0.1', () => {
+      res({ port: server.address().port, close: () => server.close() });
+    });
+  });
+}
+
+describe('TunnelManager — wake-from-sleep recovery', () => {
+  let daemon, mgr, grooveDir;
+
+  beforeEach(() => {
+    grooveDir = mkdtempSync(resolve(tmpdir(), 'groove-tunnel-'));
+    daemon = makeDaemon(grooveDir);
+    mgr = new TunnelManager(daemon);
+  });
+
+  afterEach(() => {
+    mgr.shutdown();
+    try { rmSync(grooveDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('a TCP-accept probe cannot tell a wedged tunnel from a live one', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      // This is what the old code trusted — and why the bug survived.
+      assert.equal(await mgr._isPortInUse(wedged.port), true);
+    } finally { wedged.close(); }
+  });
+
+  it('_tunnelResponds rejects a tunnel that accepts but never answers', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      assert.equal(await mgr._tunnelResponds(wedged.port, 1500), false);
+    } finally { wedged.close(); }
+  });
+
+  it('_tunnelResponds accepts a tunnel that actually serves', async () => {
+    const live = await startHealthyListener();
+    try {
+      assert.equal(await mgr._tunnelResponds(live.port, 3000), true);
+    } finally { live.close(); }
+  });
+
+  it('connect() rebuilds instead of handing back a wedged tunnel', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      mgr.saved.set('s19', {
+        id: 's19', name: 'S19 Agency', host: 'example.invalid',
+        user: 'ops', port: 22, lastConnected: new Date().toISOString(),
+      });
+      mgr.active.set('s19', {
+        pid: 999999, localPort: wedged.port, healthy: true, failCount: 0,
+        startedAt: new Date().toISOString(),
+      });
+
+      // Host is unreachable, so the rebuild fails — the point is that it TRIED
+      // rather than returning the dead port as if it were usable.
+      await assert.rejects(
+        () => mgr.connect('s19', { skipTest: false }),
+        (err) => !/^$/.test(err.message),
+      );
+      assert.equal(mgr.active.has('s19'), false, 'the dead tunnel was torn down');
+    } finally { wedged.close(); }
+  });
+
+  it('connect() reuses a tunnel that is genuinely alive', async () => {
+    const live = await startHealthyListener();
+    try {
+      mgr.saved.set('spark', { id: 'spark', name: 'DGX Spark', host: '10.0.0.5', user: 'rok', port: 22 });
+      mgr.active.set('spark', {
+        pid: 12345, localPort: live.port, healthy: true, failCount: 0,
+        startedAt: new Date().toISOString(),
+      });
+
+      const res = await mgr.connect('spark');
+      assert.equal(res.localPort, live.port, 'a working tunnel is reused, not rebuilt');
+      assert.equal(mgr.active.has('spark'), true);
+    } finally { live.close(); }
+  });
+
+  it('the health pass reaps a dead tunnel so the next connect starts clean', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      mgr.saved.set('s19', { id: 's19', name: 'S19 Agency', host: 'example.invalid', user: 'ops', port: 22 });
+      mgr.active.set('s19', {
+        pid: 999999, localPort: wedged.port, healthy: true,
+        failCount: 99, // already past the failure limit
+        startedAt: new Date().toISOString(),
+      });
+
+      await mgr._healthCheckAll();
+
+      assert.equal(mgr.active.has('s19'), false, 'dead tunnel removed from active');
+      assert.ok(
+        daemon.broadcasts.some((b) => b.type === 'tunnel.unhealthy'),
+        'the GUI is told the tunnel went unhealthy',
+      );
+    } finally { wedged.close(); }
+  });
+
+  it('treats a long timer gap as a sleep and drops the failure tolerance', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      mgr.saved.set('s19', { id: 's19', name: 'S19 Agency', host: 'example.invalid', user: 'ops', port: 22 });
+      mgr.active.set('s19', {
+        pid: 999999, localPort: wedged.port, healthy: true, failCount: 0,
+        startedAt: new Date().toISOString(),
+      });
+
+      // Last check was 10 minutes ago — the machine was asleep.
+      mgr._lastHealthCheck = Date.now() - 10 * 60 * 1000;
+      await mgr._healthCheckAll();
+
+      const conn = mgr.active.get('s19');
+      assert.equal(conn?.healthy, false, 'one failure after a sleep gap is enough');
+    } finally { wedged.close(); }
+  });
+
+  it('_waitForPortFree reports a released port', async () => {
+    const live = await startHealthyListener();
+    assert.equal(await mgr._waitForPortFree(live.port, 600), false, 'still held while listening');
+    live.close();
+    assert.equal(await mgr._waitForPortFree(live.port, 3000), true, 'free once closed');
+  });
+
+  it('_waitForExit returns true for a pid that does not exist', async () => {
+    assert.equal(await mgr._waitForExit(999999, 500), true);
+  });
+});