@cloud411716/fancy-webnovel 1.0.46 → 3.0.0

package/plugins/fancy-story-builder/storydb/import.js

@@ -0,0 +1,559 @@
+/**
+ * Import legacy stage JSON into the story graph.
+ *
+ * This is the bridge for existing projects and for the old `build` commands.
+ * The LLM-native path is `storydb apply`; this importer is for bootstrapping.
+ * Each chapter/outline/text is its own change_set.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { apply } from './store.js';
+
+function readJson(file, fallback = null) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
+}
+
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function stagePath(root, stage, ...parts) {
+  return path.join(root, '设定', stage, ...parts);
+}
+
+async function run(sdb, workflow, summary, ops, decisions = []) {
+  return apply(sdb, { workflow, summary, ops, decisions });
+}
+
+function idOf(value) {
+  return String(value || '').split(':').pop().replace(/[⟨⟩]/g, '');
+}
+
+// ---------------------------------------------------------------------------
+// scale
+// ---------------------------------------------------------------------------
+
+export async function importScale(sdb, root) {
+  const scale = readJson(stagePath(root, '10-scale', 'scale.json'), null);
+  if (!scale) throw new Error('缺少 10-scale/scale.json');
+  const ops = [{ op: 'create', kind: 'scale', data: scale }];
+  for (const volume of asArray(scale.structure && scale.structure.volumes)) {
+    const vid = volume.volume_id || volume.id;
+    ops.push({
+      op: 'create',
+      kind: 'volume',
+      data: {
+        volume_id: vid,
+        title: volume.title,
+        chapter_start: volume.chapter_start,
+        chapter_end: volume.chapter_end,
+        goal: volume.goal,
+        core_conflict: volume.core_conflict,
+        emotional_arc: volume.emotional_arc,
+        ending_hook: volume.ending_hook,
+      },
+    });
+    ops.push({ op: 'link', edge: 'has_volume', from: 'story:main', to: 'volume:' + vid, data: {} });
+    for (const act of asArray(volume.acts)) {
+      const aid = act.act_id || act.id;
+      ops.push({
+        op: 'create',
+        kind: 'act',
+        data: {
+          act_id: aid,
+          volume_id: vid,
+          act_index: act.act_index,
+          chapter_start: act.chapter_start,
+          chapter_end: act.chapter_end,
+          goal: act.goal,
+        },
+      });
+      ops.push({ op: 'link', edge: 'has_act', from: 'volume:' + vid, to: 'act:' + aid, data: {} });
+    }
+  }
+  return run(sdb, 'scale', 'import scale', ops);
+}
+
+// ---------------------------------------------------------------------------
+// macro
+// ---------------------------------------------------------------------------
+
+export async function importMacro(sdb, root) {
+  const dir = stagePath(root, '20-macro');
+  const world = readJson(path.join(dir, 'world.json'), {});
+  const story = readJson(path.join(dir, 'story.json'), {});
+  const volumes = readJson(path.join(dir, 'volumes.json'), { volumes: [] });
+  const lines = readJson(path.join(dir, 'lines.json'), { main_line: {}, branches: [] });
+  const endings = readJson(path.join(dir, 'endings.json'), { endings: [] });
+  const emotion = readJson(path.join(dir, 'emotion.json'), { volumes: [] });
+  const roles = readJson(path.join(dir, 'roles.json'), { roles: [] });
+
+  const ops = [
+    { op: 'create', kind: 'world_doc', data: world },
+    { op: 'create', kind: 'story_doc', data: story },
+    { op: 'create', kind: 'emotion_doc', data: { volumes: emotion.volumes || [] } },
+  ];
+
+  for (const volume of asArray(volumes.volumes)) {
+    const vid = volume.id || volume.volume_id;
+    ops.push({
+      op: 'create',
+      kind: 'volume',
+      data: {
+        volume_id: vid,
+        title: volume.title,
+        chapter_start: volume.chapter_start,
+        chapter_end: volume.chapter_end,
+        goal: volume.goal,
+        core_conflict: volume.core_conflict,
+        emotional_arc: volume.emotional_arc,
+        ending_hook: volume.ending_hook,
+      },
+    });
+    ops.push({ op: 'link', edge: 'has_volume', from: 'story:main', to: 'volume:' + vid, data: {} });
+    for (const act of asArray(volume.acts)) {
+      const aid = act.act_id || act.id;
+      ops.push({
+        op: 'create',
+        kind: 'act',
+        data: {
+          act_id: aid,
+          volume_id: vid,
+          act_index: act.act_index,
+          chapter_start: act.chapter_start,
+          chapter_end: act.chapter_end,
+          goal: act.goal,
+          climax: act.climax,
+        },
+      });
+      ops.push({ op: 'link', edge: 'has_act', from: 'volume:' + vid, to: 'act:' + aid, data: {} });
+    }
+  }
+
+  const main = lines.main_line || {};
+  if (main.id || main.name) {
+    const lineId = main.id || 'M001';
+    ops.push({
+      op: 'create',
+      kind: 'line',
+      data: {
+        line_id: lineId,
+        kind: 'main',
+        name: main.name || '主线',
+        goal: main.goal,
+      },
+    });
+    for (const node of asArray(main.nodes)) {
+      ops.push({
+        op: 'create',
+        kind: 'line_node',
+        data: {
+          node_id: node.id,
+          line_id: lineId,
+          volume: node.volume,
+          act: node.act,
+          goal: node.goal,
+          turn: node.turn,
+        },
+      });
+    }
+  }
+  for (const branch of asArray(lines.branches)) {
+    ops.push({
+      op: 'create',
+      kind: 'line',
+      data: {
+        line_id: branch.id,
+        kind: 'branch',
+        name: branch.name || branch.id,
+        goal: branch.goal,
+        start: branch.start,
+        turning: branch.turning,
+        resolution: branch.resolution,
+        interweaves: branch.interweaves || [],
+      },
+    });
+  }
+
+  for (const ending of asArray(endings.endings)) {
+    ops.push({
+      op: 'create',
+      kind: 'ending',
+      data: {
+        ending_id: ending.id,
+        level: ending.level,
+        type: ending.type,
+        direction: ending.direction,
+        required_foreshadow_recovery: ending.required_foreshadow_recovery || [],
+      },
+    });
+  }
+
+  for (const role of asArray(roles.roles)) {
+    ops.push({
+      op: 'create',
+      kind: 'role_slot',
+      data: {
+        role_id: role.role_id || role.id,
+        name: role.name || role.role_id || role.id || role.function,
+        slot_function: role.slot_function || role.function,
+        quota_key: role.quota_key,
+      },
+    });
+  }
+
+  return run(sdb, 'macro', 'import macro', ops);
+}
+
+// ---------------------------------------------------------------------------
+// cast
+// ---------------------------------------------------------------------------
+
+const CAST_ENTITIES = [
+  ['characters', 'characters', 'character'],
+  ['factions', 'factions', 'faction'],
+  ['locations', 'locations', 'location'],
+  ['items', 'items', 'item'],
+  ['conflicts', 'conflicts', 'conflict'],
+  ['foreshadows', 'foreshadows', 'foreshadow'],
+  ['climaxes', 'climaxes', 'climax'],
+  ['payoffs', 'payoffs', 'payoff'],
+  ['information', 'information_gaps', 'information'],
+];
+
+export async function importCast(sdb, root) {
+  const dir = stagePath(root, '30-cast');
+  const ops = [];
+  for (const [file, listKey, kind] of CAST_ENTITIES) {
+    const doc = readJson(path.join(dir, file + '.json'), null);
+    if (!doc) throw new Error('缺少 30-cast/' + file + '.json');
+    for (const row of asArray(doc[listKey])) {
+      const data = { ...row };
+      if (kind === 'information') data.info_name = row.info_name || row.name;
+      if (kind === 'item' && data.item_function === undefined && data.function !== undefined) {
+        data.item_function = data.function;
+      }
+      ops.push({ op: 'create', kind, data });
+    }
+  }
+
+  const rels = readJson(path.join(dir, 'relations.json'), { character_relations: [], faction_relations: [], memberships: [] });
+  for (const rel of asArray(rels.character_relations)) {
+    ops.push({
+      op: 'link', edge: 'relation',
+      from: 'character:' + idOf(rel.from),
+      to: 'character:' + idOf(rel.to),
+      data: { kind: rel.kind, initial_state: rel.initial_state, changes: rel.changes || [] },
+    });
+  }
+  for (const rel of asArray(rels.faction_relations)) {
+    ops.push({
+      op: 'link', edge: 'faction_relation',
+      from: 'faction:' + idOf(rel.from),
+      to: 'faction:' + idOf(rel.to),
+      data: { kind: rel.kind, initial_state: rel.initial_state, changes: rel.changes || [] },
+    });
+  }
+  for (const member of asArray(rels.memberships)) {
+    ops.push({
+      op: 'link', edge: 'membership',
+      from: 'character:' + idOf(member.character || member.from),
+      to: 'faction:' + idOf(member.faction || member.to),
+      data: { role: member.role },
+    });
+  }
+
+  const conflicts = readJson(path.join(dir, 'conflicts.json'), { conflicts: [] });
+  for (const conflict of asArray(conflicts.conflicts)) {
+    for (const participant of asArray(conflict.participants)) {
+      if (!idOf(participant).startsWith('C')) continue;
+      ops.push({
+        op: 'link', edge: 'conflict_participant',
+        from: 'conflict:' + idOf(conflict.id), to: 'character:' + idOf(participant), data: {},
+      });
+    }
+  }
+  const climaxes = readJson(path.join(dir, 'climaxes.json'), { climaxes: [] });
+  for (const climax of asArray(climaxes.climaxes)) {
+    for (const participant of asArray(climax.participants)) {
+      if (!idOf(participant).startsWith('C')) continue;
+      ops.push({
+        op: 'link', edge: 'climax_participant',
+        from: 'climax:' + idOf(climax.id), to: 'character:' + idOf(participant), data: {},
+      });
+    }
+  }
+  const foreshadows = readJson(path.join(dir, 'foreshadows.json'), { foreshadows: [] });
+  const payoffIds = new Set(asArray(readJson(path.join(dir, 'payoffs.json'), { payoffs: [] }).payoffs).map((row) => idOf(row.id)));
+  for (const fsRow of asArray(foreshadows.foreshadows)) {
+    if (!fsRow.payoff_target || !payoffIds.has(idOf(fsRow.payoff_target))) continue;
+    ops.push({
+      op: 'link', edge: 'foreshadow_payoff',
+      from: 'foreshadow:' + idOf(fsRow.id), to: 'payoff:' + idOf(fsRow.payoff_target),
+      data: { relation: fsRow.recovery_requirement },
+    });
+  }
+
+  return run(sdb, 'cast', 'import cast', ops);
+}
+
+// ---------------------------------------------------------------------------
+// rhythm
+// ---------------------------------------------------------------------------
+
+function actionName(value) {
+  const map = {
+    埋设: 'plant', 推进: 'progress', 强化: 'progress', 回收: 'reveal',
+    铺垫: 'setup', 兑现: 'payoff', 收束: 'close',
+    created: 'created', progressed: 'progressed', resolved: 'resolved',
+  };
+  return map[value] || value;
+}
+
+export async function importRhythm(sdb, root, opts = {}) {
+  const map = readJson(stagePath(root, '40-rhythm', 'chapter_map.json'), null);
+  if (!map) throw new Error('缺少 40-rhythm/chapter_map.json');
+  const chapters = [...asArray(map.chapters)].sort((a, b) => Number(a.display_no) - Number(b.display_no));
+  const results = [];
+  for (const chapter of chapters) {
+    const no = Number(chapter.display_no);
+    const cid = String(chapter.chapter_id);
+    const ops = [
+      {
+        op: 'create', kind: 'chapter',
+        data: {
+          chapter_id: cid,
+          display_no: no,
+          title: chapter.title,
+          volume: chapter.volume,
+          act: chapter.act,
+          pov: chapter.pov,
+          time: chapter.time || {},
+          why: chapter.why || {},
+          how: chapter.how || {},
+          emotion: chapter.emotion || {},
+          hook: chapter.hook || {},
+          word_target: Number(chapter.word_target) || 0,
+        },
+      },
+      { op: 'link', edge: 'has_chapter', from: 'act:' + chapter.act, to: 'chapter:' + cid, data: {} },
+    ];
+    const cast = [...new Set(asArray(chapter.cast).map(idOf))];
+    for (const character of cast) {
+      ops.push({
+        op: 'link', edge: 'chapter_cast', from: 'chapter:' + cid, to: 'character:' + character,
+        data: { role: chapter.pov && idOf(chapter.pov) === character ? 'pov' : 'cast' },
+      });
+    }
+    if (chapter.pov && !cast.includes(idOf(chapter.pov))) {
+      ops.push({ op: 'link', edge: 'chapter_cast', from: 'chapter:' + cid, to: 'character:' + idOf(chapter.pov), data: { role: 'pov' } });
+    }
+    for (const character of asArray(chapter.mentioned).map(idOf)) {
+      ops.push({ op: 'link', edge: 'chapter_cast', from: 'chapter:' + cid, to: 'character:' + character, data: { role: 'mentioned' } });
+    }
+    for (const location of [...new Set(asArray(chapter.locations).map(idOf))]) {
+      ops.push({ op: 'link', edge: 'chapter_location', from: 'chapter:' + cid, to: 'location:' + location, data: {} });
+    }
+    for (const node of asArray(chapter.why && chapter.why.main_line_nodes).map(idOf)) {
+      ops.push({ op: 'link', edge: 'chapter_line_node', from: 'chapter:' + cid, to: 'line_node:' + node, data: {} });
+    }
+    for (const branch of asArray(chapter.why && chapter.why.branch_nodes).map(idOf)) {
+      ops.push({ op: 'link', edge: 'chapter_branch', from: 'chapter:' + cid, to: 'line:' + branch, data: {} });
+    }
+    for (const conflict of asArray(chapter.why && chapter.why.conflict).map(idOf)) {
+      ops.push({ op: 'link', edge: 'chapter_conflict', from: 'chapter:' + cid, to: 'conflict:' + conflict, data: {} });
+    }
+    for (const action of asArray(chapter.foreshadow_actions)) {
+      ops.push({
+        op: 'link', edge: 'foreshadow_action',
+        from: 'chapter:' + cid, to: 'foreshadow:' + idOf(action.id),
+        data: { action: actionName(action.action), chapter_no: no, detail: action.detail },
+      });
+    }
+    for (const action of asArray(chapter.payoff_actions)) {
+      ops.push({
+        op: 'link', edge: 'payoff_action',
+        from: 'chapter:' + cid, to: 'payoff:' + idOf(action.id),
+        data: { action: actionName(action.action), chapter_no: no, detail: action.detail },
+      });
+    }
+    for (const gap of asArray(chapter.information_gaps)) {
+      ops.push({
+        op: 'link', edge: 'info_action',
+        from: 'chapter:' + cid, to: 'information:' + idOf(gap.id),
+        data: { action: gap.state || 'progressed', chapter_no: no, detail: gap.detail },
+      });
+    }
+    for (const action of asArray(chapter.ending_actions)) {
+      ops.push({
+        op: 'link', edge: 'ending_action',
+        from: 'chapter:' + cid, to: 'ending:' + idOf(action.id),
+        data: { action: 'close', chapter_no: no, detail: action.detail },
+      });
+    }
+    for (const event of asArray(chapter.knowledge_events)) {
+      ops.push({
+        op: 'knowledge',
+        data: {
+          chapter_id: cid,
+          chapter_no: no,
+          subject_type: event.subject_type,
+          subject_id: event.subject_id,
+          character_id: idOf(event.character),
+          change: event.change,
+          coverage: event.coverage,
+          knowledge: event.knowledge,
+          how: event.how,
+          source_character: event.source_character,
+          scene: event.scene,
+          evidence: event.evidence,
+        },
+      });
+    }
+    results.push(await run(sdb, 'rhythm', 'import chapter ' + cid, ops));
+    if (opts.onProgress) opts.onProgress({ chapter: cid, no });
+  }
+  return { chapters: results.length, results };
+}
+
+// ---------------------------------------------------------------------------
+// outline
+// ---------------------------------------------------------------------------
+
+export async function importOutlines(sdb, root) {
+  const dir = stagePath(root, '40-rhythm', 'outlines');
+  if (!fs.existsSync(dir)) throw new Error('缺少 40-rhythm/outlines/');
+  const names = fs.readdirSync(dir).filter((name) => name.endsWith('.json')).sort();
+  const results = [];
+  for (const name of names) {
+    const raw = readJson(path.join(dir, name), null);
+    if (!raw) continue;
+    const outline = raw.chapter || raw;
+    const cid = outline.chapter_id || path.basename(name, '.json');
+    const ops = [{
+      op: 'create', kind: 'outline',
+      data: {
+        chapter_id: cid,
+        number: outline.number,
+        title: outline.title,
+        volume: outline.volume,
+        act: outline.act,
+        word_target: outline.word_target,
+        pov: outline.pov,
+        time: outline.time,
+        why: outline.why,
+        continuity: outline.continuity,
+        coverage: outline.coverage,
+        must_write: outline.must_write || ['（待补）'],
+        must_not_write: outline.must_not_write || ['（待补）'],
+        ending: outline.ending,
+      },
+    }];
+    const scenes = asArray(outline.how && outline.how.scenes);
+    scenes.forEach((scene, index) => {
+      const sid = 'SC_' + cid + '_' + (index + 1);
+      ops.push({
+        op: 'create', kind: 'scene',
+        data: {
+          outline_id: cid,
+          scene_order: index + 1,
+          goal: scene.goal,
+          obstacle: scene.obstacle,
+          turn: scene.turn,
+          outcome: scene.outcome,
+          location: scene.location,
+        },
+      });
+      ops.push({ op: 'link', edge: 'outline_scene', from: 'outline:' + cid, to: 'scene:' + sid, data: { scene_order: index + 1 } });
+    });
+    for (const character of asArray(outline.cast)) {
+      const id = idOf(typeof character === 'string' ? character : character.id);
+      if (!id) continue;
+      ops.push({ op: 'link', edge: 'outline_cast', from: 'outline:' + cid, to: 'character:' + id, data: { role: typeof character === 'object' ? character.role_in_chapter : undefined } });
+    }
+    for (const location of asArray(outline.locations)) {
+      const lid = idOf(typeof location === 'string' ? location : location && location.id);
+      if (!lid) continue;
+      ops.push({ op: 'link', edge: 'outline_location', from: 'outline:' + cid, to: 'location:' + lid, data: {} });
+    }
+    for (const fsId of asArray(outline.coverage && outline.coverage.foreshadow).map(idOf)) {
+      ops.push({ op: 'link', edge: 'outline_foreshadow', from: 'outline:' + cid, to: 'foreshadow:' + fsId, data: {} });
+    }
+    results.push(await run(sdb, 'outline', 'import outline ' + cid, ops));
+  }
+  return { outlines: results.length, results };
+}
+
+// ---------------------------------------------------------------------------
+// writing
+// ---------------------------------------------------------------------------
+
+export async function importWriting(sdb, root) {
+  const dir = stagePath(root, '50-writing');
+  const ledger = readJson(path.join(dir, 'ledger.json'), { chapters: [] });
+  const rows = asArray(ledger.chapters);
+  const chaptersDir = path.join(dir, 'chapters');
+  const fileNames = fs.existsSync(chaptersDir)
+    ? fs.readdirSync(chaptersDir).filter((name) => name.endsWith('.md')).sort()
+    : [];
+  const results = [];
+  for (const name of fileNames) {
+    const match = /第(\d+)章\.md$/.exec(name);
+    if (!match) continue;
+    const no = Number(match[1]);
+    const content = fs.readFileSync(path.join(chaptersDir, name), 'utf8');
+    const chapter = await sdb.one(
+      `SELECT chapter_id FROM chapter WHERE story = story:main AND display_no = $no LIMIT 1;`,
+      { no },
+    );
+    if (!chapter) continue;
+    const row = rows.find((r) => Number(r.ch) === no || r.chapter_id === chapter.chapter_id) || {};
+    const ops = [
+      {
+        op: 'create', kind: 'chapter_text',
+        data: {
+          chapter_id: chapter.chapter_id,
+          display_no: no,
+          content,
+          word_count: content.replace(/\s/g, '').length,
+          status: 'draft',
+        },
+      },
+      {
+        op: 'create', kind: 'handoff',
+        data: {
+          chapter_id: chapter.chapter_id,
+          end_location: (row.locations && row.locations[row.locations.length - 1]) || undefined,
+          end_time: row.time,
+          end_characters: row.cast || [],
+          open_threads: row.ending_hook ? [row.ending_hook] : [],
+          next_scene_hint: row.ending_hook,
+          continuity_notes: '',
+          status: 'draft',
+        },
+      },
+    ];
+    results.push(await run(sdb, 'writing', 'import text ' + chapter.chapter_id, ops));
+  }
+  return { chapters: results.length, results };
+}
+
+// ---------------------------------------------------------------------------
+// dispatch
+// ---------------------------------------------------------------------------
+
+const IMPORTERS = {
+  scale: importScale,
+  macro: importMacro,
+  cast: importCast,
+  rhythm: importRhythm,
+  outline: importOutlines,
+  writing: importWriting,
+};
+
+export async function importStage(sdb, stage, root, opts = {}) {
+  const importer = IMPORTERS[stage];
+  if (!importer) throw new Error('未知导入阶段：' + stage);
+  return importer(sdb, root, opts);
+}

package/plugins/fancy-story-builder/storydb/mcp.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * MCP stdio server for fancy-webnovel.
+ *
+ * Start it with:
+ *   node plugins/fancy-story-builder/storydb/mcp.js [--workspace /path/to/workspace]
+ *
+ * All tools are in `tools.js`. The server is intentionally project-agnostic:
+ * each tool accepts an optional `project` (name or UUID) and resolves the
+ * active project/cwd when omitted.
+ */
+
+import readline from 'readline';
+import { TOOLS, callTool, closeAll } from './tools.js';
+import { flattenError } from './client.js';
+
+const argv = process.argv.slice(2);
+const flag = (name) => {
+  const idx = argv.indexOf('--' + name);
+  return idx >= 0 ? argv[idx + 1] : undefined;
+};
+const workspace = flag('workspace');
+if (workspace) process.env.FANCY_HOME = workspace;
+
+const SERVER_INFO = { name: 'fancy-webnovel', version: '3.0.0' };
+const PROTOCOL_VERSION = '2024-11-05';
+
+function send(message) {
+  process.stdout.write(JSON.stringify(message) + '\n');
+}
+
+function result(id, value) {
+  send({ jsonrpc: '2.0', id, result: value });
+}
+
+function rpcError(id, code, message, data) {
+  send({ jsonrpc: '2.0', id, error: { code, message, ...(data ? { data } : {}) } });
+}
+
+function toolContent(value, isError = false) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on('line', async (line) => {
+  const text = line.trim();
+  if (!text) return;
+  let msg;
+  try { msg = JSON.parse(text); } catch { return; }
+  const { id, method, params } = msg;
+
+  try {
+    if (method === 'initialize') {
+      result(id, {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO,
+      });
+      return;
+    }
+    if (method === 'notifications/initialized') return;
+    if (method === 'ping') { result(id, {}); return; }
+    if (method === 'tools/list') {
+      result(id, { tools: TOOLS });
+      return;
+    }
+    if (method === 'tools/call') {
+      const name = params && params.name;
+      const args = params && params.arguments;
+      if (!name) {
+        result(id, toolContent({ ok: false, error: { code: 'MISSING_TOOL', message: '缺少 tool name' } }, true));
+        return;
+      }
+      const value = await callTool(name, typeof args === 'object' && args !== null ? args : {});
+      result(id, toolContent(value, value && value.ok === false));
+      return;
+    }
+    if (method === 'shutdown') {
+      await closeAll();
+      result(id, null);
+      return;
+    }
+    if (method === 'exit') {
+      await closeAll();
+      process.exit(0);
+    }
+    rpcError(id, -32601, '未知方法：' + method);
+  } catch (err) {
+    if (id !== undefined) {
+      result(id, toolContent({ ok: false, error: { code: 'MCP_TOOL_FAILED', message: flattenError(err) } }, true));
+    }
+  }
+});
+
+process.on('SIGTERM', async () => { await closeAll(); process.exit(0); });
+process.on('SIGINT', async () => { await closeAll(); process.exit(0); });