Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: drain cancelled Bible sync tests before fixture cleanup (#13408)

[._.]/ Adam Eivyb20c15598249
diff --git a/scripts/writersRoomBibleSyncCleanup.test.js b/scripts/writersRoomBibleSyncCleanup.test.js
new file mode 100644
index 0000000000..3f6bd3e72b
--- /dev/null
+++ b/scripts/writersRoomBibleSyncCleanup.test.js
@@ -0,0 +1,97 @@
+import { afterAll, expect, it as vitestIt } from 'vitest';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ownTestBodies } from '../server/lib/mockPathsDataRoot.js';
+import { createVitestTempFixture, fixtureReadyFailureSource, runFixtureToCompletion } from './lib/vitestTempRootFixture.js';
+
+const RUN_CEILING_MS = 120000;
+const owned = ownTestBodies(vitestIt);
+const it = owned.it;
+afterAll(() => owned.drain());
+
+// Pin the real peer pull's final write against sibling bail. A green Vitest file
+// can still own a cancelled async body which recreates its already-removed root.
+for (const drainBodies of [false, true]) {
+ it(`Bible sync sibling bail: ${drainBodies ? 'drains before removal' : 'detects missing drain'}`, async ({ signal }) => {
+ const host = mkdtempSync(join(tmpdir(), 'wr-bible-cancel-'));
+ let closeConfirmed = true;
+ try {
+ const fixture = join(host, 'fixture');
+ const ready = join(fixture, 'ready');
+ const events = join(fixture, 'events');
+ const fixtureRun = createVitestTempFixture(host, 'server', '');
+ const sourcePath = fileURLToPath(new URL('../server/services/writersRoom/bibleSync.test.js', import.meta.url));
+ const input = readFileSync(sourcePath, 'utf8');
+ expect(input).toContain('await owned.drain();');
+ const mock = "makePathsProxy(await original(), { dataRoot: () => root })";
+ expect(input).toContain(mock);
+ const header = "it('ships only authored sibling files, pulls missing files, and preserves full cast fields for readers', async () => {";
+ expect(input).toContain(header);
+ const source = (drainBodies ? input : input.replaceAll('await owned.drain();', '/* negative control: no body settlement */'))
+ .replace('rmSync,', 'rmSync as realRmSync,')
+ .replace('const root =', `
+ const { appendFileSync, existsSync } = await import('node:fs');
+ const record = event => appendFileSync(${JSON.stringify(events)}, event + '\\n');
+ let cancellation;
+ let pending = false;
+ let settled;
+ const bodySettled = new Promise(resolve => { settled = resolve; });
+ // Vitest runs afterAll hooks in reverse order: observe AFTER the real cleanup.
+ afterAll(async () => { await bodySettled; record('observer-complete'); });
+ function rmSync(path, options) {
+ if (path === root) record('remove-start:pending=' + pending);
+ realRmSync(path, options);
+ if (path === root) record('remove-complete:exists=' + existsSync(root));
+ }
+ const root =`)
+ .replace("vi.mock('../../lib/fileUtils.js'", "record('allocated');\nvi.mock('../../lib/fileUtils.js'")
+ .replace(mock, `(() => {
+ return original().then(actual => makePathsProxy(actual, { dataRoot: () => root, overrides: {
+ atomicWrite: async (...args) => {
+ if (!args[0].endsWith('characters.json')) return actual.atomicWrite(...args);
+ pending = true;
+ record('write-ready');
+ writeFileSync(${JSON.stringify(ready)}, 'ready');
+ await cancellation;
+ record('write-resume:exists=' + existsSync(root));
+ await actual.atomicWrite(...args);
+ pending = false;
+ record('write-complete:exists=' + existsSync(root));
+ }
+ } }));
+ })()`)
+ .replace(header, `${header.replace('async () =>', 'async ({ signal }) =>')}
+ cancellation = new Promise(resolve => signal.addEventListener('abort', () => setImmediate(resolve), { once: true }));
+ try {`)
+ .replace('expect(await diffWorkBibleManifest(manifest)).toEqual([]);', `expect(await diffWorkBibleManifest(manifest)).toEqual([]);
+ } finally { record('body-settled'); settled(); }`)
+ .replace(/(['"])(\.\.?\/[^'"]+)\1/g, (_, quote, specifier) => JSON.stringify(resolve(dirname(sourcePath), specifier)));
+ writeFileSync(join(fixture, 'lifecycle.test.js'), source + `
+ record('hooks-registered');
+ `);
+ writeFileSync(join(fixture, 'failure.test.js'), fixtureReadyFailureSource(ready));
+ fixtureRun.args[fixtureRun.args.indexOf('--maxWorkers') + 1] = '2';
+ fixtureRun.args.push('--bail=1', '--testNamePattern', 'ships only authored sibling files|controlled sibling failure');
+ closeConfirmed = false;
+ const result = await runFixtureToCompletion(fixtureRun, RUN_CEILING_MS, { signal });
+ closeConfirmed = result.closeConfirmed;
+ if (signal.aborted && closeConfirmed) return;
+ const observed = existsSync(events) ? readFileSync(events, 'utf8') : '';
+ const output = `${result.stdout}\n${result.stderr}\nlifecycle: ${observed}`;
+ expect(result.error, output).toBeUndefined();
+ expect(result.status, output).toBe(1);
+ expect(output).toContain('controlled sibling failure');
+ expect(observed, output).toBe(drainBodies
+ ? 'allocated\nhooks-registered\nwrite-ready\nwrite-resume:exists=true\nwrite-complete:exists=true\nbody-settled\nremove-start:pending=false\nremove-complete:exists=false\nobserver-complete\n'
+ : 'allocated\nhooks-registered\nwrite-ready\nremove-start:pending=true\nremove-complete:exists=false\nwrite-resume:exists=false\nwrite-complete:exists=true\nbody-settled\nobserver-complete\n');
+ if (drainBodies) expect(output).not.toMatch(/ENOTEMPTY|ENOENT|Unhandled|test temp leak:/);
+ else expect(output).toContain('test temp leak: wr-bible-sync- ×1');
+ } finally {
+ // A killed process is not proof its handles closed. Retain an unconfirmed
+ // host for the run's leak guard instead of deleting underneath its writer.
+ if (closeConfirmed) rmSync(host, { recursive: true, force: true });
+ }
+ }, RUN_CEILING_MS + 15000);
+}
diff --git a/server/services/writersRoom/bibleSync.test.js b/server/services/writersRoom/bibleSync.test.js
index 44851f2e23..839890cdea 100644
--- a/server/services/writersRoom/bibleSync.test.js
+++ b/server/services/writersRoom/bibleSync.test.js
@@ -1,10 +1,11 @@
-import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
-import { tmpdir } from 'os';
+import { describe, it as vitestIt, expect, vi, beforeEach, afterAll } from 'vitest';
+import { rmSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
import { join } from 'path';
-import { makePathsProxy, mockNoPeerSync } from '../../lib/mockPathsDataRoot.js';
+import { makePathsProxy, mockNoPeerSync, createTempDataRoot, ownTestBodies } from '../../lib/mockPathsDataRoot.js';
-const root = mkdtempSync(join(tmpdir(), 'wr-bible-sync-'));
+const owned = ownTestBodies(vitestIt);
+const it = owned.it;
+const root = createTempDataRoot('wr-bible-sync-');
vi.mock('../../lib/fileUtils.js', async (original) => makePathsProxy(await original(), { dataRoot: () => root }));
vi.mock('../instances.js', () => ({ getPeers: vi.fn(async () => [{ instanceId: 'peer-a', address: '192.0.2.10', port: 5555 }]) }));
vi.mock('../sharing/peerSync.js', () => mockNoPeerSync());
@@ -32,12 +33,18 @@ function serve(value, duringFetch) {
});
}
beforeEach(async () => {
+ await owned.drain();
rmSync(join(root, 'writers-room'), { force: true, recursive: true });
rmSync(join(root, 'conflict-journal'), { force: true, recursive: true });
vi.clearAllMocks();
await mergeWorksFromSync([{ id: WORK, title: 'Example work', drafts: [], updatedAt: '2026-01-01T00:00:00Z' }]);
});
-afterAll(() => rmSync(root, { recursive: true, force: true }));
+// Sibling bail settles Vitest's wrapper before the underlying Bible write.
+// Wait for that body or its late failure before removing its data root (#13408).
+afterAll(async () => {
+ try { await owned.drain(); }
+ finally { rmSync(root, { recursive: true, force: true }); }
+});
describe('bible asset delivery', () => {
it('ships only authored sibling files, pulls missing files, and preserves full cast fields for readers', async () => {