@sanqianx/project-knowledge 4.7.0 → 5.0.0

package/_modules/knowledge-engine/src/runtime/scanner.js

@@ -0,0 +1,298 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { TextDecoder } = require('util');
+const { execGit } = require('./git-runner');
+const { DomainError } = require('./contracts');
+const { ExactPatchEvidenceBundle } = require('./evidence-bundle');
+
+const EMPTY_TREE_SHA = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+const DEFAULT_MAX_PATCH_BYTES = 2 * 1024 * 1024;
+
+function sha256(value) {
+  return `sha256:${crypto.createHash('sha256').update(value).digest('hex')}`;
+}
+
+function validateSha(value, name = 'commit') {
+  const sha = String(value || '').trim().toLowerCase();
+  if (!/^[0-9a-f]{40}$/.test(sha)) throw new DomainError('INVALID_ARGUMENT', `${name} must be a full Git commit SHA.`);
+  return sha;
+}
+
+function parseNameStatus(text) {
+  return String(text || '').split(/\r?\n/).filter(Boolean).map(line => {
+    const columns = line.split('\t');
+    const status = columns.shift() || '';
+    const renamed = /^[RC]/.test(status) && columns.length >= 2;
+    return {
+      status,
+      path: renamed ? columns[1] : columns[0] || '',
+      oldPath: renamed ? columns[0] : null,
+      binary: false,
+    };
+  });
+}
+
+function applyNumstat(files, text) {
+  const byPath = new Map(files.map(file => [file.path, file]));
+  for (const line of String(text || '').split(/\r?\n/).filter(Boolean)) {
+    const [added, deleted, ...nameParts] = line.split('\t');
+    const name = nameParts[nameParts.length - 1] || '';
+    const file = byPath.get(name);
+    if (!file) continue;
+    file.binary = added === '-' && deleted === '-';
+    file.added = added === '-' ? null : Number(added);
+    file.deleted = deleted === '-' ? null : Number(deleted);
+  }
+  return files;
+}
+
+class TrustedGitReader {
+  constructor(options = {}) {
+    this.execGit = options.execGit || execGit;
+    this.maxPatchBytes = Number(options.maxPatchBytes || DEFAULT_MAX_PATCH_BYTES);
+    this.evidenceBundle = options.evidenceBundle || new ExactPatchEvidenceBundle(options);
+  }
+
+  async run(repoPath, args, timeoutMs = 30_000) {
+    const result = await this.execGit(repoPath, args, timeoutMs);
+    if (!result || !result.ok) {
+      throw new DomainError('INVALID_ARGUMENT', 'Trusted Git read failed.', {
+        status: 409,
+        details: { args: args.slice(0, 4), code: result && result.code, error: String(result && (result.stderr || result.error) || '').slice(0, 1000) },
+      });
+    }
+    return String(result.stdout || '');
+  }
+
+  async runBuffer(repoPath, args, timeoutMs = 30_000) {
+    const result = await this.execGit(repoPath, args, timeoutMs);
+    if (!result || !result.ok) {
+      throw new DomainError('INVALID_ARGUMENT', 'Trusted Git read failed.', {
+        status: 409,
+        details: { args: args.slice(0, 4), code: result && result.code, error: String(result && (result.stderr || result.error) || '').slice(0, 1000) },
+      });
+    }
+    return Buffer.isBuffer(result.stdoutBuffer) ? result.stdoutBuffer : Buffer.from(String(result.stdout || ''), 'utf8');
+  }
+
+  async isRepository(repoPath) {
+    if (!repoPath || !fs.existsSync(repoPath)) return false;
+    const result = await this.execGit(repoPath, ['rev-parse', '--is-inside-work-tree'], 10_000);
+    return Boolean(result && result.ok && String(result.stdout || '').trim() === 'true');
+  }
+
+  async head(repoPath) {
+    const result = await this.execGit(repoPath, ['rev-parse', '--verify', 'HEAD'], 10_000);
+    if (!result || !result.ok) return null;
+    const sha = String(result.stdout || '').trim().toLowerCase();
+    return /^[0-9a-f]{40}$/.test(sha) ? sha : null;
+  }
+
+  async branch(repoPath) {
+    const result = await this.execGit(repoPath, ['symbolic-ref', '--quiet', '--short', 'HEAD'], 10_000);
+    return result && result.ok ? String(result.stdout || '').trim() : '';
+  }
+
+  async isAncestor(repoPath, ancestor, commit) {
+    validateSha(ancestor, 'baseline');
+    validateSha(commit, 'HEAD');
+    const result = await this.execGit(repoPath, ['merge-base', '--is-ancestor', ancestor, commit], 10_000);
+    return Boolean(result && result.ok);
+  }
+
+  async listCommits(repoPath, baseline, head) {
+    validateSha(head, 'HEAD');
+    const revision = baseline ? `${validateSha(baseline, 'baseline')}..${head}` : head;
+    const output = await this.run(repoPath, ['rev-list', '--reverse', '--topo-order', revision]);
+    return output.split(/\r?\n/).map(value => value.trim().toLowerCase()).filter(value => /^[0-9a-f]{40}$/.test(value));
+  }
+
+  async collectEvidence(repoPath, commitSha, options = {}) {
+    const commit = validateSha(commitSha);
+    const raw = await this.run(repoPath, ['show', '-s', '--date=iso-strict', '--format=%H%x00%P%x00%an%x00%aI%x00%s', commit]);
+    const [resolved, parentsRaw, author, date, ...subjectParts] = raw.replace(/\r?\n$/, '').split('\u0000');
+    const parents = String(parentsRaw || '').split(/\s+/).filter(Boolean).map(parent => validateSha(parent, 'parent'));
+    const nameStatus = await this.run(repoPath, ['diff-tree', '--root', '--find-renames', '--name-status', '-r', '--no-commit-id', commit]);
+    const numstat = await this.run(repoPath, ['diff-tree', '--root', '--find-renames', '--numstat', '-r', '--no-commit-id', commit]);
+    const files = applyNumstat(parseNameStatus(nameStatus), numstat);
+    const base = parents.length ? parents[0] : EMPTY_TREE_SHA;
+    const patchBuffer = await this.runBuffer(repoPath, ['diff', '--no-ext-diff', '--binary', '--find-renames', '--unified=3', base, commit], options.patchTimeoutMs || 60_000);
+    const patchBytes = patchBuffer.length;
+    const maxPatchBytes = Number(options.maxPatchBytes || this.maxPatchBytes);
+    let patch = null;
+    try { patch = new TextDecoder('utf-8', { fatal: true }).decode(patchBuffer); } catch { patch = null; }
+    const patchChunked = patchBytes > maxPatchBytes || patch == null;
+    const branch = options.branch != null ? String(options.branch) : await this.branch(repoPath);
+    const metadata = {
+      commitSha: resolved || commit,
+      parents,
+      author: author || '',
+      date: date || '',
+      subject: subjectParts.join('\u0000').trim(),
+      branch,
+      patchBase: base,
+      patchMode: parents.length > 1 ? 'merge-first-parent' : parents.length === 0 ? 'root-empty-tree' : 'parent',
+    };
+    const patchHash = sha256(patchBuffer);
+    if (patchChunked && !options.evidenceRoot) {
+      throw new DomainError('EVIDENCE_INTEGRITY_FAILED', 'Large patch requires an exact evidence bundle root.', { status: 500 });
+    }
+    const evidenceBundle = options.evidenceRoot ? this.evidenceBundle.build({
+      evidenceRoot: options.evidenceRoot,
+      patch: patchBuffer,
+      patchHash,
+      commit: metadata,
+      files,
+    }) : null;
+    const evidenceHash = sha256(JSON.stringify({
+      metadata,
+      files,
+      patchHash,
+      patchBytes,
+      evidenceManifestHash: evidenceBundle && evidenceBundle.manifestHash || null,
+    }));
+    return {
+      schema: 'commit-evidence/v1',
+      ...metadata,
+      files,
+      patch: patchChunked ? null : patch,
+      patchHash,
+      patchBytes,
+      patchInline: !patchChunked,
+      patchChunked,
+      patchOmitted: false,
+      patchLimitBytes: maxPatchBytes,
+      omittedReason: null,
+      evidenceBundle,
+      evidenceHash,
+    };
+  }
+
+  verifyEvidence(evidence) {
+    if (!evidence || !evidence.patchHash || !Number.isInteger(evidence.patchBytes)) {
+      throw new DomainError('EVIDENCE_INTEGRITY_FAILED', 'Commit evidence is incomplete.', { status: 500 });
+    }
+    if (evidence.evidenceBundle) {
+      return this.evidenceBundle.verify(evidence.evidenceBundle.root, {
+        expectedPatchHash: evidence.patchHash,
+        expectedBytes: evidence.patchBytes,
+      });
+    }
+    if (evidence.patchChunked) {
+      throw new DomainError('EVIDENCE_INTEGRITY_FAILED', 'Chunked patch has no frozen evidence bundle.', { status: 500 });
+    }
+    if (sha256(evidence.patch || '') !== evidence.patchHash) {
+      throw new DomainError('EVIDENCE_INTEGRITY_FAILED', 'Inline patch hash does not match.', { status: 500 });
+    }
+    return null;
+  }
+}
+
+class CommitScanner {
+  constructor(options = {}) {
+    this.git = options.gitReader || new TrustedGitReader(options);
+    this.batchSize = Math.max(1, Number(options.batchSize || 200));
+  }
+
+  async scan(config, state, options = {}) {
+    const repoPath = config && config.repoPath;
+    if (!repoPath || !await this.git.isRepository(repoPath)) {
+      return { status: 'not-git', head: null, baseline: null, commits: [], continuation: null, error: 'repoPath is not an available Git worktree' };
+    }
+    const head = await this.git.head(repoPath);
+    if (!head) {
+      return { status: 'empty-repo', head: null, baseline: null, commits: [], continuation: null, branch: await this.git.branch(repoPath) };
+    }
+    const branch = await this.git.branch(repoPath);
+    const last = state && state.lastAnalyzedCommit || null;
+    const tracking = state && state.trackingStartCommit || null;
+    const baseline = last || tracking || null;
+    if (!baseline && (!state || state.trackingMode !== 'empty-repo')) {
+      return { status: 'establish-tracking', head, baseline: null, commits: [], continuation: null, branch };
+    }
+    if (baseline && !await this.git.isAncestor(repoPath, baseline, head)) {
+      return { status: 'history-diverged', head, baseline, commits: [], continuation: null, branch, error: 'tracking baseline is not an ancestor of HEAD' };
+    }
+    const all = await this.git.listCommits(repoPath, baseline, head);
+    const batchSize = Math.max(1, Number(options.batchSize || this.batchSize));
+    const commits = all.slice(0, batchSize);
+    return {
+      status: 'ok',
+      head,
+      baseline,
+      branch,
+      commits,
+      pendingCount: all.length,
+      continuation: all.length > commits.length ? { remaining: all.length - commits.length, after: commits[commits.length - 1] } : null,
+    };
+  }
+
+  collectEvidence(config, commitSha, options = {}) {
+    return this.git.collectEvidence(config.repoPath, commitSha, options);
+  }
+
+  verifyEvidence(evidence) {
+    return this.git.verifyEvidence(evidence);
+  }
+}
+
+// Transitional read-only adapter for callers migrated in T10.
+async function scanProject(project, options = {}) {
+  const scanner = options.scanner || new CommitScanner(options);
+  const config = { repoPath: project && (project.repoPath || project.gitPath || project.localPath) };
+  const state = {
+    lastAnalyzedCommit: project && project.lastAnalyzedCommit || null,
+    trackingStartCommit: project && project.trackingStartCommit || null,
+    trackingMode: project && project.trackingMode || 'normal',
+  };
+  const scan = await scanner.scan(config, state, options);
+  const result = {
+    slug: project && (project.projectId || project.slug),
+    repoStatus: scan.status === 'empty-repo' ? 'empty' : scan.status === 'not-git' ? 'not-git' : scan.status === 'history-diverged' ? 'diverged' : 'ok',
+    headCommit: scan.head,
+    lastAnalyzedCommit: state.lastAnalyzedCommit,
+    trackingStartCommit: scan.status === 'establish-tracking' ? scan.head : state.trackingStartCommit,
+    pendingCount: scan.commits.length,
+    mode: scan.status === 'establish-tracking' ? 'tracking-start' : state.lastAnalyzedCommit ? 'incremental' : state.trackingMode === 'empty-repo' ? 'empty-repo-first-commit' : 'tracked',
+    range: scan.baseline && scan.head ? `${scan.baseline}..${scan.head}` : null,
+    commits: [],
+    continuation: scan.continuation,
+    error: scan.error || null,
+  };
+  for (const commitSha of scan.commits) {
+    const evidence = await scanner.collectEvidence(config, commitSha, { branch: scan.branch });
+    result.commits.push({
+      hash: commitSha,
+      short: commitSha.slice(0, 7),
+      date: evidence.date,
+      author: evidence.author,
+      subject: evidence.subject,
+    });
+  }
+  return result;
+}
+
+async function applyScanResult(project, scan) {
+  project.headCommit = scan.headCommit;
+  project.repoStatus = scan.repoStatus;
+  if (!project.trackingStartCommit && scan.trackingStartCommit) project.trackingStartCommit = scan.trackingStartCommit;
+  project.lastSeenCommit = scan.headCommit || project.lastSeenCommit;
+  project.lastScanAt = new Date().toISOString();
+  project.lastScanPendingCount = scan.pendingCount;
+  project.lastScanMode = scan.mode;
+  project.lastScanError = scan.error || null;
+  return project;
+}
+
+module.exports = {
+  EMPTY_TREE_SHA,
+  DEFAULT_MAX_PATCH_BYTES,
+  TrustedGitReader,
+  CommitScanner,
+  scanProject,
+  applyScanResult,
+  parseNameStatus,
+  sha256,
+  validateSha,
+};

package/_modules/knowledge-engine/src/server.js

@@ -0,0 +1,154 @@
+'use strict';
+const http = require('node:http');
+const path = require('node:path');
+const fs = require('node:fs');
+const crypto = require('node:crypto');
+const { EngineStore } = require('./store');
+const { EngineCoordinator } = require('./coordinator');
+const AtomicFile = require('./runtime/atomic-file');
+
+const VERSION = require('../package.json').version;
+const UI_DIR = path.resolve(__dirname, '..', 'ui');
+const STATIC_FILES = new Map([['/', ['index.html', 'text/html']], ['/index.html', ['index.html', 'text/html']], ['/app.js', ['app.js', 'text/javascript']], ['/app.css', ['app.css', 'text/css']]]);
+
+function createEngineServer(options = {}) {
+  const dataDir = options.dataDir || path.join(process.cwd(), 'data-v3');
+  const store = options.store || new EngineStore(dataDir, { deferLoad: true });
+  let releaseLease;
+  const coordinator = new EngineCoordinator(store, { ...options, initializeHook: async () => {
+    try { releaseLease = await AtomicFile.acquireFileLock(path.join(store.dataDir, 'engine-runtime.lock'), { timeoutMs: 0 }); }
+    catch (error) { throw Object.assign(new Error('此数据目录已有引擎运行，请勿启动第二个知识写入者。'), { code: 'ENGINE_ALREADY_RUNNING', cause: error }); }
+    try { if (!options.store) store.load(); } catch (error) { await releaseLease(); releaseLease = null; throw error; }
+  } });
+  const startedAt = Date.now();
+  const connections = new Set();
+  const runtimeToken = options.runtimeToken || process.env.KB_ENGINE_RUNTIME_TOKEN;
+  function trusted(req) {
+    const value = String(req.headers.authorization || '').replace(/^Bearer /, '');
+    const address = req.socket.remoteAddress;
+    return !req.headers.origin && ['127.0.0.1', '::1', '::ffff:127.0.0.1'].includes(address) && runtimeToken && Buffer.byteLength(value) === Buffer.byteLength(runtimeToken) && crypto.timingSafeEqual(Buffer.from(value), Buffer.from(runtimeToken));
+  }
+  async function handle(req, res) {
+    const url = new URL(req.url, 'http://localhost');
+    const pathname = url.pathname;
+    if (req.headers.origin && req.headers.origin !== `http://${req.headers.host}`) throw httpError(403, 'FORBIDDEN_ORIGIN', '不允许跨来源访问。');
+    if (pathname === '/api/progress' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive', 'X-Accel-Buffering': 'no' });
+      connections.add(res);
+      const projectId = url.searchParams.get('projectId');
+      res.write(`event: snapshot\ndata: ${JSON.stringify({ cursor: store.state.cursor, runs: store.listRuns(projectId || null) })}\n\n`);
+      const listener = event => { if ((!projectId || event.projectId === projectId) && !res.destroyed) res.write(`id: ${event.seq || store.state.cursor}\nevent: progress\ndata: ${JSON.stringify(event)}\n\n`); };
+      coordinator.on('progress', listener);
+      const heartbeat = setInterval(() => { if (!res.destroyed) res.write(': heartbeat\n\n'); }, 15000);
+      res.on('close', () => { clearInterval(heartbeat); coordinator.off('progress', listener); connections.delete(res); });
+      return;
+    }
+    if (pathname.startsWith('/api/')) {
+      const body = await readBody(req);
+      if (pathname === '/api/runtime-auth' && req.method === 'GET') {
+        if (!trusted(req)) throw httpError(403, 'RUNTIME_AUTH_REQUIRED', '仅允许受信任外壳检查连接。');
+        send(res, 200, { ok: true, dataSchemaVersion: store.state.schemaVersion }); return;
+      }
+      if (pathname === '/api/control' && req.method === 'POST') {
+        if (!trusted(req)) throw httpError(403, 'RUNTIME_AUTH_REQUIRED', '仅允许受信任外壳切换运行所有权。');
+        if (body.enabled !== true) throw httpError(400, 'INVALID_ARGUMENT', '只支持外壳完成接线后的启用操作。');
+        await coordinator.activate(); send(res, 200, { ok: true }); return;
+      }
+      if (pathname === '/api/runtime-config' && req.method === 'POST') {
+        if (!trusted(req)) throw httpError(403, 'RUNTIME_AUTH_REQUIRED', '仅允许受信任本地服务解析配置。');
+        coordinator.setProfile(body.projectId || 'default', body.profile);
+        send(res, 200, { ok: true });
+        return;
+      }
+      if (pathname === '/api/scopes' && req.method === 'POST') {
+        if (!trusted(req)) throw httpError(403, 'RUNTIME_AUTH_REQUIRED', '仅允许外壳登记共享范围。');
+        const scopes = await coordinator.memories.configure(body.scopes);
+        coordinator.syncSharedIndexes();
+        send(res, 200, { ok: true, scopes }); return;
+      }
+      send(res, 200, { ok: true, ...await api(req.method, pathname, url.searchParams, body, store, coordinator, { dataDir, startedAt, debug: options.debug === true }) });
+      return;
+    }
+    const entry = STATIC_FILES.get(pathname);
+    if (entry && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': `${entry[1]}; charset=utf-8` });
+      res.end(fs.readFileSync(path.join(UI_DIR, entry[0])));
+      return;
+    }
+    throw httpError(404, 'NOT_FOUND', '页面不存在。');
+  }
+  const server = http.createServer((req, res) => handle(req, res).catch(error => {
+    if (!res.headersSent) send(res, error.status || 500, { ok: false, error: error.code || 'INTERNAL', message: error.message });
+    else res.destroy();
+  }));
+  server.store = store;
+  server.coordinator = coordinator;
+  let closing;
+  async function close() {
+    if (closing) return closing;
+    closing = (async () => {
+      await coordinator.ready.catch(() => {});
+      await coordinator.close();
+      for (const response of connections) response.end(); server.closeAllConnections();
+      await new Promise(resolve => server.close(resolve));
+      await releaseLease?.(); releaseLease = null;
+    })();
+    return closing;
+  }
+  server.on('close', () => { if (!closing) close(); });
+  return { server, store, coordinator, ready: coordinator.ready, close };
+}
+
+async function api(method, pathname, search, body, store, coordinator, ctx) {
+  if (method === 'GET' && pathname === '/api/health') return { name: 'knowledge-engine', version: VERSION, dataSchemaVersion: store.state.schemaVersion, debug: ctx.debug, executionEnabled: coordinator.executionEnabled, uptimeSec: Math.floor((Date.now() - ctx.startedAt) / 1000), dataDir: ctx.dataDir, counts: { projects: store.state.projects.length, runs: store.state.runs.length, running: coordinator.active.size }, journal: { cursor: store.state.cursor, cursors: store.state.journalCursors, consumer: 'knowledge-engine', enabled: coordinator.consume, error: coordinator.journalError || null }, concurrency: coordinator.concurrency };
+  if (method === 'GET' && pathname === '/api/projects') return { projects: store.listProjects() };
+  if (method === 'GET' && pathname === '/api/memories') return { memories: coordinator.memories.list(Object.fromEntries(search)) };
+  const memoryMatch = pathname.match(/^\/api\/memories\/([^/]+)$/);
+  if (method === 'PATCH' && memoryMatch) {
+    const memory = await coordinator.memories.update(decodeURIComponent(memoryMatch[1]), body);
+    coordinator.emit('progress', store.addEvent({ type: 'memory.updated', summary: memory.status === 'confirmed' ? '已确认长期记忆' : memory.status === 'ignored' ? '已忽略记忆候选' : '已编辑记忆候选' }));
+    return { memory };
+  }
+  if (method === 'POST' && pathname === '/api/projects') {
+    const result = store.addProject(body);
+    if (!result.reused) store.addEvent({ type: 'project.register', projectId: body.projectId, summary: `登记 ${result.project.name}` });
+    return result;
+  }
+  const projectMatch = pathname.match(/^\/api\/projects\/([^/]+)$/);
+  if (method === 'DELETE' && projectMatch) {
+    const result = await coordinator.removeProject(decodeURIComponent(projectMatch[1]));
+    if (!result.removed) throw httpError(404, 'NOT_FOUND', '项目未登记。');
+    return { ...result, keptData: true };
+  }
+  if (method === 'GET' && pathname === '/api/runs') return { runs: store.listRuns(search.get('projectId')) };
+  const runMatch = pathname.match(/^\/api\/runs\/([^/]+)(\/retry)?$/);
+  if (runMatch) {
+    const id = decodeURIComponent(runMatch[1]);
+    if (method === 'POST' && runMatch[2]) return { run: await coordinator.retry(id) || store.getRun(id) };
+    if (method === 'GET' && !runMatch[2]) { const run = store.getRun(id); if (!run) throw httpError(404, 'NOT_FOUND', '运行不存在。'); return { run }; }
+  }
+  if (method === 'POST' && pathname === '/api/runs') {
+    if (!ctx.debug) throw httpError(403, 'DEBUG_DISABLED', '正式运行只消费提交事件，手工运行仅在调试模式中可用。');
+    return { run: coordinator.enqueue({ projectId: body.projectId, commitSha: body.commitSha, trigger: 'manual-debug', debugFailure: ctx.debug && body.simulateFailure === true }) };
+  }
+  if (method === 'POST' && ['/api/search', '/api/ask', '/api/get', '/api/history'].includes(pathname)) return coordinator.retrieval[pathname.slice(5)](body);
+  if (method === 'GET' && ['/api/get', '/api/history'].includes(pathname)) return coordinator.retrieval[pathname.slice(5)](Object.fromEntries(search));
+  if (method === 'GET' && pathname === '/api/events') return { events: store.listEvents(search.get('limit')).filter(e => !search.get('projectId') || e.projectId === search.get('projectId')) };
+  if (method === 'POST' && pathname === '/api/events' && ctx.debug) return { event: store.addEvent(body) };
+  if (method === 'POST' && pathname === '/api/bridge/notify') { if (coordinator.consume) coordinator.drain(); return { accepted: true }; }
+  if (method === 'GET' && pathname === '/api/snapshot') return { projects: store.listProjects(), runs: store.listRuns(search.get('projectId')), events: store.listEvents(50), memories: store.state.memories, sharedScopes: store.state.sharedScopes };
+  throw httpError(404, 'NOT_FOUND', '接口不存在。');
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', chunk => { size += chunk.length; if (size > 1024 * 1024) { reject(httpError(413, 'BODY_TOO_LARGE', '请求过大。')); req.resume(); } else chunks.push(chunk); });
+    req.on('end', () => { if (!size) return resolve({}); try { const value = JSON.parse(Buffer.concat(chunks).toString('utf8')); if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid body'); resolve(value); } catch { reject(httpError(400, 'INVALID_ARGUMENT', '请求必须为 JSON 对象。')); } });
+    req.on('error', reject);
+  });
+}
+function send(res, status, payload) { res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(payload)); }
+function httpError(status, code, message) { return Object.assign(new Error(message), { status, code }); }
+module.exports = { createEngineServer };