clew-code 0.2.28 → 0.2.30

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

package/scripts/write-store-test.cjs

@@ -0,0 +1,12 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshStore.test.ts';
+const code = `
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { MeshStore } from './MeshStore.js';
+
+function mp(o) { return { id:'peer-1', hostname:'w', ip:'127.0.0.1', port:4200, cwd:'/r', version:'t', lastSeen:Date.now(), status:'online', ...o }; }
+function mm(o) { return { id:'msg-1', from:'peer-1', fromName:'w', text:'hello', color:'cyan', timestamp:Date.now(), ...o }; }
+function mt(o) { return { id:'todo-1', from:'peer-1', fromName:'w', message:'do', createdAt:Date.now(), status:'pending', ...o }; }
+`;
+fs.writeFileSync(p, code.trimStart(), 'utf8');
+console.log('MeshStore.test.ts part 1 written');

package/scripts/write-store-test2.cjs

@@ -0,0 +1,163 @@
+const fs = require('fs');
+const p = 'D:/Projects/Github/clew-code/src/mesh/MeshStore.test.ts';
+const code = `
+describe('MeshStore', () => {
+  let store;
+  beforeEach(() => { store = new MeshStore(); });
+  afterEach(() => { store.destroy(); });
+
+  test('addPeer/getPeers', () => {
+    store.addPeer(mp());
+    expect(store.getPeers()).toHaveLength(1);
+  });
+
+  test('addPeer updates existing', () => {
+    store.addPeer(mp()); store.addPeer(mp({ cwd:'/x' }));
+    expect(store.getPeers()[0].cwd).toBe('/x');
+  });
+
+  test('getPeer', () => {
+    store.addPeer(mp());
+    expect(store.getPeer('peer-1')).toBeDefined();
+    expect(store.getPeer('nope')).toBeUndefined();
+  });
+
+  test('findPeer by id/hostname/displayName', () => {
+    store.addPeer(mp({ id:'abc', hostname:'alpha' }));
+    store.setPeerName('abc','Builder');
+    expect(store.findPeer('abc')?.id).toBe('abc');
+    expect(store.findPeer('alpha')?.id).toBe('abc');
+    expect(store.findPeer('Builder')?.id).toBe('abc');
+  });
+
+  test('addMesh alias', () => {
+    store.addMesh(mp({ id:'x' }));
+    expect(store.getPeer('x')).toBeDefined();
+  });
+
+  test('removePeer fires callback', () => {
+    let rid=''; const s=new MeshStore({onPeerRemoved:i=>{rid=i}});
+    s.addPeer(mp()); s.removePeer('peer-1');
+    expect(rid).toBe('peer-1'); s.destroy();
+  });
+
+  test('addConnection', () => {
+    store.addConnection(mp({ id:'c' }));
+    expect(store.getConnections()).toHaveLength(1);
+  });
+
+  test('addMessage/getMessages/clear/createMessage', () => {
+    store.addMessage(mm()); expect(store.getMessages()).toHaveLength(1);
+    store.clearMessages(); expect(store.getMessages()).toHaveLength(0);
+    const m=store.createMessage('tp','T','hi');
+    expect(m.from).toBe('tp'); expect(m.text).toBe('hi');
+  });
+
+  test('getMessagesAfter', () => {
+    store.addMessage(mm({id:'m1',timestamp:100}));
+    store.addMessage(mm({id:'m2',timestamp:200}));
+    expect(store.getMessagesAfter(150)).toHaveLength(1);
+  });
+
+  test('getReassembledMessages', () => {
+    store.addMessage(mm({id:'c1',text:'A',chunkGroup:'g',chunkIndex:0,chunkTotal:2}));
+    store.addMessage(mm({id:'c2',text:'B',chunkGroup:'g',chunkIndex:1,chunkTotal:2}));
+    const r=store.getReassembledMessages();
+    expect(r).toHaveLength(1); expect(r[0].text).toBe('AB');
+  });
+
+  test('getChunkGroupStatus', () => {
+    expect(store.getChunkGroupStatus('n')).toBeNull();
+    store.addMessage(mm({chunkGroup:'g',chunkIndex:0,chunkTotal:3}));
+    store.addMessage(mm({chunkGroup:'g',chunkIndex:2,chunkTotal:3}));
+    expect(store.getChunkGroupStatus('g').received).toBe(2);
+  });
+
+  test('waitForNewMessage', async () => {
+    const a=Date.now(); const p=store.waitForNewMessage(a,500);
+    store.addMessage(mm({timestamp:Date.now()+5}));
+    expect((await p)).toHaveLength(1);
+  });
+
+  test('waitForNewMessage timeout', async () => {
+    const msgs=await store.waitForNewMessage(Date.now(),50);
+    expect(msgs).toHaveLength(0);
+  },2000);
+
+  test('waitForMessageFrom', async () => {
+    const a=Date.now();
+    const p=store.waitForMessageFrom(a,500,'exp');
+    store.addMessage(mm({id:'w',from:'wrong',timestamp:Date.now()+5}));
+    await new Promise(r=>setTimeout(r,50));
+    store.addMessage(mm({id:'r',from:'exp',timestamp:Date.now()+20}));
+    expect((await p)).toHaveLength(1);
+  });
+
+  test('addTodo/updateTodoStatus', () => {
+    store.addTodo(mt()); expect(store.getTodos()).toHaveLength(1);
+    expect(store.updateTodoStatus('todo-1','done')).toBeTrue();
+    expect(store.getTodos()[0].status).toBe('done');
+    expect(store.updateTodoStatus('n','done')).toBeFalse();
+  });
+
+  test('peer tags and resolve', () => {
+    store.setPeerName('p1','N'); store.setPeerRole('p1','R');
+    expect(store.getPeerTags('p1')?.displayName).toBe('N');
+    expect(store.getPeerTags('p1')?.role).toBe('R');
+    const p=mp({id:'p1',hostname:'h'});
+    expect(store.resolveName(p)).toBe('N');
+    expect(store.resolveRole(p)).toBe('R');
+  });
+
+  test('mesh alias methods', () => {
+    store.setMeshName('x','A'); store.setMeshRole('x','B');
+    expect(store.getMeshTags('x')?.displayName).toBe('A');
+    expect(store.getAllMeshTags()).toHaveLength(1);
+  });
+
+  test('callbacks', () => {
+    let a=false,r=false,u=false;
+    const s=new MeshStore({onPeerAdded:()=>{a=true},onPeerUpdated:()=>{u=true},onPeerRemoved:()=>{r=true}});
+    s.addPeer(mp()); s.addPeer(mp({status:'off'})); s.removePeer('peer-1');
+    expect(a).toBeTrue(); expect(u).toBeTrue(); expect(r).toBeTrue();
+    s.destroy();
+  });
+
+  test('setCallbacks merges', () => {
+    let a=false,m=false;
+    const s=new MeshStore({onPeerAdded:()=>{a=true}});
+    s.setCallbacks({onMessageReceived:()=>{m=true}});
+    s.addPeer(mp()); s.addMessage(mm());
+    expect(a).toBeTrue(); expect(m).toBeTrue();
+    s.destroy();
+  });
+
+  test('alias getters', () => {
+    store.addPeer(mp({port:7777}));
+    expect(store.getMeshs()).toHaveLength(1);
+    expect(store.getMeshByPort(7777)).toBeDefined();
+    expect(store.findMesh('w')?.id).toBe('peer-1');
+  });
+
+  test('size', () => {
+    expect(store.size).toBe(0);
+    store.addPeer(mp({id:'p1'}));
+    expect(store.size).toBe(1);
+  });
+
+  test('destroy', () => {
+    store.addPeer(mp()); store.addMessage(mm()); store.addTodo(mt());
+    store.destroy();
+    expect(store.getPeers()).toHaveLength(0);
+    expect(store.getMessages()).toHaveLength(0);
+    expect(store.getTodos()).toHaveLength(0);
+  });
+
+  test('singleton', async () => {
+    const {getGlobalMeshStore}=await import('./MeshStore.js');
+    expect(getGlobalMeshStore()).toBe(getGlobalMeshStore());
+  });
+});
+`;
+fs.appendFileSync(p, code, 'utf8');
+console.log('MeshStore.test.ts completed');