clew-code 0.2.29 → 0.2.30

package/scripts/session.ts

@@ -0,0 +1,195 @@
+#!/usr/bin/env bun
+/**
+ * Session Bridge
+ *
+ * Saves & restores session context so Claude Code can pick up
+ * where it left off across sessions.
+ *
+ * Usage:
+ *   bun run session save     "กำลัง refactor bridge reconnect logic"
+ *   bun run session list     # ดู sessions ล่าสุด
+ *   bun run session restore  # โหลด session ล่าสุดกลับมา
+ *   bun run session drop     # ลบ current session
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync } from 'fs'
+import { join, dirname, basename } from 'path'
+import { execSync } from 'child_process'
+
+const ROOT = join(import.meta.dirname, '..')
+const SESSIONS_DIR = join(ROOT, '.clew', 'sessions')
+const CURRENT_LINK = join(SESSIONS_DIR, 'CURRENT.md')
+const MAX_SESSIONS = 20
+
+const cmd = process.argv[2]
+const message = process.argv.slice(3).join(' ')
+
+function run(cmd: string): string {
+  try {
+    return execSync(cmd, { cwd: ROOT, encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'ignore'] })
+  } catch (e: any) {
+    return e.stdout || ''
+  }
+}
+
+function ts(): string {
+  return new Date().toISOString().replace('T', ' ').slice(0, 19)
+}
+
+function sessionId(): string {
+  return new Date().toISOString().slice(0, 10) + '-' + Date.now().toString(36)
+}
+
+function getModifiedFiles(): string[] {
+  try {
+    const out = run('git diff --name-only --relative').trim()
+    const staged = run('git diff --cached --name-only --relative').trim()
+    const files = [...new Set([...out.split('\n'), ...staged.split('\n')])].filter(Boolean)
+    return files.filter(f => f.startsWith('src/'))
+  } catch {
+    return []
+  }
+}
+
+function getCurrentBranch(): string {
+  try {
+    return run('git branch --show-current').trim()
+  } catch {
+    return 'unknown'
+  }
+}
+
+function getRecentCommits(count = 5): string[] {
+  try {
+    return run(`git log --oneline -${count} -- .`).trim().split('\n').filter(Boolean)
+  } catch {
+    return []
+  }
+}
+
+// ── Commands ──
+
+if (cmd === 'save') {
+  const id = sessionId()
+  const branch = getCurrentBranch()
+  const modified = getModifiedFiles()
+  const commits = getRecentCommits(3)
+  const content = message || '(no description)'
+
+  mkdirSync(SESSIONS_DIR, { recursive: true })
+
+  const md = [
+    `# Session: ${id}`,
+    ``,
+    `- **Date**: ${ts()}`,
+    `- **Branch**: ${branch}`,
+    `- **Description**: ${content}`,
+    ``,
+  ]
+
+  if (modified.length) {
+    md.push(`## Modified Files`, ``)
+    for (const f of modified) md.push(`- \`${f}\``)
+    md.push(``)
+  }
+
+  if (commits.length) {
+    md.push(`## Recent Commits`, ``)
+    md.push('```')
+    for (const c of commits) md.push(c)
+    md.push('```')
+    md.push(``)
+  }
+
+  md.push(`## Notes`, ``)
+  md.push(`(add key decisions, pending items, or anything to remember)`)
+  md.push(``)
+
+  const filepath = join(SESSIONS_DIR, `${id}.md`)
+  writeFileSync(filepath, md.join('\n'), 'utf-8')
+  writeFileSync(CURRENT_LINK, `# Current Session\n\n${content}\n\nSee: ${id}.md`, 'utf-8')
+
+  console.log(`✅ Session saved: ${id}`)
+  console.log(`   ${filepath}`)
+  if (modified.length) console.log(`   ${modified.length} modified file(s)`)
+
+} else if (cmd === 'list') {
+  mkdirSync(SESSIONS_DIR, { recursive: true })
+  const files = readdirSync(SESSIONS_DIR)
+    .filter(f => f.endsWith('.md') && f !== 'CURRENT.md')
+    .sort()
+    .reverse()
+    .slice(0, MAX_SESSIONS)
+
+  if (files.length === 0) {
+    console.log('📭 No saved sessions')
+    process.exit(0)
+  }
+
+  console.log(`📋 Recent sessions (${files.length}):`)
+  console.log('')
+  for (const f of files) {
+    const content = readFileSync(join(SESSIONS_DIR, f), 'utf-8')
+    const firstLine = content.split('\n')[0] || f
+    const desc = content.match(/\*\*Description\*\*:\s*(.+)/)?.[1] || '(no description)'
+    const date = content.match(/\*\*Date\*\*:\s*(.+)/)?.[1] || '?'
+    console.log(`  ${firstLine.replace('# ', '')}`)
+    console.log(`    ${date} — ${desc}`)
+    console.log('')
+  }
+
+} else if (cmd === 'restore') {
+  if (!existsSync(CURRENT_LINK)) {
+    console.log('📭 No current session to restore')
+    process.exit(0)
+  }
+
+  const content = readFileSync(CURRENT_LINK, 'utf-8')
+  const refMatch = content.match(/See:\s+(.+\.md)/)
+  if (!refMatch) {
+    console.log('📭 No session file referenced')
+    process.exit(0)
+  }
+
+  const sessionFile = join(SESSIONS_DIR, refMatch[1])
+  if (!existsSync(sessionFile)) {
+    console.log(`📭 Session file not found: ${sessionFile}`)
+    process.exit(0)
+  }
+
+  const session = readFileSync(sessionFile, 'utf-8')
+  console.log('📋 Restoring session...')
+  console.log('')
+  console.log(session)
+
+} else if (cmd === 'drop') {
+  if (existsSync(CURRENT_LINK)) {
+    const content = readFileSync(CURRENT_LINK, 'utf-8')
+    const refMatch = content.match(/See:\s+(.+\.md)/)
+    if (refMatch) {
+      const sessionFile = join(SESSIONS_DIR, refMatch[1])
+      if (existsSync(sessionFile)) {
+        try { execSync(`rm "${sessionFile}"`) } catch {}
+        console.log(`🗑️  Removed: ${refMatch[1]}`)
+      }
+    }
+    try { execSync(`rm "${CURRENT_LINK}"`) } catch {}
+    console.log('✅ Session dropped')
+  } else {
+    console.log('📭 No current session')
+  }
+
+} else {
+  console.log(`
+Usage:
+  bun run session save "<description>"     — save current state
+  bun run session list                     — list recent sessions
+  bun run session restore                  — restore latest session
+  bun run session drop                     — drop current session
+
+Examples:
+  bun run session save "adding auth middleware"
+  bun run session save "fixing bridge reconnect bug"
+  bun run session list
+  `)
+}

package/scripts/sweep.ts

@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+
+import { lifecycle, STALE_UPVOTE_THRESHOLD } from "./issue-lifecycle.ts";
+
+// --
+
+const NEW_ISSUE = "https://github.com/JonusNattapong/ClaudeCode/issues/new/choose";
+const DRY_RUN = process.argv.includes("--dry-run");
+
+const CLOSE_MESSAGE = (reason: string) =>
+  `Closing for now — ${reason}. Please [open a new issue](${NEW_ISSUE}) if this is still relevant.`;
+
+// --
+
+async function githubRequest<T>(
+  endpoint: string,
+  method = "GET",
+  body?: unknown
+): Promise<T> {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) throw new Error("GITHUB_TOKEN required");
+
+  const response = await fetch(`https://api.github.com${endpoint}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "sweep",
+      ...(body && { "Content-Type": "application/json" }),
+    },
+    ...(body && { body: JSON.stringify(body) }),
+  });
+
+  if (!response.ok) {
+    if (response.status === 404) return {} as T;
+    const text = await response.text();
+    throw new Error(`GitHub API ${response.status}: ${text}`);
+  }
+
+  return response.json();
+}
+
+// --
+
+async function markStale(owner: string, repo: string) {
+  const staleDays = lifecycle.find((l) => l.label === "stale")!.days;
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - staleDays);
+
+  let labeled = 0;
+
+  console.log(`\n=== marking stale (${staleDays}d inactive) ===`);
+
+  for (let page = 1; page <= 10; page++) {
+    const issues = await githubRequest<any[]>(
+      `/repos/${owner}/${repo}/issues?state=open&sort=updated&direction=asc&per_page=100&page=${page}`
+    );
+    if (issues.length === 0) break;
+
+    for (const issue of issues) {
+      if (issue.pull_request) continue;
+      if (issue.locked) continue;
+      if (issue.assignees?.length > 0) continue;
+
+      const updatedAt = new Date(issue.updated_at);
+      if (updatedAt > cutoff) return labeled;
+
+      const alreadyStale = issue.labels?.some(
+        (l: any) => l.name === "stale" || l.name === "autoclose"
+      );
+      if (alreadyStale) continue;
+
+      const thumbsUp = issue.reactions?.["+1"] ?? 0;
+      if (thumbsUp >= STALE_UPVOTE_THRESHOLD) continue;
+
+      const base = `/repos/${owner}/${repo}/issues/${issue.number}`;
+
+      if (DRY_RUN) {
+        const age = Math.floor((Date.now() - updatedAt.getTime()) / 86400000);
+        console.log(`#${issue.number}: would label stale (${age}d inactive) — ${issue.title}`);
+      } else {
+        await githubRequest(`${base}/labels`, "POST", { labels: ["stale"] });
+        console.log(`#${issue.number}: labeled stale — ${issue.title}`);
+      }
+      labeled++;
+    }
+  }
+
+  return labeled;
+}
+
+async function closeExpired(owner: string, repo: string) {
+  let closed = 0;
+
+  for (const { label, days, reason } of lifecycle) {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    console.log(`\n=== ${label} (${days}d timeout) ===`);
+
+    for (let page = 1; page <= 10; page++) {
+      const issues = await githubRequest<any[]>(
+        `/repos/${owner}/${repo}/issues?state=open&labels=${label}&sort=updated&direction=asc&per_page=100&page=${page}`
+      );
+      if (issues.length === 0) break;
+
+      for (const issue of issues) {
+        if (issue.pull_request) continue;
+        if (issue.locked) continue;
+
+        const thumbsUp = issue.reactions?.["+1"] ?? 0;
+        if (thumbsUp >= STALE_UPVOTE_THRESHOLD) continue;
+
+        const base = `/repos/${owner}/${repo}/issues/${issue.number}`;
+
+        const events = await githubRequest<any[]>(`${base}/events?per_page=100`);
+
+        const labeledAt = events
+          .filter((e) => e.event === "labeled" && e.label?.name === label)
+          .map((e) => new Date(e.created_at))
+          .pop();
+
+        if (!labeledAt || labeledAt > cutoff) continue;
+
+        // Skip if a non-bot user commented after the label was applied.
+        // The triage workflow should remove lifecycle labels on human
+        // activity, but check here too as a safety net.
+        const comments = await githubRequest<any[]>(
+          `${base}/comments?since=${labeledAt.toISOString()}&per_page=100`
+        );
+        const hasHumanComment = comments.some(
+          (c) => c.user && c.user.type !== "Bot"
+        );
+        if (hasHumanComment) {
+          console.log(
+            `#${issue.number}: skipping (human activity after ${label} label)`
+          );
+          continue;
+        }
+
+        if (DRY_RUN) {
+          const age = Math.floor((Date.now() - labeledAt.getTime()) / 86400000);
+          console.log(`#${issue.number}: would close (${label}, ${age}d old) — ${issue.title}`);
+        } else {
+          await githubRequest(`${base}/comments`, "POST", { body: CLOSE_MESSAGE(reason) });
+          await githubRequest(base, "PATCH", { state: "closed", state_reason: "not_planned" });
+          console.log(`#${issue.number}: closed (${label})`);
+        }
+        closed++;
+      }
+    }
+  }
+
+  return closed;
+}
+
+// --
+
+const owner = process.env.GITHUB_REPOSITORY_OWNER;
+const repo = process.env.GITHUB_REPOSITORY_NAME;
+if (!owner || !repo)
+  throw new Error("GITHUB_REPOSITORY_OWNER and GITHUB_REPOSITORY_NAME required");
+
+if (DRY_RUN) console.log("DRY RUN — no changes will be made\n");
+
+const labeled = await markStale(owner, repo);
+const closed = await closeExpired(owner, repo);
+
+console.log(`\nDone: ${labeled} ${DRY_RUN ? "would be labeled" : "labeled"} stale, ${closed} ${DRY_RUN ? "would be closed" : "closed"}`);

package/scripts/write-discovery-test.cjs

@@ -0,0 +1,93 @@
+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;
+  beforeEach(() => { process.env.CLEW_MESH_LAN = undefined; });
+  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 sets isSharing true', async () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.isSharing).toBeFalse();
+    await discovery.startAdvertising(9999, '/cwd');
+    expect(discovery.isSharing).toBeTrue();
+  });
+
+  test('stopAdvertising sets isSharing false', async () => {
+    discovery = new MeshDiscovery();
+    await discovery.startAdvertising(9999, '/cwd');
+    discovery.stopAdvertising();
+    expect(discovery.isSharing).toBeFalse();
+  });
+
+  test('startAdvertising idempotent', async () => {
+    discovery = new MeshDiscovery();
+    await discovery.startAdvertising(9999, '/cwd');
+    await discovery.startAdvertising(8888, '/other');
+    expect(discovery.isSharing).toBeTrue();
+  });
+
+  test('stopAdvertising idempotent when not advertising', () => {
+    discovery = new MeshDiscovery();
+    discovery.stopAdvertising();
+    expect(discovery.isSharing).toBeFalse();
+  });
+
+  test('getPeers returns empty initially', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.getPeers()).toEqual([]);
+  });
+
+  test('getPeer returns undefined for unknown', () => {
+    discovery = new MeshDiscovery();
+    expect(discovery.getPeer('nobody')).toBeUndefined();
+  });
+
+  test('discoverPeers returns array', async () => {
+    discovery = new MeshDiscovery();
+    const peers = await discovery.discoverPeers(100);
+    expect(Array.isArray(peers)).toBeTrue();
+  });
+
+  test('discoverMeshs alias', async () => {
+    discovery = new MeshDiscovery();
+    const peers = await discovery.discoverMeshs(100);
+    expect(Array.isArray(peers)).toBeTrue();
+  });
+
+  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 written');

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