@vitex/nook 0.0.0-stage → 0.1.0

package/src/backend/server.js

@@ -0,0 +1,433 @@
+/**
+ * Nook HTTP 服务：
+ *   - 构建后的前端静态文件
+ *   - JSON API（项目、会话、对话）
+ *   - SSE 事件流（Pi 的思考 / 工具调用 / 文本增量）
+ *
+ * 只按传入的 host / port 监听，不感知任何特定网络服务。
+ */
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getWebDir, getHost, getPort } from './config.js';
+import { listProjects, getProject, createProject, removeProject } from './projects.js';
+import {
+  listSessions,
+  newSessionId,
+  isValidSessionId,
+  findSessionFile,
+  readTranscript,
+  deleteSessionFile,
+  openSessionManager,
+} from './sessions.js';
+import { SessionPool } from './agent/pool.js';
+import { listDirectories, createDirectory } from './fs-browser.js';
+import { serializeEvent } from './agent/serialize.js';
+import { accessUrls } from './net.js';
+import { log, logErr } from './logging.js';
+
+const PUBLIC_DIR = getWebDir();
+const EVENT_LIMIT = 5000;
+const MAX_BODY = 1024 * 1024;
+const SSE_BUFFER_LIMIT = 8 * 1024 * 1024;
+
+const MIME = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.mjs': 'text/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.webmanifest': 'application/manifest+json; charset=utf-8',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.ico': 'image/x-icon',
+  '.woff2': 'font/woff2',
+  '.txt': 'text/plain; charset=utf-8',
+};
+
+class HttpError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+
+function sendJson(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': Buffer.byteLength(body),
+    'Cache-Control': 'no-store',
+    'X-Content-Type-Options': 'nosniff',
+  });
+  res.end(body);
+}
+
+function sendText(res, status, text, type = 'text/plain; charset=utf-8') {
+  res.writeHead(status, {
+    'Content-Type': type,
+    'Cache-Control': 'no-store',
+    'X-Content-Type-Options': 'nosniff',
+  });
+  res.end(text);
+}
+
+async function readJson(req) {
+  let size = 0;
+  const chunks = [];
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_BODY) throw new HttpError(413, '请求体过大');
+    chunks.push(chunk);
+  }
+  if (!chunks.length) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  } catch {
+    throw new HttpError(400, 'JSON 格式不正确');
+  }
+}
+
+function projectOr404(id) {
+  const project = getProject(id);
+  if (!project) throw new HttpError(404, '项目不存在');
+  return project;
+}
+
+function sessionIdOr400(id) {
+  if (!isValidSessionId(id)) throw new HttpError(400, '会话 ID 不正确');
+  return id;
+}
+
+function staticFile(res, pathname, reqMethod) {
+  if (!PUBLIC_DIR) {
+    if (pathname === '/' || pathname === '/index.html') {
+      return sendText(res, 200, 'Nook API is running. Start the frontend with `npm run dev:frontend`, or build it with `npm run build`.', 'text/plain; charset=utf-8');
+    }
+    return sendText(res, 404, 'Not Found');
+  }
+  let rel = pathname === '/' ? '/index.html' : pathname;
+  try { rel = decodeURIComponent(rel); } catch { }
+  const full = path.resolve(PUBLIC_DIR, '.' + rel);
+  if (!full.startsWith(PUBLIC_DIR + path.sep) && full !== PUBLIC_DIR) {
+    return sendText(res, 403, 'Forbidden');
+  }
+  let stat = null;
+  try { stat = fs.statSync(full); } catch { }
+  if (!stat || !stat.isFile()) {
+    // 纯前端只有 hash 路由，其余未知路径回 index.html
+    if (!path.extname(rel)) {
+      const index = path.join(PUBLIC_DIR, 'index.html');
+      return serveFile(res, index, reqMethod);
+    }
+    return sendText(res, 404, 'Not Found');
+  }
+  return serveFile(res, full, reqMethod);
+}
+
+function serveFile(res, file, reqMethod) {
+  const ext = path.extname(file).toLowerCase();
+  const type = MIME[ext] || 'application/octet-stream';
+  const stat = fs.statSync(file);
+  res.writeHead(200, {
+    'Content-Type': type,
+    'Content-Length': stat.size,
+    'Cache-Control': 'no-cache',
+    'X-Content-Type-Options': 'nosniff',
+    'Referrer-Policy': 'no-referrer',
+    'Content-Security-Policy': "default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; script-src 'self'; connect-src 'self'",
+  });
+  if (reqMethod === 'HEAD') { res.end(); return; }
+  fs.createReadStream(file).pipe(res);
+}
+
+function sseEnvelope(res, env) {
+  if (res.destroyed) return;
+  if (res.writableLength > SSE_BUFFER_LIMIT) {
+    try { res.end(); } catch { }
+    return;
+  }
+  res.write(`id: ${env.seq}\nevent: pi\ndata: ${JSON.stringify(env)}\n\n`);
+}
+
+export function createNookServer({ port = getPort(), host = getHost() } = {}) {
+  /** @type {Set<{res: import('node:http').ServerResponse, projectId: string, sessionId: string, timer: NodeJS.Timeout}>} */
+  const clients = new Set();
+  const eventLog = [];
+  let seq = 0;
+
+  const pool = new SessionPool({
+    emit(project, sessionId, event) {
+      const clean = serializeEvent(event);
+      const envelope = {
+        seq: ++seq,
+        projectId: project.id,
+        sessionId,
+        ts: Date.now(),
+        event: clean,
+      };
+      eventLog.push(envelope);
+      if (eventLog.length > EVENT_LIMIT) eventLog.splice(0, eventLog.length - EVENT_LIMIT);
+      for (const client of clients) {
+        if (client.projectId && client.projectId !== envelope.projectId) continue;
+        if (client.sessionId && client.sessionId !== envelope.sessionId) continue;
+        sseEnvelope(client.res, envelope);
+      }
+      return envelope.seq;
+    },
+  });
+
+  async function handleSse(req, res, url) {
+    const projectId = url.searchParams.get('projectId') || '';
+    const sessionId = url.searchParams.get('sessionId') || '';
+    const sinceParam = req.headers['last-event-id'] || url.searchParams.get('since') || '';
+    let since = Number(sinceParam);
+    if (!Number.isFinite(since)) since = seq;
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream; charset=utf-8',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    });
+    res.write('retry: 3000\n\n');
+
+    const matches = (env) => (!projectId || env.projectId === projectId) && (!sessionId || env.sessionId === sessionId);
+
+    if (eventLog.length && since < eventLog[0].seq - 1) {
+      res.write(`id: ${seq}\nevent: reset\ndata: ${JSON.stringify({ reason: 'gap' })}\n\n`);
+    } else {
+      for (const env of eventLog) {
+        if (env.seq > since && matches(env)) sseEnvelope(res, env);
+      }
+    }
+
+    const timer = setInterval(() => {
+      if (!res.destroyed) res.write(': ping\n\n');
+    }, 20_000);
+    if (timer.unref) timer.unref();
+
+    const client = { res, projectId, sessionId, timer };
+    clients.add(client);
+    const close = () => {
+      clients.delete(client);
+      clearInterval(timer);
+    };
+    req.on('close', close);
+    req.on('error', close);
+    res.on('close', close);
+    res.on('error', close);
+  }
+
+  async function handleApi(req, res, url) {
+    const method = req.method || 'GET';
+    const parts = url.pathname.split('/').filter(Boolean); // ['api', ...]
+    const [, a, b, c, d, e] = parts;
+
+    if (a === 'health') {
+      return sendJson(res, 200, { ok: true, seq });
+    }
+
+    if (a === 'config') {
+      if (method !== 'GET') throw new HttpError(405, 'Method Not Allowed');
+      return sendJson(res, 200, {
+        urls: accessUrls(port, host),
+      });
+    }
+
+    if (a === 'events') {
+      if (method !== 'GET') throw new HttpError(405, 'Method Not Allowed');
+      return handleSse(req, res, url);
+    }
+
+    if (a === 'fs') {
+      if (b === 'list') {
+        if (method !== 'GET') throw new HttpError(405, 'Method Not Allowed');
+        try {
+          return sendJson(res, 200, await listDirectories(url.searchParams.get('path') || ''));
+        } catch (e) {
+          throw new HttpError(400, e?.message || String(e));
+        }
+      }
+      if (b === 'mkdir') {
+        if (method !== 'POST') throw new HttpError(405, 'Method Not Allowed');
+        const body = await readJson(req);
+        try {
+          return sendJson(res, 201, await createDirectory(body.parent, body.name));
+        } catch (e) {
+          throw new HttpError(400, e?.message || String(e));
+        }
+      }
+      throw new HttpError(404, 'Not Found');
+    }
+
+    if (a !== 'projects') throw new HttpError(404, 'Not Found');
+
+    // /api/projects
+    if (!b) {
+      if (method === 'GET') {
+        return sendJson(res, 200, { projects: listProjects() });
+      }
+      if (method === 'POST') {
+        const body = await readJson(req);
+        const project = createProject({ name: body.name, path: body.path });
+        log(`新建项目：${project.name} → ${project.path}`);
+        return sendJson(res, 201, { project });
+      }
+      throw new HttpError(405, 'Method Not Allowed');
+    }
+
+    const project = projectOr404(b);
+
+    // /api/projects/:id
+    if (!c) {
+      if (method === 'DELETE') {
+        if (pool.runningSessions(project.id).size > 0) throw new HttpError(409, '项目里还有会话在运行');
+        const removed = removeProject(project.id);
+        pool.disposeProject(project.id);
+        return sendJson(res, 200, { removed: Boolean(removed) });
+      }
+      if (method === 'GET') return sendJson(res, 200, { project });
+      throw new HttpError(405, 'Method Not Allowed');
+    }
+
+    if (c !== 'sessions') throw new HttpError(404, 'Not Found');
+
+    // /api/projects/:id/sessions
+    if (!d) {
+      if (method === 'GET') {
+        const sessions = await listSessions(project);
+        const running = pool.runningSessions(project.id);
+        for (const s of sessions) s.running = running.has(s.id);
+        // 尚未落盘、但正在运行的新会话也放进列表
+        const known = new Set(sessions.map((s) => s.id));
+        for (const id of running) {
+          if (known.has(id)) continue;
+          const run = pool.getRun(project, id);
+          sessions.unshift({
+            id,
+            title: (run?.userText || '新会话').slice(0, 80),
+            name: '',
+            firstMessage: run?.userText || '',
+            created: new Date(run?.startedAt || Date.now()).toISOString(),
+            modified: new Date(run?.startedAt || Date.now()).toISOString(),
+            messageCount: 0,
+            path: '',
+            running: true,
+          });
+        }
+        return sendJson(res, 200, { sessions });
+      }
+      if (method === 'POST') {
+        const id = newSessionId();
+        return sendJson(res, 201, { session: { id, title: '新会话', name: '', messages: [] } });
+      }
+      throw new HttpError(405, 'Method Not Allowed');
+    }
+
+    const sessionId = sessionIdOr400(d);
+
+    // /api/projects/:id/sessions/:sid
+    if (!e) {
+      if (method === 'GET') {
+        const file = findSessionFile(project, sessionId);
+        const sm = openSessionManager(project, sessionId, file);
+        const session = readTranscript(sm);
+        return sendJson(res, 200, {
+          project: { id: project.id, name: project.name, path: project.path },
+          session,
+          run: pool.getRun(project, sessionId),
+          seq,
+        });
+      }
+      if (method === 'DELETE') {
+        if (pool.isRunning(project.id, sessionId)) throw new HttpError(409, '会话正在运行，无法删除');
+        const file = findSessionFile(project, sessionId);
+        pool.dispose(project.id, sessionId);
+        const deleted = file ? deleteSessionFile(file) : true;
+        return sendJson(res, 200, { deleted });
+      }
+      throw new HttpError(405, 'Method Not Allowed');
+    }
+
+    if (e === 'messages') {
+      if (method !== 'POST') throw new HttpError(405, 'Method Not Allowed');
+      const body = await readJson(req);
+      const text = typeof body.text === 'string' ? body.text.trim() : '';
+      if (!text) throw new HttpError(400, '消息不能为空');
+      if (text.length > 100_000) throw new HttpError(413, '消息过长');
+      const mode = body.mode === 'steer' || body.mode === 'followUp' ? body.mode : 'prompt';
+      try {
+        const result = await pool.send(project, sessionId, text, mode);
+        return sendJson(res, 202, result);
+      } catch (err) {
+        if (err?.code === 'RUNNING') throw new HttpError(409, '这个会话正在运行，请用插话或跟进');
+        if (mode !== 'prompt') throw new HttpError(400, err?.message || String(err));
+        throw err;
+      }
+    }
+
+    if (e === 'queue') {
+      if (method !== 'POST') throw new HttpError(405, 'Method Not Allowed');
+      const cleared = pool.clearQueue(project, sessionId);
+      return sendJson(res, 200, { cleared });
+    }
+
+    if (e === 'abort') {
+      if (method !== 'POST') throw new HttpError(405, 'Method Not Allowed');
+      const result = await pool.abort(project, sessionId);
+      return sendJson(res, 200, result);
+    }
+
+    throw new HttpError(404, 'Not Found');
+  }
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    try {
+      if (url.pathname.startsWith('/api/')) {
+        await handleApi(req, res, url);
+      } else if (req.method === 'GET' || req.method === 'HEAD') {
+        staticFile(res, url.pathname, req.method);
+      } else {
+        sendText(res, 405, 'Method Not Allowed');
+      }
+    } catch (err) {
+      if (res.headersSent) {
+        try { res.end(); } catch { }
+        return;
+      }
+      const status = err instanceof HttpError ? err.status : 500;
+      if (status >= 500) logErr('请求失败：', err?.stack || err);
+      sendJson(res, status, { error: err?.message || String(err) });
+    }
+  });
+
+  server.on('close', () => {
+    for (const client of clients) {
+      clearInterval(client.timer);
+      try { client.res.end(); } catch { }
+    }
+    clients.clear();
+    pool.disposeAll();
+  });
+
+  return { server, pool, currentSeq: () => seq };
+}
+
+export async function startServer({ port = getPort(), host = getHost() } = {}) {
+  const bindHost = host || '127.0.0.1';
+  const { server, pool, currentSeq } = createNookServer({ port, host: bindHost });
+  await new Promise((resolve, reject) => {
+    const onError = (err) => { server.off('listening', onListening); reject(err); };
+    const onListening = () => { server.off('error', onError); resolve(); };
+    server.once('error', onError);
+    server.once('listening', onListening);
+    server.listen(port, bindHost);
+  });
+  const address = server.address();
+  const actualPort = typeof address === 'object' && address ? address.port : port;
+  return { server, pool, currentSeq, port: actualPort, host: bindHost };
+}