@remnic/core 9.10.0 → 9.11.0

package/src/extraction-redaction-rules.test.ts

@@ -7,10 +7,11 @@
  * correction actually blocks future extraction of matching content.
  */
 import { strict as assert } from "node:assert";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { tmpdir } from "node:os";
 import { test } from "node:test";
+
+import { withTempDir as managedWithTempDir } from "./testing/tmp-dir.js";
 import {
   REDACTION_RULES_SUBDIR,
   compileRedactionPattern,
@@ -20,14 +21,8 @@ import {
 } from "./extraction-redaction-rules.js";
 import { validateRedactionPattern } from "./correction/correction-contract.js";
 
-async function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
-  const dir = await mkdtemp(path.join(tmpdir(), "remnic-redact-"));
-  try {
-    return await fn(dir);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
+const withTempDir = <T>(fn: (dir: string) => Promise<T>): Promise<T> =>
+  managedWithTempDir(fn, "remnic-redact-");
 
 async function writeRule(stateDir: string, pattern: string): Promise<void> {
   const dir = path.join(stateDir, REDACTION_RULES_SUBDIR);

package/src/maintenance/graph-edge-decay.test.ts

@@ -3,10 +3,11 @@
  */
 
 import assert from "node:assert/strict";
-import os from "node:os";
 import path from "node:path";
 import test from "node:test";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+
+import { withTempDir as managedWithTempDir } from "../testing/tmp-dir.js";
 
 import { appendEdge, graphFilePath, graphsDir, type GraphEdge } from "../graph.js";
 import {
@@ -85,14 +86,8 @@ async function readEdgesFile(memoryDir: string): Promise<GraphEdge[]> {
     .map((l) => JSON.parse(l) as GraphEdge);
 }
 
-async function withTempDir(fn: (dir: string) => Promise<void>): Promise<void> {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-graph-decay-test-"));
-  try {
-    await fn(dir);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
+const withTempDir = (fn: (dir: string) => Promise<void>): Promise<void> =>
+  managedWithTempDir(fn, "remnic-graph-decay-test-");
 
 test("runs end-to-end on a fixture graph with fresh, mid-decay, stale edges", async () => {
   await withTempDir(async (memoryDir) => {

package/src/peers/migrate-from-identity-anchor.test.ts

@@ -6,10 +6,11 @@
 
 import assert from "node:assert/strict";
 import { promises as fs } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
+import { makeTempDir as managedMakeTempDir } from "../testing/tmp-dir.js";
+
 import { readPeer } from "./storage.js";
 import { migrateFromIdentityAnchor } from "./migrate-from-identity-anchor.js";
 
@@ -17,9 +18,7 @@ import { migrateFromIdentityAnchor } from "./migrate-from-identity-anchor.js";
 // Helpers
 // ──────────────────────────────────────────────────────────────────────────────
 
-async function makeTempDir(): Promise<string> {
-  return fs.mkdtemp(path.join(os.tmpdir(), "peer-migrate-test-"));
-}
+const makeTempDir = (): Promise<string> => managedMakeTempDir("peer-migrate-test-");
 
 /** Write a file, creating intermediate directories as needed. */
 async function writeFixture(filePath: string, content: string): Promise<void> {

package/src/peers/peers.test.ts

@@ -7,10 +7,11 @@
 
 import assert from "node:assert/strict";
 import { promises as fs } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
+import { makeTempDir as managedMakeTempDir } from "../testing/tmp-dir.js";
+
 import {
   appendInteractionLog,
   assertValidPeerId,
@@ -33,9 +34,7 @@ import {
 // Fixtures
 // ──────────────────────────────────────────────────────────────────────
 
-async function makeTempDir(): Promise<string> {
-  return await fs.mkdtemp(path.join(os.tmpdir(), "peers-test-"));
-}
+const makeTempDir = (): Promise<string> => managedMakeTempDir("peers-test-");
 
 function samplePeer(overrides: Partial<Peer> = {}): Peer {
   return {

package/src/session-summaries/session-summaries.test.ts

@@ -4,16 +4,12 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
+import { withTempDir as managedWithTempDir } from "../testing/tmp-dir.js";
+
 import { collectLocalSessionSummaries, compileRedactionRules, runLocalSessionSummaryCliCommand } from "./index.js";
 
-async function withTempDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-session-summary-"));
-  try {
-    return await fn(dir);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
+const withTempDir = <T>(fn: (dir: string) => Promise<T>): Promise<T> =>
+  managedWithTempDir(fn, "remnic-session-summary-");
 
 test("collectLocalSessionSummaries produces metadata-only drafts without local paths or raw session keys", async () => {
   await withTempDir(async (dir) => {

package/src/testing/tmp-dir.ts

@@ -0,0 +1,68 @@
+import { after } from "node:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Shared temp-dir lifecycle for `@remnic/core` tests (#2083). The single source
+ * of truth within this package, so its tests are self-cleaning rather than
+ * relying solely on the run-level TMPDIR sandbox (Tier 1).
+ *
+ * `makeTempDir` / `makeTempDirSync` register the created directory for cleanup
+ * via a single file-scoped `after()` hook (registered at import time, before
+ * any test runs), so a bare `const dir = await makeTempDir()` call site needs
+ * no per-test teardown wiring. `withTempDir` scopes the directory to a callback
+ * and removes it in `finally`.
+ */
+const pendingCleanup = new Set<string>();
+
+// Registered at module load — importing this module from a test file installs
+// one file-scoped after-all hook that removes every managed temp dir. Doing it
+// here (not lazily inside a test) guarantees the hook binds to the file root
+// rather than whichever test happened to allocate the first dir.
+after(async () => {
+  const dirs = [...pendingCleanup];
+  pendingCleanup.clear();
+  // Surface cleanup failures (do not swallow): a dir that cannot be removed is
+  // a real signal. `force: true` already ignores a missing dir, so a rejection
+  // here means an actual teardown problem and should fail the file loudly.
+  await Promise.all(dirs.map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+/** Create a temp dir that is removed automatically after the file's tests. */
+export async function makeTempDir(prefix = "remnic-test-"): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), prefix));
+  pendingCleanup.add(dir);
+  return dir;
+}
+
+/** Synchronous {@link makeTempDir}. */
+export function makeTempDirSync(prefix = "remnic-test-"): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  pendingCleanup.add(dir);
+  return dir;
+}
+
+/** Run `fn` with a fresh temp dir, removing it in `finally`. */
+export async function withTempDir<T>(
+  fn: (dir: string) => T | Promise<T>,
+  prefix = "remnic-test-",
+): Promise<T> {
+  const dir = await mkdtemp(join(tmpdir(), prefix));
+  try {
+    return await fn(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+/** Synchronous {@link withTempDir}. */
+export function withTempDirSync<T>(fn: (dir: string) => T, prefix = "remnic-test-"): T {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  try {
+    return fn(dir);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}

package/src/transfer/capsule-encrypt.test.ts

@@ -22,11 +22,12 @@
 
 import assert from "node:assert/strict";
 import test from "node:test";
-import { mkdtemp, rm, writeFile, readFile, mkdir, stat, readdir } from "node:fs/promises";
+import { rm, writeFile, readFile, mkdir, stat, readdir } from "node:fs/promises";
 import path from "node:path";
-import { tmpdir } from "node:os";
 import { gzipSync, gunzipSync } from "node:zlib";
 
+import { makeTempDir as managedMakeTempDir } from "../testing/tmp-dir.js";
+
 import { exportCapsule } from "./capsule-export.js";
 import { importCapsule } from "./capsule-import.js";
 import { backupMemoryDir } from "./backup.js";
@@ -53,9 +54,7 @@ const FAST_SCRYPT: ScryptParams = {
 
 const TEST_PASSPHRASE = "hunter2-test-passphrase";
 
-async function makeTempDir(): Promise<string> {
-  return mkdtemp(path.join(tmpdir(), "capsule-enc-test-"));
-}
+const makeTempDir = (): Promise<string> => managedMakeTempDir("capsule-enc-test-");
 
 /**
  * Initialize a secure-store header in `memoryDir` and unlock the keyring.

package/src/write-quarantine.test.ts

@@ -4,16 +4,12 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import test from "node:test";
 
+import { withTempDir as managedWithTempDir } from "./testing/tmp-dir.js";
+
 import { WriteQuarantineStore } from "./write-quarantine.js";
 
-async function withTempDir(fn: (dir: string) => Promise<void>): Promise<void> {
-  const dir = await mkdtemp(path.join(tmpdir(), "remnic-quarantine-"));
-  try {
-    await fn(dir);
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
+const withTempDir = (fn: (dir: string) => Promise<void>): Promise<void> =>
+  managedWithTempDir(fn, "remnic-quarantine-");
 
 function isInside(root: string, child: string): boolean {
   const rel = path.relative(path.resolve(root), path.resolve(child));