clew-code 0.2.28 → 0.2.30

package/scripts/write-discovery-test2.cjs

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshDiscovery.test.ts';
+const code = `import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { MeshDiscovery, getGlobalDiscovery } from './MeshDiscovery.js';
+
+describe('MeshDiscovery', () => {
+  let discovery;
+
+  afterEach(() => {
+    if (discovery) discovery.close();
+  });
+
+  test('constructor generates localId', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.meshId).toBeTruthy();
+    expect(discovery.meshId.split('-').length).toBeGreaterThanOrEqual(3);
+  });
+
+  test('constructor accepts callbacks', () => {
+    let c = false;
+    discovery = new MeshDiscovery({ onPeerDiscovered: () => { c = true; } });
+    expect(discovery).toBeDefined();
+  });
+
+  test('setLocalName updates hostname and ID', () => {
+    discovery = new MeshDiscovery();
+    const oid = discovery.meshId;
+    discovery.setLocalName('custom');
+    expect(discovery.hostname).toBe('custom');
+    expect(discovery.meshId).not.toBe(oid);
+    expect(discovery.meshId).toContain('custom');
+  });
+
+  test('startAdvertising then close', async () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.isSharing).toBeFalse();
+    await discovery.startAdvertising(9999, '/cwd');
+    expect(discovery.isSharing).toBeTrue();
+    const mid = discovery.meshId;
+    expect(mid).toBeTruthy();
+  });
+
+  test('getPeers empty initially', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.getPeers()).toEqual([]);
+  });
+
+  test('getPeer undefined for unknown', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.getPeer('nobody')).toBeUndefined();
+  });
+
+  test('close stops advertising', () => {
+    discovery = new MeshDiscovery();
+    discovery.close();
+    expect(discovery.isSharing).toBeFalse();
+  });
+
+  test('getGlobalDiscovery singleton', () => {
+    expect(getGlobalDiscovery()).toBe(getGlobalDiscovery());
+  });
+});
+`;
+fs.writeFileSync(p, code, 'utf8');
+console.log('MeshDiscovery.test.ts rewritten');

package/scripts/write-server-final.cjs

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { MeshServer, getGlobalMeshServer } from './MeshServer.js';
+
+function mi(o) { return { id:'tp', hostname:'th', ip:'127.0.0.1', port:0, cwd:'/r', version:'t', lastSeen:Date.now(), status:'online', ...o }; }
+
+describe('MeshServer', () => {
+  let server;
+  beforeEach(() => { server = new MeshServer(); });
+  afterEach(() => { server.stop(); });
+
+  test('constructor creates instance', () => {
+    expect(server).toBeInstanceOf(MeshServer);
+    expect(server.port).toBe(0);
+  });
+
+  test('constructor accepts callbacks', () => {
+    const s = new MeshServer({ onMessage: () => {} });
+    expect(s).toBeInstanceOf(MeshServer);
+    s.stop();
+  });
+
+  test('getGlobalMeshServer singleton', () => {
+    expect(getGlobalMeshServer()).toBe(getGlobalMeshServer());
+  });
+
+  test('setCallbacks merges', () => {
+    server.setCallbacks({ onMessage: () => {} });
+    server.setCallbacks({ onTodo: () => {} });
+    expect(server).toBeInstanceOf(MeshServer);
+  });
+
+  test('isBusy/queueDepth initially false/0', () => {
+    expect(server.isBusy).toBeFalse();
+    expect(server.queueDepth).toBe(0);
+  });
+
+  test('getTodos empty, updateTodoStatus false for unknown', () => {
+    expect(server.getTodos()).toEqual([]);
+    expect(server.updateTodoStatus('x','done')).toBeFalse();
+  });
+
+  test('start returns port', async () => {
+    const port = await server.start(mi());
+    expect(typeof port).toBe('number');
+    expect(port).toBeGreaterThan(0);
+    expect(server.port).toBe(port);
+  });
+
+  test('start idempotent', async () => {
+    const p1 = await server.start(mi());
+    const p2 = await server.start(mi());
+    expect(p1).toBe(p2);
+  });
+
+  test('stop does not throw', () => {
+    expect(() => server.stop()).not.toThrow();
+  });
+
+  test('start-stop-start works', async () => {
+    await server.start(mi());
+    server.stop();
+    const p = await server.start(mi());
+    expect(p).toBeGreaterThan(0);
+  });
+
+  test('GET /mesh-info', async () => {
+    const port = await server.start(mi({ id:'info-test' }));
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-info\`);
+    expect(r.status).toBe(200);
+    const d = await r.json();
+    expect(d.id).toBe('info-test');
+    expect(d.isBusy).toBeFalse();
+  });
+
+  test('POST /mesh-msg fires callback', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', body: JSON.stringify({ from:'p2', text:'hello' }),
+    });
+    expect(r.status).toBe(200);
+    expect((await r.json()).ok).toBeTrue();
+    expect(m.from).toBe('p2');
+  });
+
+  test('POST /mesh-msg chunk info', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', body: JSON.stringify({ from:'p2', chunkGroup:'g1', chunkIndex:0 }),
+    });
+    expect(m.chunkGroup).toBe('g1');
+  });
+
+  test('POST /mesh-msg defaults', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, { method:'POST', body: JSON.stringify({}) });
+    expect(m.from).toBe('unknown');
+  });
+`;
+fs.writeFileSync(p, code, 'utf8');
+console.log('MeshServer.test.ts p1 written');

package/scripts/write-server-test.cjs

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { MeshServer, getGlobalMeshServer } from './MeshServer.js';
+
+function mi(o) { return { id:'tp', hostname:'th', ip:'127.0.0.1', port:0, cwd:'/r', version:'t', lastSeen:Date.now(), status:'online', ...o }; }
+
+describe('MeshServer', () => {
+  let server;
+  beforeEach(() => { server = new MeshServer(); });
+  afterEach(() => { server.stop(); });
+
+  test('constructor creates instance', () => {
+    expect(server).toBeInstanceOf(MeshServer);
+    expect(server.port).toBe(0);
+  });
+
+  test('constructor accepts callbacks', () => {
+    const s = new MeshServer({ onMessage: () => {} });
+    expect(s).toBeInstanceOf(MeshServer);
+    s.stop();
+  });
+
+  test('getGlobalMeshServer singleton', () => {
+    expect(getGlobalMeshServer()).toBe(getGlobalMeshServer());
+  });
+
+  test('setCallbacks merges', () => {
+    server.setCallbacks({ onMessage: () => {} });
+    server.setCallbacks({ onTodo: () => {} });
+    expect(server).toBeInstanceOf(MeshServer);
+  });
+
+  test('isBusy/queueDepth initially false/0', () => {
+    expect(server.isBusy).toBeFalse();
+    expect(server.queueDepth).toBe(0);
+  });
+
+  test('getTodos empty, updateTodoStatus false for unknown', () => {
+    expect(server.getTodos()).toEqual([]);
+    expect(server.updateTodoStatus('x','done')).toBeFalse();
+  });
+
+  test('start returns port', async () => {
+    const port = await server.start(mi());
+    expect(typeof port).toBe('number');
+    expect(port).toBeGreaterThan(0);
+    expect(server.port).toBe(port);
+  });
+
+  test('start idempotent', async () => {
+    const p1 = await server.start(mi());
+    const p2 = await server.start(mi());
+    expect(p1).toBe(p2);
+  });
+
+  test('stop does not throw', () => {
+    expect(() => server.stop()).not.toThrow();
+  });
+
+  test('start-stop-start works', async () => {
+    await server.start(mi());
+    server.stop();
+    const p = await server.start(mi());
+    expect(p).toBeGreaterThan(0);
+  });
+`;
+fs.writeFileSync(p, code, 'utf8');
+console.log('MeshServer.test.ts part 1 written');

package/scripts/write-server-test2.cjs

@@ -0,0 +1,99 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `
+  test('GET /mesh-info', async () => {
+    const port = await server.start(mi({ id:'info-test' }));
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-info\`);
+    expect(res.status).toBe(200);
+    const d = await res.json();
+    expect(d.id).toBe('info-test');
+    expect(d.isBusy).toBeFalse();
+  });
+
+  test('POST /mesh-msg fires callback', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ from:'p2', fromName:'w2', text:'hello' }),
+    });
+    expect(res.status).toBe(200);
+    expect((await res.json()).ok).toBeTrue();
+    expect(m.from).toBe('p2');
+    expect(m.text).toBe('hello');
+  });
+
+  test('POST /mesh-msg chunk info', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ from:'p2', text:'c', chunkGroup:'g1', chunkIndex:0, chunkTotal:2 }),
+    });
+    expect(m.chunkGroup).toBe('g1');
+    expect(m.chunkIndex).toBe(0);
+    expect(m.chunkTotal).toBe(2);
+  });
+
+  test('POST /mesh-msg defaults', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({}),
+    });
+    expect(m.from).toBe('unknown');
+    expect(m.text).toBe('');
+  });
+
+  test('POST /mesh-todo fires callback', async () => {
+    let t = null;
+    server.setCallbacks({ onTodo: todo => { t = todo; } });
+    const port = await server.start(mi());
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-todo\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ from:'p2', message:'fix' }),
+    });
+    expect(res.status).toBe(200);
+    expect((await res.json()).ok).toBeTrue();
+    expect(t.message).toBe('fix');
+  });
+
+  test('POST /mesh-todo defaults', async () => {
+    let t = null;
+    server.setCallbacks({ onTodo: todo => { t = todo; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-todo\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({}),
+    });
+    expect(t.from).toBe('unknown');
+    expect(t.message).toBe('');
+  });
+
+  test('POST /mesh-exec with onExec', async () => {
+    server.setCallbacks({ onExec: async () => ({ stdout:'ok', stderr:'', exitCode:0 }) });
+    const port = await server.start(mi());
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ command:'echo hi', from:'t' }),
+    });
+    expect(res.status).toBe(200);
+    expect((await res.json()).running).toBeTrue();
+  });
+
+  test('POST /mesh-exec 501 without onExec', async () => {
+    const port = await server.start(mi());
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ command:'hi', from:'t' }),
+    });
+    expect(res.status).toBe(501);
+    expect((await res.json()).stderr).toBe('Exec not supported');
+  });
+`;
+fs.appendFileSync(p, code, 'utf8');
+console.log('MeshServer.test.ts part 2 appended');

package/scripts/write-server-test3.cjs

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `
+  test('POST /mesh-exec queues when busy', async () => {
+    let resolve;
+    server.setCallbacks({ onExec: async () => new Promise(r => { resolve = r; }) });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'long', from:'t' }) });
+    expect(server.isBusy).toBeTrue();
+    const r2 = await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'q', from:'t' }) });
+    expect(r2.status).toBe(202);
+    expect((await r2.json()).queued).toBeTrue();
+    expect(server.queueDepth).toBe(1);
+    if (resolve) resolve({ stdout:'', stderr:'', exitCode:0 });
+    await new Promise(r => setTimeout(r, 50));
+  });
+
+  test('POST /mesh-exec 503 queue full', async () => {
+    let resolve;
+    server.setCallbacks({ onExec: async () => new Promise(r => { resolve = r; }) });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'first', from:'t' }) });
+    const max = server.maxQueueSize || 50;
+    for (let i=0; i<max; i++) {
+      await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:\`t-\${i}\`, from:'t' }) });
+    }
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'x', from:'t' }) });
+    expect(r.status).toBe(503);
+    expect((await r.json()).error).toBe('Queue full');
+    if (resolve) resolve({ stdout:'', stderr:'', exitCode:0 });
+    await new Promise(r => setTimeout(r, 50));
+  });
+
+  test('GET /mesh-queue-status', async () => {
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-queue-status\`);
+    expect(r.status).toBe(200);
+    const d = await r.json();
+    expect(d.isBusy).toBeFalse();
+    expect(d.queueDepth).toBe(0);
+    expect(d.currentTask).toBeNull();
+  });
+
+  test('POST /mesh-queue-cancel', async () => {
+    let resolve;
+    server.setCallbacks({ onExec: async () => new Promise(r => { resolve = r; }) });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'first', from:'t' }) });
+    const qr = await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'x', from:'t' }) });
+    const tid = (await qr.json()).id;
+    const cr = await fetch(\`http://127.0.0.1:\${port}/mesh-queue-cancel\`, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({ id: tid }) });
+    expect(cr.status).toBe(200);
+    expect((await cr.json()).ok).toBeTrue();
+    if (resolve) resolve({ stdout:'', stderr:'', exitCode:0 });
+    await new Promise(r => setTimeout(r, 50));
+  });
+`;
+fs.appendFileSync(p, code, 'utf8');
+console.log('MeshServer.test.ts part 3a appended');

package/scripts/write-server-test4.cjs

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `
+  test('POST /mesh-queue-cancel 404', async () => {
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-queue-cancel\`, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({ id:'nope' }) });
+    expect(r.status).toBe(404);
+  });
+
+  test('POST /mesh-queue-cancel 400', async () => {
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-queue-cancel\`, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify({}) });
+    expect(r.status).toBe(400);
+  });
+
+  test('POST /mesh-queue-cancel-all', async () => {
+    let resolve;
+    server.setCallbacks({ onExec: async () => new Promise(r => { resolve = r; }) });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'first', from:'t' }) });
+    await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'t1', from:'t' }) });
+    await fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, { method:'POST', body: JSON.stringify({ command:'t2', from:'t' }) });
+    expect(server.queueDepth).toBe(2);
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-queue-cancel-all\`, { method:'POST' });
+    expect(r.status).toBe(200);
+    expect((await r.json()).cancelled).toBe(2);
+    if (resolve) resolve({ stdout:'', stderr:'', exitCode:0 });
+    await new Promise(r => setTimeout(r, 50));
+  });
+
+  test('cancelAllQueuedTasks when empty', () => {
+    expect(server.cancelAllQueuedTasks()).toBe(0);
+  });
+
+  test('GET /mesh-events SSE', async () => {
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-events\`);
+    expect(r.status).toBe(200);
+    expect(r.headers.get('content-type')).toContain('text/event-stream');
+    await r.body?.cancel();
+  });
+
+  test('SSE connected event', async () => {
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-events\`);
+    const reader = r.body?.getReader();
+    let data = '';
+    if (reader) { const {value} = await reader.read(); data = new TextDecoder().decode(value); }
+    expect(data).toContain('event: connected');
+    expect(data).toContain('"status":"ok"');
+    await r.body?.cancel();
+  });
+
+  test('broadcastEvent sends SSE', async () => {
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-events\`);
+    const reader = r.body?.getReader();
+    const dec = new TextDecoder();
+    if (reader) await reader.read();
+    server.broadcastEvent('new_message', { text:'sse test' });
+    let data = '';
+    if (reader) { const {value}=await reader.read(); data=dec.decode(value); }
+    expect(data).toContain('event: new_message');
+    expect(data).toContain('"text":"sse test"');
+    await r.body?.cancel();
+  });
+
+  test('updatePeerInfo', async () => {
+    const port = await server.start(mi({ id:'orig' }));
+    server.updatePeerInfo({ hostname:'upd' });
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-info\`);
+    const d = await r.json();
+    expect(d.hostname).toBe('upd');
+    expect(d.id).toBe('orig');
+  });
+
+  test('extraInfo in mesh-info', async () => {
+    const port = await server.start(mi());
+    server.extraInfo = { cf: 'cv' };
+    expect((await (await fetch(\`http://127.0.0.1:\${port}/mesh-info\`)).json()).cf).toBe('cv');
+  });
+
+  test('cancelQueuedTask false for unknown', () => {
+    expect(server.cancelQueuedTask('nope')).toBeFalse();
+  });
+
+  test('getTasks', () => {
+    const t = server.getTasks();
+    expect(t).toHaveProperty('queue');
+    expect(t).toHaveProperty('current');
+    expect(t.queue).toEqual([]);
+    expect(t.current).toBeNull();
+  });
+
+  test('unknown route 404', async () => {
+    const port = await server.start(mi());
+    expect((await fetch(\`http://127.0.0.1:\${port}/unknown\`)).status).toBe(404);
+  });
+
+  test('malformed JSON 400', async () => {
+    const port = await server.start(mi());
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, { method:'POST', headers:{'Content-Type':'application/json'}, body:'not-json' });
+    expect(r.status).toBe(400);
+  });
+});
+`;
+fs.appendFileSync(p, code, 'utf8');
+console.log('MeshServer.test.ts completed');

package/scripts/write-server-v2.cjs

@@ -0,0 +1,142 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { MeshServer, getGlobalMeshServer } from './MeshServer.js';
+
+function mi(o) { return { id:'tp', hostname:'th', ip:'127.0.0.1', port:0, cwd:'/r', version:'t', lastSeen:Date.now(), status:'online', ...o }; }
+
+describe('MeshServer', () => {
+  let server;
+  beforeEach(() => { server = new MeshServer(); });
+  afterEach(() => { server.stop(); });
+
+  test('constructor creates instance', () => {
+    expect(server).toBeInstanceOf(MeshServer);
+    expect(server.port).toBe(0);
+  });
+
+  test('constructor accepts callbacks', () => {
+    const s = new MeshServer({ onMessage: () => {} });
+    expect(s).toBeInstanceOf(MeshServer);
+    s.stop();
+  });
+
+  test('getGlobalMeshServer singleton', () => {
+    expect(getGlobalMeshServer()).toBe(getGlobalMeshServer());
+  });
+
+  test('setCallbacks merges', () => {
+    server.setCallbacks({ onMessage: () => {} });
+    server.setCallbacks({ onTodo: () => {} });
+    expect(server).toBeInstanceOf(MeshServer);
+  });
+
+  test('isBusy/queueDepth initially false/0', () => {
+    expect(server.isBusy).toBeFalse();
+    expect(server.queueDepth).toBe(0);
+  });
+
+  test('getTodos empty, updateTodoStatus false for unknown', () => {
+    expect(server.getTodos()).toEqual([]);
+    expect(server.updateTodoStatus('x','done')).toBeFalse();
+  });
+
+  test('start returns port', async () => {
+    const port = await server.start(mi());
+    expect(typeof port).toBe('number');
+    expect(port).toBeGreaterThan(0);
+    expect(server.port).toBe(port);
+  });
+
+  test('start idempotent', async () => {
+    const p1 = await server.start(mi());
+    const p2 = await server.start(mi());
+    expect(p1).toBe(p2);
+  });
+
+  test('stop does not throw', () => {
+    expect(() => server.stop()).not.toThrow();
+  });
+
+  test('start-stop-start works', async () => {
+    await server.start(mi());
+    server.stop();
+    const p = await server.start(mi());
+    expect(p).toBeGreaterThan(0);
+  });
+
+  // ── HTTP Endpoints ─────────────────────────────────────────────────
+
+  test('GET /mesh-info returns peer info', async () => {
+    const port = await server.start(mi({ id:'info-test' }));
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-info\`);
+    expect(res.status).toBe(200);
+    const d = await res.json();
+    expect(d.id).toBe('info-test');
+    expect(d.isBusy).toBeFalse();
+  });
+
+  test('POST /mesh-msg fires callback', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ from:'p2', fromName:'w2', text:'hello' }),
+    });
+    expect(res.status).toBe(200);
+    expect((await res.json()).ok).toBeTrue();
+    expect(m.from).toBe('p2');
+    expect(m.text).toBe('hello');
+  });
+
+  test('POST /mesh-msg handles chunk info', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ from:'p2', text:'c', chunkGroup:'g1', chunkIndex:0, chunkTotal:2 }),
+    });
+    expect(m.chunkGroup).toBe('g1');
+  });
+
+  test('POST /mesh-msg with empty body uses defaults', async () => {
+    let m = null;
+    server.setCallbacks({ onMessage: msg => { m = msg; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-msg\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({}),
+    });
+    expect(m.from).toBe('unknown');
+    expect(m.text).toBe('');
+  });
+
+  test('POST /mesh-todo fires callback', async () => {
+    let t = null;
+    server.setCallbacks({ onTodo: todo => { t = todo; } });
+    const port = await server.start(mi());
+    const res = await fetch(\`http://127.0.0.1:\${port}/mesh-todo\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ from:'p2', message:'fix' }),
+    });
+    expect(res.status).toBe(200);
+    expect((await res.json()).ok).toBeTrue();
+    expect(t.message).toBe('fix');
+  });
+
+  test('POST /mesh-todo empty body defaults', async () => {
+    let t = null;
+    server.setCallbacks({ onTodo: todo => { t = todo; } });
+    const port = await server.start(mi());
+    await fetch(\`http://127.0.0.1:\${port}/mesh-todo\`, {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({}),
+    });
+    expect(t.from).toBe('unknown');
+    expect(t.message).toBe('');
+  });
+`;
+fs.writeFileSync(p, code, 'utf8');
+console.log('MeshServer.test.ts part 1 written');