clew-code 0.2.29 → 0.2.31

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');

package/scripts/write-server-v2b.cjs

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `
+  test('POST /mesh-exec with onExec returns result', async () => {
+    let execCmd = '';
+    server.setCallbacks({ onExec: async (cmd) => {
+      execCmd = cmd;
+      return { stdout:'ok\\\\n', 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);
+    const d = await res.json();
+    expect(d.running).toBeTrue();
+    expect(execCmd).toBe('echo hi');
+  });
+
+  test('POST /mesh-exec returns 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');
+  });
+
+  test('POST /mesh-exec queues when busy', async () => {
+    let resolveExec;
+    const execPromise = new Promise(r => { resolveExec = r; });
+    server.setCallbacks({ onExec: async () => execPromise });
+    const port = await server.start(mi());
+
+    // Start first exec (don't await - it won't complete until we resolve)
+    const p1 = fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, {
+      method:'POST', body: JSON.stringify({ command:'long', from:'t' }),
+    });
+    // Wait for server to process the request and mark busy
+    await new Promise(r => setTimeout(r, 200));
+    expect(server.isBusy).toBeTrue();
+
+    // Second exec should queue
+    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);
+    const d2 = await r2.json();
+    expect(d2.queued).toBeTrue();
+    expect(server.queueDepth).toBe(1);
+
+    // Resolve first exec
+    resolveExec({ stdout:'', stderr:'', exitCode:0 });
+    const r1 = await p1;
+    expect(r1.status).toBe(200);
+  });
+
+  test('POST /mesh-exec 503 queue full', async () => {
+    let resolveExec;
+    const execPromise = new Promise(r => { resolveExec = r; });
+    server.setCallbacks({ onExec: async () => execPromise });
+    const port = await server.start(mi());
+
+    // Start first exec
+    const p1 = fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, {
+      method:'POST', body: JSON.stringify({ command:'first', from:'t' }),
+    });
+    await new Promise(r => setTimeout(r, 200));
+    expect(server.isBusy).toBeTrue();
+
+    // Fill queue
+    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' }),
+      });
+    }
+
+    // Next one should be rejected
+    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');
+
+    resolveExec({ stdout:'', stderr:'', exitCode:0 });
+    await p1;
+  });
+
+  test('GET /mesh-queue-status returns queue state', 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 cancels queued task', async () => {
+    let resolveExec;
+    const execPromise = new Promise(r => { resolveExec = r; });
+    server.setCallbacks({ onExec: async () => execPromise });
+    const port = await server.start(mi());
+
+    const p1 = fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, {
+      method:'POST', body: JSON.stringify({ command:'first', from:'t' }),
+    });
+    await new Promise(r => setTimeout(r, 200));
+
+    // Queue a task, then cancel it
+    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();
+
+    resolveExec({ stdout:'', stderr:'', exitCode:0 });
+    await p1;
+  });
+`;
+fs.appendFileSync(p, code, 'utf8');
+console.log('MeshServer.test.ts part 2 written');

package/scripts/write-server-v2c.cjs

@@ -0,0 +1,136 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshServer.test.ts';
+const code = `
+  test('POST /mesh-queue-cancel 404 for unknown', 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 if id missing', 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 resolveExec;
+    const execPromise = new Promise(r => { resolveExec = r; });
+    server.setCallbacks({ onExec: async () => execPromise });
+    const port = await server.start(mi());
+
+    const p1 = fetch(\`http://127.0.0.1:\${port}/mesh-exec\`, {
+      method:'POST', body: JSON.stringify({ command:'first', from:'t' }),
+    });
+    await new Promise(r => setTimeout(r, 200));
+
+    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);
+    expect(server.queueDepth).toBe(0);
+
+    resolveExec({ stdout:'', stderr:'', exitCode:0 });
+    await p1;
+  });
+
+  test('cancelAllQueuedTasks when empty', () => {
+    expect(server.cancelAllQueuedTasks()).toBe(0);
+  });
+
+  test('GET /mesh-events SSE returns event-stream content type', 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 contains status', 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);
+      reader.cancel();
+    }
+    expect(data).toContain('event: connected');
+    expect(data).toContain('"status":"ok"');
+  });
+
+  test('broadcastEvent sends event to SSE clients', 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) {
+      // Read and discard connected event
+      await reader.read();
+      // Broadcast
+      server.broadcastEvent('new_message', { text:'sse test' });
+      // Read next event
+      const {value} = await reader.read();
+      const data = dec.decode(value);
+      expect(data).toContain('event: new_message');
+      expect(data).toContain('"text":"sse test"');
+      reader.cancel();
+    }
+  });
+
+  test('updatePeerInfo updates stored peer info', 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 appears in mesh-info response', async () => {
+    const port = await server.start(mi());
+    server.extraInfo = { cf: 'cv' };
+    const r = await fetch(\`http://127.0.0.1:\${port}/mesh-info\`);
+    expect((await r.json()).cf).toBe('cv');
+  });
+
+  test('cancelQueuedTask returns false for unknown', () => {
+    expect(server.cancelQueuedTask('nope')).toBeFalse();
+  });
+
+  test('getTasks returns queue and current', () => {
+    const t = server.getTasks();
+    expect(t).toHaveProperty('queue');
+    expect(t).toHaveProperty('current');
+    expect(t.queue).toEqual([]);
+    expect(t.current).toBeNull();
+  });
+
+  test('unknown route returns 404', async () => {
+    const port = await server.start(mi());
+    expect((await fetch(\`http://127.0.0.1:\${port}/unknown\`)).status).toBe(404);
+  });
+
+  test('malformed JSON returns 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');