weaver-work-cli 0.1.38 → 0.1.40

package/skills/weaver-e10-workflow/tools/todo-serve.cjs

@@ -1,28 +1,27 @@
 #!/usr/bin/env node
 /**
- * todo-serve.cjs —— 待办汇总载荷的本地 GET 数据源（单进程多快照版，2026-10-29）。
+ * todo-serve.cjs —— 待办汇总载荷的本地 GET 数据源（v4：内存优先，2026-10-30）。
  *
- * 设计：
- *   一个常驻进程，按 token 路由到文件系统里的快照目录，进程数恒为 1、端口恒定。
+ * v4 变化（为什么必须改）：
+ *   宿主沙箱对「脱离父命令的常驻进程」的文件读授权，只在其启动命令存活期间有效——
+ *   命令一结束，服务就读不了任何快照文件（能 stat、不能 read ⇒ GET 404 snapshot_empty），
+ *   用户过几分钟再打开链接必 404。所以 v4 改为：**快照正文由 CLI 通过 POST 推进本进程内存，
+ *   GET 从内存返回，服务端不再读任何磁盘文件**。
  *
- *   ~/.weaver-work-cli/serve/
- *   ├── current.json              # { pid, port, version, startedAt }
- *   └── snapshots/<token>/todo.json
+ * 数据通路：
+ *   POST /s/<token>/todo.json   -> CLI 发布：body 即三键 JSON 原文，存入内存（须带 x-publish-key）
+ *   GET  /s/<token>/todo.json   -> 内存优先，miss 再回落读磁盘快照（兼容旧文件）
+ *   GET  /todo.json?token=<t>   -> 同上（兼容旧链接形态）
+ *   GET  /health                -> 存活信息（inMemory = 内存快照数）
  *
- *   GET /s/<token>/todo.json     -> 该快照的三键数据
- *   GET /todo.json?token=<token> -> 同上（兼容旧链接形态）
- *   GET /health                  -> 存活信息与快照数
- *
- * 生命周期：
- *   - 快照各自按目录 mtime 计空闲，超时即删（请求命中过期快照也会顺手删掉）。
- *   - 所有快照都过期且全局无请求超过 idle 分钟 -> 进程退出并删 current.json。
- *
- * 为什么必须自己写这个服务（而不是 python -m http.server / http-server）：
- *   https 页面取 http://127.0.0.1 会先发 OPTIONS 私有网络预检，
- *   必须回 `Access-Control-Allow-Private-Network: true` 且回显 Origin，否则浏览器直接拦
- *   （python 的 http.server 对 OPTIONS 直接 501）。
+ * 兼容与安全：
+ *   - x-publish-key：启动时随机生成、写入 current.json 给 CLI；发布必须携带，防止拿到 URL 的人伪造发布；
+ *   - 内存快照上限 20 份（LRU 淘汰）、单份 ≤ 8MB；
+ *   - 服务收到正文后仍 best-effort 写一份磁盘副本（只写不读，排错用）；
+ *   - 旧版「CLI 写文件、服务读文件」的路径保留为回落，但不再是主通路。
  */
 const http = require('node:http');
+const crypto = require('node:crypto');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
@@ -41,7 +40,7 @@ function parseArgs(argv) {
 }
 
 /** 与服务端约定一致的版本号：客户端只复用同版本实例。 */
-const SERVE_VERSION = '3';
+const SERVE_VERSION = '4';
 
 const args = parseArgs(process.argv.slice(2));
 // 默认放系统临时目录：快照只有 30 分钟寿命，本就不该写进家目录；
@@ -58,6 +57,12 @@ const allowOrigin = args['allow-origin'] && args['allow-origin'] !== true ? Stri
 // token 只允许十六进制，避免 `../` 之类的目录穿越
 const TOKEN_RE = /^[a-f0-9]{8,64}$/;
 const IDLE_MS = idleMinutes * 60000;
+/** 发布密钥：启动时随机生成，写进 current.json 给 CLI；发布请求必须带它（防伪造发布）。 */
+const publishKey = crypto.randomBytes(8).toString('hex');
+/** 内存快照：token -> { body, createdAt, bytes }。GET 的主来源，服务端不再读磁盘。 */
+const memorySnapshots = new Map();
+const MAX_MEMORY_SNAPSHOTS = 20;
+const MAX_BODY_BYTES = 8 * 1024 * 1024;
 
 fs.mkdirSync(snapshotsDir, { recursive: true });
 
@@ -82,9 +87,14 @@ function dropSnapshot(dir) {
   } catch { /* 忽略 */ }
 }
 
-/** 读一份快照；不存在或已过期都返回 404（过期的顺手清掉）。 */
+/** 读一份快照：**内存优先**，miss 再回落磁盘文件（兼容旧路径）。过期都返回 404。 */
 function readSnapshot(token) {
   if (!TOKEN_RE.test(String(token || ''))) return { status: 400, error: 'invalid_token' };
+  const mem = memorySnapshots.get(token);
+  if (mem) {
+    mem.createdAt = Date.now(); // 命中即续期
+    return { status: 200, body: mem.body };
+  }
   const dir = path.join(snapshotsDir, token);
   const file = path.join(dir, 'todo.json');
   let mtime = 0;
@@ -107,13 +117,17 @@ function readSnapshot(token) {
   return { status: 200, body };
 }
 
-/** 清掉过期快照，返回仍在有效期内的数量。 */
+/** 清掉过期快照（内存 + 磁盘），返回仍在有效期内的数量。 */
 function sweepSnapshots() {
+  const now = Date.now();
+  for (const [token, mem] of memorySnapshots) {
+    if (now - mem.createdAt > IDLE_MS) memorySnapshots.delete(token);
+  }
   let names = [];
   try {
     names = fs.readdirSync(snapshotsDir);
   } catch {
-    return 0;
+    names = [];
   }
   let alive = 0;
   for (const name of names) {
@@ -127,14 +141,14 @@ function sweepSnapshots() {
     if (Date.now() - mtime > IDLE_MS) dropSnapshot(dir);
     else alive += 1;
   }
-  return alive;
+  return alive + memorySnapshots.size;
 }
 
 function corsHeaders(req) {
   const origin = allowOrigin || req.headers.origin || '*';
   return {
     'Access-Control-Allow-Origin': origin,
-    'Access-Control-Allow-Methods': 'GET, OPTIONS',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
     'Access-Control-Allow-Headers': req.headers['access-control-request-headers'] || '*',
     'Access-Control-Allow-Private-Network': 'true',
     'Access-Control-Max-Age': '600',
@@ -147,6 +161,36 @@ function send(res, status, headers, body) {
   res.end(body);
 }
 
+/** 读取请求体（有 8MB 上限，超限返回 null）。 */
+function readBody(req, onDone) {
+  const chunks = [];
+  let size = 0;
+  let aborted = false;
+  req.on('data', (chunk) => {
+    if (aborted) return;
+    size += chunk.length;
+    if (size > MAX_BODY_BYTES) {
+      aborted = true;
+      onDone(null);
+      return;
+    }
+    chunks.push(chunk);
+  });
+  req.on('end', () => { if (!aborted) onDone(Buffer.concat(chunks).toString('utf8')); });
+  req.on('error', () => { if (!aborted) onDone(null); });
+}
+
+/** 内存快照：存入并按 LRU 淘汰最旧的，返回是否成功。 */
+function putMemorySnapshot(token, body) {
+  memorySnapshots.set(token, { body, createdAt: Date.now(), bytes: Buffer.byteLength(body) });
+  while (memorySnapshots.size > MAX_MEMORY_SNAPSHOTS) {
+    const oldest = [...memorySnapshots.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt)[0];
+    if (!oldest) break;
+    memorySnapshots.delete(oldest[0]);
+  }
+  return true;
+}
+
 const server = http.createServer((req, res) => {
   lastHit = Date.now();
   const url = new URL(req.url || '/', 'http://127.0.0.1');
@@ -157,6 +201,48 @@ const server = http.createServer((req, res) => {
     res.end();
     return;
   }
+
+  // 发布端点：CLI 把三键 JSON 原文 POST 进内存（必须带 x-publish-key）。
+  // 这是 v4 的主通路——服务端从此不依赖「读磁盘」就能服务 GET。
+  let publishMatch = null;
+  if (req.method === 'POST') {
+    publishMatch = url.pathname.match(/^\/s\/([^/]+)\/todo\.json$/);
+    if (!publishMatch) {
+      send(res, 404, headers, JSON.stringify({ ok: false, error: 'not_found' }));
+      return;
+    }
+    const token = publishMatch[1];
+    if (!TOKEN_RE.test(token)) {
+      send(res, 400, headers, JSON.stringify({ ok: false, error: 'invalid_token' }));
+      return;
+    }
+    if (String(req.headers['x-publish-key'] || '') !== publishKey) {
+      send(res, 403, headers, JSON.stringify({ ok: false, error: 'forbidden' }));
+      return;
+    }
+    readBody(req, (body) => {
+      if (body === null) {
+        send(res, 413, headers, JSON.stringify({ ok: false, error: 'payload_too_large' }));
+        return;
+      }
+      try { JSON.parse(body); } catch {
+        send(res, 400, headers, JSON.stringify({ ok: false, error: 'invalid_json' }));
+        return;
+      }
+      putMemorySnapshot(token, body);
+      // best-effort 落一份磁盘副本：只写不读，排错/人工恢复用
+      try {
+        const dir = path.join(snapshotsDir, token);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'todo.json'), body);
+      } catch { /* 写不了也不影响内存通路 */ }
+      send(res, 200, { ...headers, 'Cache-Control': 'no-store' }, JSON.stringify({
+        ok: true, token, bytes: Buffer.byteLength(body), inMemory: memorySnapshots.size,
+      }));
+    });
+    return;
+  }
+
   if (req.method !== 'GET') {
     send(res, 405, headers, JSON.stringify({ ok: false, error: 'method_not_allowed' }));
     return;
@@ -170,6 +256,7 @@ const server = http.createServer((req, res) => {
       pid: process.pid,
       port: address ? address.port : port,
       snapshots: alive,
+      inMemory: memorySnapshots.size,
       idleMinutes,
       hits,
     }));
@@ -216,8 +303,9 @@ server.listen(port, '127.0.0.1', () => {
     root,
     startedAt: new Date().toISOString(),
     idleMinutes,
+    publishKey,
   }, null, 2));
-  console.log('[todo-serve] listening http://127.0.0.1:%d/s/<token>/todo.json｜空闲 %d 分钟自动退出｜pid=%d', actualPort, idleMinutes, process.pid);
+  console.log('[todo-serve] listening http://127.0.0.1:%d/s/<token>/todo.json｜内存优先版 v%s｜空闲 %d 分钟自动退出｜pid=%d', actualPort, SERVE_VERSION, idleMinutes, process.pid);
 });
 
 function cleanup(code) {