groove-dev 0.27.206 → 0.27.208

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

@@ -0,0 +1,198 @@
+// GROOVE — Axom Runtime Model Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// The model is exercised with faked backends: what matters here is that verbs
+// dispatch on control mode, states derive honestly, and migration folds the
+// legacy keys without forking anyone's ledger.
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { AxomRuntimes, validateRuntime } from '../src/axom-runtimes.js';
+
+function fakeDaemon() {
+  const calls = { remote: [], server: [], connector: [], nudges: [], rechecks: [] };
+  const broadcasts = [];
+  return {
+    calls,
+    broadcasts,
+    grooveDir: mkdtempSync(join(tmpdir(), 'groove-axrt-')),
+    config: { axom: {} },
+    broadcast(m) { broadcasts.push(m); },
+    audit: { log() {} },
+    axom: {
+      endpoints: new Map(),
+      configure(entries) { calls.connector.push(entries); },
+      nudge(name) { calls.nudges.push(name); },
+      recheck(name) { calls.rechecks.push(name); },
+    },
+    axomRemote: {
+      async status(cfg) { calls.remote.push(['status', cfg]); return fakeDaemon._remoteStatus || { running: false }; },
+      async start(cfg) { calls.remote.push(['start', cfg]); return { started: true }; },
+      async stop(o, cfg) { calls.remote.push(['stop', o, cfg]); return { stopped: true, via: 'shutdown' }; },
+      async ensureTunnel(cfg) { calls.remote.push(['tunnel', cfg]); return { tunneled: true }; },
+    },
+    axomServer: {
+      instances: [],
+      list() { return this.instances; },
+      async start(id, opts) { calls.server.push(['start', id, opts]); return { id, port: 8737, status: 'running' }; },
+      async stop(id) { calls.server.push(['stop', id]); },
+    },
+  };
+}
+
+const SSH_RT = {
+  id: 'spark', name: 'Spark', url: 'http://127.0.0.1:8737', control: 'ssh',
+  ssh: { host: 'spark.local', user: 'axom' },
+  launch: { command: 'cd /x && PYTHONPATH=model python3 -u -m axom.cli serve --cpu' },
+};
+
+describe('AxomRuntimes', () => {
+  let daemon, model;
+
+  beforeEach(() => {
+    daemon = fakeDaemon();
+    model = new AxomRuntimes(daemon);
+    // The real broadcastStatus probes runtime URLs; record the push instead so
+    // these tests stay hermetic. The genuine payload has its own test below.
+    model.broadcastStatus = async () => { daemon.broadcasts.push({ type: 'axom:runtimes' }); };
+  });
+
+  it('migrates the legacy endpoint+remote pair into one ssh runtime', () => {
+    daemon.config.axom = {
+      endpoints: [{ name: 'local', url: 'http://127.0.0.1:8737' }],
+      remote: { host: 'edgexpert-aaa6.local', user: 'axom', port: 8737, command: 'python3 -m axom.cli serve', logPath: '/x.log' },
+    };
+    assert.equal(model.migrate(), true);
+    const [rt] = model.list();
+    assert.equal(rt.control, 'ssh');
+    assert.equal(rt.url, 'http://127.0.0.1:8737');
+    assert.equal(rt.ssh.host, 'edgexpert-aaa6.local');
+    assert.equal(rt.launch.command, 'python3 -m axom.cli serve');
+    assert.equal(model.activeId(), rt.id);
+    assert.equal(model.migrate(), false); // idempotent
+  });
+
+  it('migrates a lone endpoint into a connect-only runtime', () => {
+    daemon.config.axom = { endpoints: [{ name: 'other', url: 'http://127.0.0.1:9999' }] };
+    model.migrate();
+    assert.equal(model.list()[0].control, 'none');
+  });
+
+  it('start dispatches by control: ssh starts remotely and heals the tunnel', async () => {
+    model.add(SSH_RT);
+    await model.startRuntime('spark');
+    const kinds = daemon.calls.remote.map((c) => c[0]);
+    assert.ok(kinds.includes('start'));
+    assert.ok(kinds.includes('tunnel')); // reachability follows lifecycle
+    const cfg = daemon.calls.remote.find((c) => c[0] === 'start')[1];
+    assert.equal(cfg.host, 'spark.local');
+    assert.equal(cfg.command, SSH_RT.launch.command); // spec passed VERBATIM
+  });
+
+  it('start dispatches by control: local spawns and adopts the resulting port as its URL', async () => {
+    model.add({ id: 'here', name: 'This machine', control: 'local', launch: { command: 'axom' }, dataDir: '/home/axom/axom-serve/data' });
+    await model.startRuntime('here');
+    const [, id, opts] = daemon.calls.server[0];
+    assert.equal(id, 'here');
+    assert.equal(opts.dataDir, '/home/axom/axom-serve/data'); // ADOPTS the ledger
+    assert.equal(model.get('here').url, 'http://127.0.0.1:8737');
+  });
+
+  it('refuses lifecycle verbs on connect-only runtimes with an honest message', async () => {
+    model.add({ id: 'theirs', name: 'Theirs', url: 'http://127.0.0.1:7000', control: 'none' });
+    await assert.rejects(() => model.startRuntime('theirs'), /not controlled by GROOVE/);
+    await assert.rejects(() => model.stopRuntime('theirs'), /not controlled by GROOVE/);
+    await assert.rejects(() => model.heal('theirs'), /only ssh runtimes/);
+  });
+
+  it('derives ssh states honestly: tunnel-down vs stopped vs host-unreachable', async () => {
+    model.add({ ...SSH_RT, url: 'http://127.0.0.1:1' }); // nothing listens on :1
+    fakeDaemon._remoteStatus = { running: true };
+    assert.equal((await model.state('spark')).state, 'unreachable'); // up on host, tunnel down
+    fakeDaemon._remoteStatus = { running: false };
+    assert.equal((await model.state('spark')).state, 'stopped');
+    fakeDaemon._remoteStatus = { running: null, error: 'no route to host' };
+    const s = await model.state('spark');
+    assert.equal(s.state, 'unreachable');
+    assert.match(s.detail, /no route/);
+    delete fakeDaemon._remoteStatus;
+  });
+
+  it('reports connected when the connector has the stream', async () => {
+    model.add(SSH_RT);
+    daemon.axom.endpoints.set('spark', { status: 'connected' });
+    assert.equal((await model.state('spark')).state, 'connected');
+  });
+
+  it('status exposes exactly the verbs each state supports', async () => {
+    model.add({ id: 'theirs', name: 'Theirs', url: 'http://127.0.0.1:1', control: 'none' });
+    const { runtimes } = await model.status();
+    const theirs = runtimes.find((r) => r.id === 'theirs');
+    assert.equal(theirs.canStart, false);
+    assert.equal(theirs.canStop, false);
+    assert.equal(theirs.canHeal, false);
+  });
+
+  it('keeps the connector in sync with the runtime list', () => {
+    model.add(SSH_RT);
+    model.remove('spark');
+    const last = daemon.calls.connector.pop();
+    assert.deepEqual(last, []);
+  });
+
+  // Axom-UX flag 1: the GUI's runtime cards must move on events, not a poll.
+  it('pushes fresh runtime state on every mutation and lifecycle verb', async () => {
+    const seen = () => daemon.broadcasts.filter((b) => b.type === 'axom:runtimes').length;
+    model.add(SSH_RT);
+    assert.ok(seen() >= 1);
+    let n = seen();
+    model.update('spark', { name: 'Spark 2' });
+    assert.ok(seen() > n);
+    n = seen();
+    model.activate('spark');
+    assert.ok(seen() > n);
+    n = seen();
+    await model.startRuntime('spark');
+    assert.ok(seen() > n);
+    // Axom-UX flag 3: start pulls the connector in NOW — 'running' must not
+    // linger for a backoff cycle before becoming 'connected'.
+    assert.deepEqual(daemon.calls.nudges, ['spark']);
+    n = seen();
+    await model.stopRuntime('spark');
+    assert.ok(seen() > n);
+    // ...and stop re-probes so a stale 'connected' collapses with the verb.
+    assert.deepEqual(daemon.calls.rechecks, ['spark']);
+    n = seen();
+    model.remove('spark');
+    assert.ok(seen() > n);
+  });
+
+  it('broadcastStatus emits the full axom:runtimes payload', async () => {
+    const d = fakeDaemon();
+    const m = new AxomRuntimes(d);
+    m.add({ id: 'here', name: 'This machine', control: 'local' }); // no URL → no probe
+    const deadline = Date.now() + 2000;
+    while (!d.broadcasts.some((b) => b.type === 'axom:runtimes')) {
+      if (Date.now() > deadline) throw new Error('no axom:runtimes broadcast');
+      await new Promise((r) => setTimeout(r, 10));
+    }
+    const msg = d.broadcasts.find((b) => b.type === 'axom:runtimes');
+    assert.equal(msg.data.activeRuntimeId, 'here');
+    assert.equal(msg.data.runtimes[0].state, 'stopped');
+    assert.equal(msg.data.runtimes[0].canStart, true);
+  });
+});
+
+describe('validateRuntime', () => {
+  it('accepts the three shapes and rejects garbage', () => {
+    assert.equal(validateRuntime(SSH_RT), null);
+    assert.equal(validateRuntime({ id: 'x', name: 'X', control: 'local' }), null); // url comes from spawn
+    assert.equal(validateRuntime({ id: 'y', name: 'Y', url: 'http://127.0.0.1:1', control: 'none' }), null);
+    assert.ok(validateRuntime({ id: 'z', name: 'Z', control: 'teleport' }));
+    assert.ok(validateRuntime({ id: 'z', name: 'Z', control: 'none' })); // none requires url
+    assert.ok(validateRuntime({ id: 'z', name: 'Z', control: 'ssh', url: 'http://127.0.0.1:1', ssh: { host: 'h;rm', user: 'u' } }));
+  });
+});

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

@@ -6,28 +6,101 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { resolve } from 'path';
-import { ChatStore } from '../src/chatstore.js';
+import { ChatStore, mergeMessages } from '../src/chatstore.js';
+
+// Minimal registry: id -> {id, name}. Lets tests exercise the id→name
+// resolution that makes history survive rotation.
+function makeDaemon(agents = []) {
+  const map = new Map(agents.map((a) => [a.id, a]));
+  return {
+    grooveDir: null, // set per test
+    registry: {
+      _map: map,
+      get(id) { return map.get(id) || null; },
+      getAll() { return [...map.values()]; },
+      set(a) { map.set(a.id, a); },
+      delete(id) { map.delete(id); },
+    },
+  };
+}
 
 describe('ChatStore', () => {
-  let dir, store;
+  let dir, daemon, store;
 
   beforeEach(() => {
     dir = mkdtempSync(resolve(tmpdir(), 'groove-chat-'));
-    store = new ChatStore({ grooveDir: dir });
+    daemon = makeDaemon([{ id: 'a1', name: 'fullstack-1' }, { id: 'a2', name: 'planner-1' }]);
+    daemon.grooveDir = dir;
+    store = new ChatStore(daemon);
   });
   afterEach(() => {
     store.stop();
     try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
   });
 
-  it('appends and returns per-agent history', () => {
+  it('appends under the agent NAME when given an id', () => {
     store.append('a1', { from: 'user', text: 'hello', timestamp: 1 });
-    store.append('a1', { from: 'agent', text: 'hi', timestamp: 2 });
-    store.append('a2', { from: 'user', text: 'other', timestamp: 3 });
+    store.append('fullstack-1', { from: 'agent', text: 'hi', timestamp: 2 });
+
+    // Both routes land in one bucket — the name.
+    assert.deepEqual(store.get('a1').map((m) => m.text), ['hello', 'hi']);
+    assert.deepEqual(store.getAll()['fullstack-1'].map((m) => m.text), ['hello', 'hi']);
+    assert.equal(store.getAll().a1, undefined);
+  });
+
+  it('history survives rotation: new id, same name, same history', () => {
+    store.append('a1', { from: 'user', text: 'before rotation', timestamp: 1 });
+
+    // Rotation mints a new id; the name is stable.
+    daemon.registry.delete('a1');
+    daemon.registry.set({ id: 'a1-r9', name: 'fullstack-1' });
+
+    store.append('a1-r9', { from: 'agent', text: 'after rotation', timestamp: 2 });
+    assert.deepEqual(store.get('a1-r9').map((m) => m.text), ['before rotation', 'after rotation']);
+  });
+
+  it('remap() folds a dead-id entry into the live agent', () => {
+    // Simulates data written under an id while the registry didn't know it
+    // (stale client post mid-rotation) — the rotation:complete hook remaps it.
+    store.history['dead-id'] = [{ from: 'user', text: 'stranded', timestamp: 1 }];
+    store.remap('dead-id', 'a1');
+    assert.equal(store.history['dead-id'], undefined);
+    assert.deepEqual(store.get('a1').map((m) => m.text), ['stranded']);
+  });
+
+  it('migrate() reattaches id-keyed histories from the old store format', () => {
+    store.history = {
+      a1: [{ from: 'user', text: 'legacy', timestamp: 1 }],
+      'fullstack-1': [{ from: 'agent', text: 'current', timestamp: 2 }],
+      'ghost-id': [{ from: 'user', text: 'unresolvable', timestamp: 3 }],
+    };
+    const moved = store.migrate();
+    assert.equal(moved, 1);
+    assert.deepEqual(store.getAll()['fullstack-1'].map((m) => m.text), ['legacy', 'current']);
+    // Unresolvable keys are parked, never dropped.
+    assert.equal(store.getAll()['ghost-id'][0].text, 'unresolvable');
+  });
 
-    assert.equal(store.get('a1').length, 2);
-    assert.equal(store.get('a2').length, 1);
-    assert.deepEqual(store.getAll().a1.map((m) => m.text), ['hello', 'hi']);
+  it('view() keys live agents by CURRENT id and parks the rest by name', () => {
+    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
+  });
+
+  it('merge() is a union — a sparse client can never truncate server history', () => {
+    for (let i = 0; i < 10; i++) store.append('a1', { from: 'user', text: `m${i}`, timestamp: i });
+    // Client syncs only 2 messages (1 duplicate, 1 new).
+    store.merge('a1', [
+      { from: 'user', text: 'm3', timestamp: 3 },
+      { from: 'agent', text: 'fresh', timestamp: 99 },
+    ]);
+    const texts = store.get('a1').map((m) => m.text);
+    assert.equal(texts.length, 11);
+    assert.equal(texts.at(-1), 'fresh');
+    assert.ok(texts.includes('m0') && texts.includes('m9'));
   });
 
   it('strips attachment data URLs but keeps metadata', () => {
@@ -44,7 +117,7 @@ describe('ChatStore', () => {
     store.append('a1', { from: 'user', text: 'durable', timestamp: 1 });
     store.stop(); // flushes synchronously
 
-    const reloaded = new ChatStore({ grooveDir: dir });
+    const reloaded = new ChatStore(daemon);
     assert.equal(reloaded.get('a1')[0].text, 'durable');
     reloaded.stop();
   });
@@ -55,7 +128,7 @@ describe('ChatStore', () => {
     assert.ok(existsSync(resolve(dir, 'chat-history.json')));
     assert.ok(!existsSync(resolve(dir, 'chat-history.json.tmp')));
     const onDisk = JSON.parse(readFileSync(resolve(dir, 'chat-history.json'), 'utf8'));
-    assert.equal(onDisk.a1[0].text, 'x');
+    assert.equal(onDisk['fullstack-1'][0].text, 'x');
   });
 
   it('caps per-agent history', () => {
@@ -66,21 +139,40 @@ describe('ChatStore', () => {
     assert.equal(h.at(-1).text, 'm249');
   });
 
-  it('replace() swaps an agent history wholesale', () => {
-    store.append('a1', { from: 'user', text: 'old' });
-    store.replace('a1', [{ from: 'user', text: 'new1' }, { from: 'agent', text: 'new2' }]);
-    assert.deepEqual(store.get('a1').map((m) => m.text), ['new1', 'new2']);
-  });
-
-  it('remove() deletes an agent history', () => {
+  it('remove() deletes by name so a purge cannot haunt a future same-name agent', () => {
     store.append('a1', { from: 'user', text: 'x' });
-    store.remove('a1');
+    store.remove('fullstack-1');
     assert.equal(store.get('a1').length, 0);
   });
 
+  it('works without a registry (refs pass through verbatim)', () => {
+    const bare = new ChatStore({ grooveDir: mkdtempSync(resolve(tmpdir(), 'groove-chat-bare-')) });
+    bare.append('some-id', { from: 'user', text: 'x', timestamp: 1 });
+    assert.equal(bare.get('some-id')[0].text, 'x');
+    bare.stop();
+  });
+
   it('starts empty when the file is missing or corrupt', () => {
     const empty = new ChatStore({ grooveDir: mkdtempSync(resolve(tmpdir(), 'groove-chat-empty-')) });
     assert.deepEqual(empty.getAll(), {});
     empty.stop();
   });
 });
+
+describe('mergeMessages', () => {
+  it('dedupes on (timestamp, from, text) and sorts by time', () => {
+    const merged = mergeMessages(
+      [{ from: 'u', text: 'b', timestamp: 2 }, { from: 'u', text: 'a', timestamp: 1 }],
+      [{ from: 'u', text: 'a', timestamp: 1 }, { from: 'u', text: 'c', timestamp: 3 }],
+    );
+    assert.deepEqual(merged.map((m) => m.text), ['a', 'b', 'c']);
+  });
+
+  it('treats same text at different timestamps as distinct messages', () => {
+    const merged = mergeMessages(
+      [{ from: 'u', text: 'ok', timestamp: 1 }],
+      [{ from: 'u', text: 'ok', timestamp: 2 }],
+    );
+    assert.equal(merged.length, 2);
+  });
+});

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

@@ -143,9 +143,11 @@ describe('Watcher', () => {
     assert.throws(() => watcher.create('nope', { command: 'x' }), /Agent not found/);
   });
 
+  // Distinct commands — identical ones now re-attach to the running job rather
+  // than stacking up, so they would never reach the cap.
   it('caps active watches per agent', () => {
-    for (let i = 0; i < 5; i++) watcher.create('a1', { command: 'sleep 5', label: `w${i}` });
-    assert.throws(() => watcher.create('a1', { command: 'sleep 5' }), /already have 5/);
+    for (let i = 0; i < 5; i++) watcher.create('a1', { command: `sleep 5 # ${i}`, label: `w${i}` });
+    assert.throws(() => watcher.create('a1', { command: 'sleep 5 # 6' }), /already have 5/);
   });
 
   it('cancels a watch and stops its process', async () => {
@@ -206,6 +208,70 @@ describe('Watcher', () => {
     watcher2.stop();
   });
 
+  // ── no double-launch (regression: daemon rebuild re-ran a live job) ──
+  //
+  // A daemon restart resumes the agent mid-turn, so it re-issues the watch it
+  // believes never completed. Launching a second copy of a long job corrupts
+  // the first one's output and competes for the same hardware.
+
+  it('re-attaches instead of launching a second copy of a running command', async () => {
+    const marker = resolve(grooveDir, 'runs.txt');
+    const cmd = `echo run >> ${marker}; sleep 3`;
+
+    const first = watcher.create('a1', { command: cmd, label: 'champion v11' });
+    await settle(300);
+
+    const second = watcher.create('a1', { command: cmd, label: 'champion v11' });
+    assert.equal(second.id, first.id, 'the same watch is returned, not a new one');
+    assert.equal(second.reattached, true, 'the caller is told it re-attached');
+    assert.equal(
+      watcher.list().filter((w) => w.status === 'active').length, 1,
+      'only one active watch exists',
+    );
+
+    await settle(400);
+    const runs = readFileSync(marker, 'utf8').trim().split('\n').filter(Boolean);
+    assert.equal(runs.length, 1, 'the command executed exactly once');
+  });
+
+  it('does not re-attach once the original job has exited', async () => {
+    const cmd = 'exit 0';
+    const first = watcher.create('a1', { command: cmd, label: 'short' });
+    await settle(500); // job finishes and the watch fires
+
+    const second = watcher.create('a1', { command: cmd, label: 'short again' });
+    assert.notEqual(second.id, first.id, 'a finished job may legitimately be re-run');
+    assert.ok(!second.reattached);
+  });
+
+  it('reports a job that vanished while the daemon was down instead of polling to timeout', async () => {
+    const w = watcher.create('a1', { command: 'sleep 30', label: 'doomed' });
+    await settle(200);
+    watcher._killJob(watcher.watches.get(w.id));   // job dies during the outage
+    watcher.stop();
+    await settle(200);
+
+    const daemon2 = makeDaemon(grooveDir);
+    wireDelivery(daemon2);
+    const watcher2 = new Watcher(daemon2);
+    daemon2.watcher = watcher2;
+    daemon2.registry.add({ id: 'a1', name: 'fullstack-1', role: 'fullstack', provider: 'claude-code' });
+
+    watcher2.restore();
+    await settle(120);
+    assert.equal(daemon2.delivered.length, 1, 'the agent is told the job was lost');
+    assert.match(daemon2.delivered[0].message, /lost while the daemon was down/);
+    watcher2.stop();
+  });
+
+  it('appends to the run log so a re-run cannot erase the record', () => {
+    const w = watcher.create('a1', { command: 'echo hi', label: 'log' });
+    const script = readFileSync(resolve(grooveDir, 'watch-runs', w.id, 'run.sh'), 'utf8');
+    const outLine = script.split('\n').find((l) => l.includes('out.log'));
+    assert.ok(outLine.includes('>>'), 'the output redirect appends');
+    assert.ok(!/[^>]>\s*'[^']*out\.log/.test(outLine), 'the output log is never truncated');
+  });
+
   it('persists watches to disk', () => {
     watcher.create('a1', { command: 'sleep 5', label: 'persisted' });
     const raw = JSON.parse(readFileSync(resolve(grooveDir, 'watches.json'), 'utf8'));