@sanqianx/project-knowledge 5.0.23 → 5.0.25

package/_site/_test/parallel-memory-sync-test.js

@@ -0,0 +1,238 @@
+'use strict';
+// _site/_test/parallel-memory-sync-test.js
+//
+// MEM-006 同步失败（sync pending）.
+//
+// Real isolated product instance, real browser, real HTTP and real disk.
+//
+// The write really fails: the brain's shared memory file path is occupied by
+// a directory, so the engine's own materialize() cannot write the confirmed
+// memory file. Nothing is faked here — the engine records the real write
+// error, the shell renders the real pending state and the real injection gate
+// refuses to hand the unsynced memory to a task.
+//
+// MEM-006 expected:
+//   * sync pending真实显示。   -> the engine really answers syncStatus
+//                                 'pending' with the write error, the real UI
+//                                 shows 写入待恢复 / 待同步 and the real toast
+//                                 warns that the unsynced memory is not
+//                                 injected;
+//   * 未同步内容不注入。        -> the engine injects nothing for the unsynced
+//                                 memory, and it does inject it again once
+//                                 the file can really be written.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { startHarness, makeRepo } = require('./helpers/parallel-memory-shell');
+
+const EVIDENCE = process.env.PK_TEST_EVIDENCE_DIR ? path.resolve(process.env.PK_TEST_EVIDENCE_DIR) : null;
+const MEMORY_TEXT = '同步失败回归：对外错误信息使用中文表述。';
+
+async function openMemoryView(harness) {
+  await harness.nativeClick('nav [data-view="memory"]');
+  await harness.waitFor(
+    () => harness.run("document.getElementById('view-memory').classList.contains('active')"),
+    'the memory view is open',
+    10000,
+  );
+}
+
+async function main() {
+  const harness = await startHarness({ tag: 'memsync', evidenceDir: EVIDENCE || undefined });
+  const evidence = [];
+  try {
+    const repo = makeRepo(harness.fixture, 'memsync-repo', { 'README.md': '# 同步甲\n' });
+    const { projectId } = await harness.importProject(repo, '同步甲');
+    await harness.requestRegistryRefresh();
+    await harness.waitFor(
+      () => harness.run("document.getElementById('homeContent').textContent.includes('同步甲')"),
+      'the imported project is listed',
+      20000,
+    );
+
+    await openMemoryView(harness);
+    await harness.waitFor(
+      () => harness.run("!document.getElementById('addMemory').disabled"),
+      'the engine is reachable and the add button is live',
+      20000,
+    );
+
+    // Break the real write path: the confirmed memory file path becomes a
+    // directory, so the engine cannot write the memory file.
+    const brainScope = harness.brainScopePath();
+    const memoryFile = path.join(brainScope, 'memories', 'confirmed.md');
+    fs.rmSync(memoryFile, { recursive: true, force: true });
+    fs.mkdirSync(memoryFile, { recursive: true });
+    assert.ok(fs.lstatSync(memoryFile).isDirectory(), 'the confirmed memory file path really is occupied by a directory');
+
+    // Add the memory through the real UI as a global memory.
+    await harness.nativeClick('#addMemory');
+    await harness.waitFor(
+      () => harness.run("document.getElementById('memoryDialog').open === true"),
+      'the add dialog is open',
+      10000,
+    );
+    await harness.typeText(MEMORY_TEXT);
+    await harness.selectOption('#memoryScope', 'global');
+    const postsBefore = harness.network.find(entry => entry.method === 'POST' && entry.url.includes('/api/engine/memories')).length;
+    // Passive DOM observation installed BEFORE the real click. The product's
+    // confirm handler closes the dialog BEFORE its post-save refreshSnapshot()
+    // and shows the toast only after that refresh resolves (ui/product.js:
+    // 'close(); await refreshSnapshot(); toast(...)'), so a one-shot read
+    // gated on 'dialog closed' can land inside the refresh gap and see an
+    // empty toast (CI 40080404131, line 98: empty text). The observer records
+    // every REAL toast mutation the REAL click produces — text, visibility
+    // and time — nothing is fabricated or forced.
+    await harness.run(`(() => {
+      const el = document.getElementById('toast');
+      window.__pkToastLog = [{ text: el.textContent, hidden: el.hidden, at: Date.now() }];
+      new MutationObserver(() => {
+        window.__pkToastLog.push({ text: el.textContent, hidden: el.hidden, at: Date.now() });
+      }).observe(el, { childList: true, characterData: true, subtree: true, attributes: true, attributeFilter: ['hidden'] });
+      return true;
+    })()`);
+    await harness.nativeClick('#confirmMemory');
+    await harness.waitFor(
+      () => harness.run("document.getElementById('memoryDialog').open === false"),
+      'the dialog closes after the save',
+      15000,
+    );
+
+    const post = harness.network.find(entry => entry.method === 'POST' && entry.url.includes('/api/engine/memories'))[postsBefore];
+    assert.ok(post, 'the shell really posted the memory');
+    assert.equal(post.status, 200, `the real POST answers 200: ${JSON.stringify(post.body)}`);
+    const postBody = await harness.network.body(post);
+    const created = postBody.memory;
+    assert.equal(created.status, 'confirmed', 'the memory itself is confirmed');
+    assert.equal(created.syncStatus, 'pending', `the engine really answers syncStatus pending: ${JSON.stringify(created)}`);
+    assert.ok(created.syncError, `the engine reports the real write error: ${JSON.stringify(created.syncError)}`);
+
+    // The real UI shows the pending state. The wait is on the OBSERVED toast
+    // record (installed before the click), so the assertion holds no matter
+    // when the shell's post-save refreshSnapshot() finishes — the observed
+    // toast is the real one the real click produced. The toast's text also
+    // persists after its 4s auto-hide (product toast() flips only `hidden`),
+    // so a late match is still the real text; requiring hidden === false in
+    // the same record proves it was actually VISIBLE when shown.
+    const debugUiFailure = async stage => {
+      try {
+        const dump = await harness.run(`(() => ({
+          toasts: window.__pkToastLog || null,
+          feedback: document.getElementById('memoryFeedback').textContent,
+          feedbackHidden: document.getElementById('memoryFeedback').hidden,
+          dialogOpen: document.getElementById('memoryDialog').open,
+          activeView: (document.querySelector('.view.active') || {}).id || null,
+        }))()`);
+        console.error(`MEM-006 UI failure at ${stage}: ${JSON.stringify(dump)}`);
+        if (harness.evidence) await harness.browser.screenshot(path.join(harness.evidence, `mem006-failure-${stage}.png`));
+      } catch {}
+    };
+    let toastRecord;
+    try {
+      toastRecord = await harness.waitFor(
+        () => harness.run(`(window.__pkToastLog || []).find(t => !t.hidden && t.text.includes('记忆文件待恢复')) || null`),
+        'the toast warns about the pending file',
+        10000,
+      );
+    } catch (error) { await debugUiFailure('toast-pending'); throw error; }
+    assert.equal(toastRecord.hidden, false, `the pending toast was really visible when shown: ${JSON.stringify(toastRecord)}`);
+    const toast = toastRecord.text;
+    assert.match(String(toast), /记忆文件待恢复/, `the toast warns about the pending file: ${toast}`);
+    assert.match(String(toast), /未同步内容不会注入任务。/, 'the toast warns that the unsynced memory is not injected');
+
+    let card;
+    try {
+      card = await harness.run(`(() => {
+        const el = document.querySelector('[data-memory-card=${JSON.stringify(created.id)}]');
+        return el ? el.textContent : null;
+      })()`);
+    } catch (error) { await debugUiFailure('card-read'); throw error; }
+    if (!card) await debugUiFailure('card-listed');
+    assert.ok(card, 'the confirmed memory is really listed');
+    assert.match(card, /写入待恢复/, `the card shows the pending write: ${card}`);
+    assert.match(card, /待同步/, 'the card shows the pending sync state');
+    if (harness.evidence) await harness.browser.screenshot(path.join(harness.evidence, 'mem006-sync-pending.png'));
+
+    // 未同步内容不注入: the real injection gate refuses the unsynced memory.
+    const injected = await harness.injectedMemories(projectId);
+    assert.ok(
+      !injected.some(entry => entry.memoryId === created.id),
+      `the unsynced memory is never injected: ${JSON.stringify(injected)}`,
+    );
+
+    const pendingRecord = (await harness.productMemories()).find(memory => memory.id === created.id);
+    assert.equal(pendingRecord.syncStatus, 'pending', 'the stored memory still carries the pending sync state');
+
+    evidence.push({
+      case: 'MEM-006',
+      request: { method: post.method, url: post.url.replace(harness.base, ''), status: post.status, response: postBody },
+      memory: { id: created.id, status: created.status, syncStatus: created.syncStatus, syncError: created.syncError, scopeType: created.scopeType, scopeId: created.scopeId },
+      ui: { toast, toastObserved: { visibleWhenShown: toastRecord.hidden === false, at: toastRecord.at }, card },
+      injectedWhilePending: injected.map(entry => entry.memoryId),
+      blockedPath: memoryFile,
+    });
+
+    // ---------------------------------------------------------------- recovery
+    // The write really works again: the directory is removed and the engine's
+    // own recovery writes the file. The memory becomes injectable again.
+    fs.rmSync(memoryFile, { recursive: true, force: true });
+    await harness.waitFor(
+      async () => {
+        const memories = await harness.productMemories();
+        const memory = memories.find(entry => entry.id === created.id);
+        return memory && memory.syncStatus === 'ready' ? memory : null;
+      },
+      'the engine recovers the pending write',
+      30000,
+    );
+    assert.ok(fs.existsSync(memoryFile), 'the confirmed memory file is really written again');
+    const fileText = fs.readFileSync(memoryFile, 'utf8');
+    assert.ok(fileText.includes(created.id), 'the recovered file holds the memory');
+    assert.ok(fileText.includes(MEMORY_TEXT), 'the recovered file holds the text');
+
+    const afterRecovery = await harness.injectedMemories(projectId);
+    assert.ok(
+      afterRecovery.some(entry => entry.memoryId === created.id),
+      `the recovered memory is injected again: ${JSON.stringify(afterRecovery)}`,
+    );
+
+    await harness.reload();
+    await openMemoryView(harness);
+    await harness.nativeClick('[data-memory-tab="confirmed"]');
+    await harness.waitFor(
+      () => harness.run(`document.getElementById('memoryContent').textContent.includes(${JSON.stringify(MEMORY_TEXT)})`),
+      'the recovered memory is listed again',
+      15000,
+    );
+    const recoveredCard = await harness.run(`(() => {
+      const el = document.querySelector('[data-memory-card=${JSON.stringify(created.id)}]');
+      return el ? el.textContent : null;
+    })()`);
+    assert.ok(recoveredCard, 'the recovered memory has a card');
+    assert.ok(!recoveredCard.includes('写入待恢复'), `the card no longer shows the pending write: ${recoveredCard}`);
+    assert.match(recoveredCard, /已确认/, 'the card shows the confirmed state again');
+    if (harness.evidence) await harness.browser.screenshot(path.join(harness.evidence, 'mem006-recovered.png'));
+
+    evidence.push({
+      case: 'MEM-006-recovery',
+      memoryFile,
+      injectedAfterRecovery: afterRecovery.map(entry => entry.memoryId),
+      ui: { card: recoveredCard },
+    });
+
+    assert.equal(harness.browser.exceptions.length, 0, `no uncaught product JavaScript exceptions: ${JSON.stringify(harness.browser.exceptions)}`);
+
+    if (harness.evidence) {
+      fs.mkdirSync(harness.evidence, { recursive: true });
+      fs.writeFileSync(path.join(harness.evidence, 'mem006-sync.json'), `${JSON.stringify(evidence, null, 2)}\n`, 'utf8');
+    }
+
+    console.log('parallel-memory-sync-test PASS (MEM-006 the real write failure shows sync pending, the unsynced memory is not injected, and the recovered memory is injected again)');
+  } finally {
+    await harness.cleanup();
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });

package/_site/_test/parallel-memory-view-r8-reload-gate-test.js

@@ -0,0 +1,123 @@
+'use strict';
+// _site/_test/parallel-memory-view-r8-reload-gate-test.js
+//
+// P-CI-MEMORY-VIEW-R8 focused case: the reload→navigate contract that CI
+// 40062048045 broke in parallel-memory-source-test ("Timed out waiting for
+// the memory view is open", test line 136).
+//
+// Root cause class (see the R8 probe evidence under
+// qa-autopilot/artifacts/parallel-20261023/ci-memory-view-r8/): the shell's
+// reload() used to gate ONLY on `document.readyState === 'complete'`, which
+// proves neither WHICH document answered (Page.reload is acknowledged before
+// the navigation commits; Runtime.evaluate can answer from the outgoing
+// context on a congested renderer) nor that the product's interactive boot
+// finished. A native nav click dispatched right after such a gate can land
+// in the load/swap settle window and be dropped — reproduced 2/2 against the
+// real page with a forced 600ms commit delay; the memory view then never
+// activates (the exact CI never-true predicate).
+//
+// The fixed gate returns only when the answering document is provably FRESH
+// (a marker set on the outgoing document is gone) AND the product's own boot
+// evidence is present (.view.active — ui/product.js attaches its click
+// delegation before the boot setView that marks the initial view active).
+//
+// This case proves that contract on the real page, offline from MEM-008:
+//   1. reload() returns on the fresh, booted document (identity marker);
+//   2. the golden path the CI failure broke — nativeClick nav memory right
+//      after reload() — activates the memory view, and home navigation
+//      still works;
+//   3. back-to-back reloads keep the contract (the marker technique marks
+//      each outgoing document, so consecutive reloads cannot pass on a
+//      stale context);
+//   4. the failure-diagnostics surface exists (navigationState).
+//
+// Real isolated product instance, real browser, real CDP input; the harness
+// owns vector+bridge before the engine constructor and no live
+// 5757/5790/8787/8790 endpoint is touched (parallel-memory-shell.js).
+
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { startHarness } = require('./helpers/parallel-memory-shell');
+
+const EVIDENCE = process.env.PK_TEST_EVIDENCE_DIR ? path.resolve(process.env.PK_TEST_EVIDENCE_DIR) : null;
+
+async function main() {
+  const harness = await startHarness({ tag: 'memviewr8', evidenceDir: EVIDENCE || undefined });
+  const proof = { startedAt: new Date().toISOString() };
+  try {
+    await harness.waitFor(
+      () => harness.run("document.readyState === 'complete' && document.querySelector('.view.active') !== null"),
+      'the initial page is booted',
+      20000,
+    );
+
+    // ---- 1. reload() returns on the FRESH, booted document ----------------
+    await harness.run('window.__pkR8Mark = "outgoing", true');
+    await harness.reload();
+    const fresh = await harness.run(`(() => ({
+      mark: typeof window.__pkR8Mark,
+      activeView: (document.querySelector('.view.active') || {}).id || null,
+      readyState: document.readyState,
+    }))()`);
+    assert.equal(fresh.mark, 'undefined', 'reload() must return on the fresh document, never on the outgoing one (the marker exists only in the outgoing context)');
+    assert.ok(fresh.activeView, 'the product boot finished before reload() returned (an initial view is active — the delegation-attached proof)');
+    assert.equal(fresh.readyState, 'complete');
+    assert.ok(harness.reloadLog.length >= 1, 'the reload gate records its small metadata');
+    proof.freshDocumentGate = fresh;
+
+    // ---- 2. the golden path the CI failure broke ---------------------------
+    await harness.nativeClick('nav [data-view="memory"]');
+    await harness.waitFor(
+      () => harness.run("document.getElementById('view-memory').classList.contains('active')"),
+      'the memory view is open',
+      10000,
+    );
+    await harness.nativeClick('nav [data-view="home"]');
+    await harness.waitFor(
+      () => harness.run("document.getElementById('view-home').classList.contains('active')"),
+      'the home view is open',
+      10000,
+    );
+    proof.goldenPath = { memoryViewOpened: true, homeViewReopened: true };
+
+    // ---- 3. back-to-back reloads keep the contract -------------------------
+    await harness.run('window.__pkR8Mark = "outgoing-again", true');
+    await harness.reload();
+    await harness.reload();
+    const twice = await harness.run(`(() => ({
+      mark: typeof window.__pkR8Mark,
+      activeView: (document.querySelector('.view.active') || {}).id || null,
+    }))()`);
+    assert.equal(twice.mark, 'undefined', 'after two consecutive reloads the gate still returned on the fresh document');
+    assert.ok(twice.activeView, 'the boot evidence held through the second reload');
+    await harness.nativeClick('nav [data-view="memory"]');
+    await harness.waitFor(
+      () => harness.run("document.getElementById('view-memory').classList.contains('active')"),
+      'the memory view opens after back-to-back reloads',
+      10000,
+    );
+    proof.backToBackReloads = { ...twice, memoryViewOpened: true };
+
+    // ---- 4. the failure-diagnostics surface exists -------------------------
+    const state = await harness.navigationState();
+    assert.ok(state && typeof state === 'object' && !state.unreachable, `navigationState() must be reachable: ${JSON.stringify(state)}`);
+    assert.equal(typeof state.readyState, 'string');
+    assert.ok('activeView' in state && 'openDialogs' in state);
+    proof.navigationStateShape = state;
+
+    assert.equal(harness.browser.exceptions.length, 0, `no uncaught product JavaScript exceptions: ${JSON.stringify(harness.browser.exceptions)}`);
+    proof.finishedAt = new Date().toISOString();
+    proof.verdict = 'PASS';
+    if (harness.evidence) {
+      fs.mkdirSync(harness.evidence, { recursive: true });
+      fs.writeFileSync(path.join(harness.evidence, 'memviewr8-reload-gate.json'), `${JSON.stringify(proof, null, 2)}\n`, 'utf8');
+    }
+    console.log('parallel-memory-view-r8-reload-gate-test PASS');
+  } finally {
+    await harness.cleanup();
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });

package/_site/_test/parallel-nav-failure-test.js

@@ -0,0 +1,119 @@
+'use strict';
+// NAV-004 — 失败保留旧数据。
+//
+// When the registry read fails the shell must show the failure, must keep the
+// project list it already has, and must pick up the new snapshot once the
+// registry answers again.
+//
+// The failure is a real HTTP 503 injected by a proxy in front of the product:
+// the browser really receives a failed answer, and the shell really reads a
+// broken registry. The regression drives the real product UI in a real
+// browser against an isolated instance (own port, own data dir, own knowledge
+// dir, own Bridge journal, own browser profile, own vendored knowledge
+// engine). Screenshots are written to PK_TEST_EVIDENCE_DIR when the batch
+// sets it, so this tracked file stays free of machine-specific paths.
+
+const path = require('node:path');
+const assert = require('node:assert/strict');
+
+const { startHarness, makeRepo } = require('./helpers/parallel-nav-shell');
+
+const EVIDENCE = process.env.PK_TEST_EVIDENCE_DIR ? path.resolve(process.env.PK_TEST_EVIDENCE_DIR) : null;
+
+const PROJECTION = '/api/projects/projection';
+
+async function main() {
+  const harness = await startHarness({ tag: 'nav004', evidenceDir: EVIDENCE || undefined });
+  try {
+    const repoA = makeRepo(harness.fixture, 'nav004-a');
+    const repoB = makeRepo(harness.fixture, 'nav004-b');
+    const repoC = makeRepo(harness.fixture, 'nav004-c');
+    await harness.importProject(repoA, 'NAV004 甲');
+    await harness.importProject(repoB, 'NAV004 乙');
+    await harness.requestRegistryRefresh();
+    await harness.waitFor(
+      async () => {
+        const text = await harness.run("document.getElementById('homeContent').textContent");
+        return text.includes('NAV004 甲') && text.includes('NAV004 乙');
+      },
+      'both imported projects are listed',
+      20000,
+    );
+
+    const listedProjects = () => harness.run(`(() => {
+      const rows = [...document.querySelectorAll('#homeContent [data-select-project]')];
+      return rows.map(button => {
+        const name = button.parentElement.querySelector('b');
+        return name ? name.textContent.trim() : '';
+      });
+    })()`);
+    const failedReads = () => harness.productProxy.requests.filter(entry => entry.path.startsWith(PROJECTION) && entry.status === 503).length;
+
+    // The registry read now fails at the HTTP level.
+    harness.productProxy.fail(entry => entry.method === 'GET' && entry.path.startsWith(PROJECTION), 503, '注入的登记读取故障');
+    const failuresBefore = failedReads();
+    await harness.refreshRegistryAndWait();
+    await harness.waitFor(async () => failedReads() > failuresBefore, 'the registry read really failed with an HTTP 503', 20000);
+
+    // NAV-004 expected 1: the failure is visible.
+    await harness.waitFor(
+      () => harness.run("document.getElementById('toast').hidden === false && document.getElementById('toast').textContent.includes('暂未刷新')"),
+      'the failed refresh is reported to the user',
+      10000,
+    );
+    const toast = await harness.run("document.getElementById('toast').textContent");
+    assert.ok(toast.includes('已有内容已保留'), `the failure message says the content was kept: ${toast}`);
+    await harness.browser.screenshot(path.join(harness.evidence, 'nav004-read-failure.png'));
+
+    // NAV-004 expected 2: the list that was already there is not cleared.
+    const listed = (await listedProjects()).sort();
+    assert.deepEqual(listed, ['NAV004 乙', 'NAV004 甲'], 'the project list still holds the projects it had before the failure');
+    const homeText = await harness.run("document.getElementById('homeContent').textContent");
+    assert.ok(homeText.includes('NAV004 甲'), 'the failed read keeps the first project');
+    assert.ok(homeText.includes('NAV004 乙'), 'the failed read keeps the second project');
+    const selectorText = await harness.run("document.getElementById('projectSelect').textContent");
+    assert.ok(selectorText.includes('NAV004 甲') && selectorText.includes('NAV004 乙'), 'the failed read keeps the project selector entries');
+
+    // A project that appears while the registry is broken must not slip into
+    // the list as if it had been read.
+    await harness.importProject(repoC, 'NAV004 丙');
+    const failuresBeforeSecond = failedReads();
+    await harness.refreshRegistryAndWait();
+    await harness.waitFor(async () => failedReads() > failuresBeforeSecond, 'the second registry read really failed too', 20000);
+    const duringFailure = await harness.run("document.getElementById('homeContent').textContent");
+    assert.ok(duringFailure.includes('NAV004 甲') && duringFailure.includes('NAV004 乙'), 'the old projects survive the repeated failure');
+    assert.equal(duringFailure.includes('NAV004 丙'), false, 'a project that was never read is not shown while the registry is broken');
+    assert.deepEqual((await listedProjects()).sort(), ['NAV004 乙', 'NAV004 甲'], 'the project rows are exactly the projects read before the failure');
+    await harness.browser.screenshot(path.join(harness.evidence, 'nav004-old-data-kept.png'));
+
+    // NAV-004 expected 3: after the registry answers again, the list is
+    // updated from the new snapshot.
+    harness.productProxy.clearFaults();
+    await harness.refreshRegistryAndWait();
+    await harness.waitFor(
+      () => harness.run("document.getElementById('homeContent').textContent.includes('NAV004 丙')"),
+      'the recovered read shows the new project',
+      20000,
+    );
+    const recovered = await harness.run("document.getElementById('homeContent').textContent");
+    assert.ok(recovered.includes('NAV004 甲') && recovered.includes('NAV004 乙'), 'the recovered read keeps the earlier projects');
+    assert.deepEqual((await listedProjects()).sort(), ['NAV004 丙', 'NAV004 乙', 'NAV004 甲'], 'the recovered list is the new snapshot');
+    await harness.browser.screenshot(path.join(harness.evidence, 'nav004-recovered.png'));
+
+    // The failure was an HTTP failure of a real read, not a shell-side guess.
+    const failed = harness.productProxy.requests.filter(entry => entry.path.startsWith(PROJECTION) && entry.status === 503);
+    assert.ok(failed.length >= 2, `the registry read failed at the HTTP level ${failed.length} times`);
+    // The failure notice is transient: the recovery does not leave a permanent
+    // error behind in the shell.
+    await harness.wait(4500);
+    assert.equal(await harness.run("document.getElementById('toast').hidden"), true, 'the failure message is not left behind after the recovery');
+
+    assert.equal(harness.browser.exceptions.length, 0, `no uncaught product JavaScript exceptions: ${JSON.stringify(harness.browser.exceptions)}`);
+
+    console.log('parallel-nav-failure-test PASS (the failure is visible, the old list survives, the recovery updates from the new snapshot)');
+  } finally {
+    await harness.cleanup();
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });