agentic-workflow-manager 9.8.0 → 9.10.0

package/dist/tests/structural/directory-fsync-is-single-source.test.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Structural guard, same family as symlink-type-is-explicit.test.ts.
+//
+// fsync-ing a DIRECTORY file descriptor is a POSIX-only capability. On Windows
+// `fs.openSync(dir, 'r')` succeeds and the following `fs.fsyncSync(fd)` always
+// fails with EPERM — libuv's mapping of `FlushFileBuffers` on a directory
+// handle, which Win32 rejects categorically. That is not a durability failure
+// (NTFS journals the rename itself); the mechanism simply does not exist there.
+//
+// `atomic-file.fsyncDirSync` is where that decision lives, and it is deliberately
+// narrow: degrade ONLY on win32 + EPERM at the fsync, keep throwing everywhere
+// else. Re-implementing the open/fsync/close sequence inline re-creates the gap
+// without the exception, and it fails on Windows and nowhere else — invisible to
+// every local run, and behind CI's `--bail` it costs one full matrix round to
+// surface. That is exactly how `tests/core/model-policy/store.test.ts` broke the
+// Windows legs of the matrix while all four POSIX legs stayed green.
+//
+// So the rule is about the CALL, not about any one call site: a directory fd may
+// be flushed only through `fsyncDirSync`. This scans `tests` as well as `src` —
+// the regression that motivated it lived in a test double, and a guard that only
+// watched `src` would have reported a clean bill of health.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const CLI = path_1.default.join(__dirname, '..', '..');
+const ROOTS = ['src', 'tests'];
+/** The single source of the policy: the one file allowed to flush a directory fd. */
+const SINGLE_SOURCE = path_1.default.join('src', 'core', 'atomic-file.ts');
+/** This guard itself, which must quote the forbidden shape to describe and test it. */
+const THIS_GUARD = path_1.default.join('tests', 'structural', 'directory-fsync-is-single-source.test.ts');
+function sourceFiles(dir) {
+    const out = [];
+    for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...sourceFiles(full));
+        else if (entry.name.endsWith('.ts'))
+            out.push(full);
+    }
+    return out;
+}
+/** True when `lines[i]` opens something that reads as a directory. Deliberately
+ *  shallow — it recognises the shapes this codebase actually writes. Something
+ *  cleverer that defeats it should be calling `fsyncDirSync` instead. */
+function opensADirectory(line) {
+    const open = /\bfs\.openSync\s*\(\s*([^,]+),/.exec(line);
+    if (!open)
+        return false;
+    const target = open[1];
+    return /\bpath\.dirname\s*\(|\bdirname\s*\(/.test(target) || /\b(dir|Dir|root|Root)\b|Dir\b/.test(target);
+}
+/** True when the fd opened at `lines[i]` is flushed within the next few lines. */
+function flushedNearby(lines, i) {
+    return /\bfsyncSync\s*\(/.test(lines.slice(i, i + 4).join('\n'));
+}
+describe('directory fsync has exactly one implementation', () => {
+    it('no file outside atomic-file.ts opens a directory and flushes it inline', () => {
+        const offenders = [];
+        for (const root of ROOTS) {
+            for (const file of sourceFiles(path_1.default.join(CLI, root))) {
+                const relative = path_1.default.relative(CLI, file);
+                if (relative === SINGLE_SOURCE || relative === THIS_GUARD)
+                    continue;
+                const lines = fs_1.default.readFileSync(file, 'utf-8').split('\n');
+                lines.forEach((line, i) => {
+                    if (!opensADirectory(line) || !flushedNearby(lines, i))
+                        return;
+                    offenders.push(`${relative}:${i + 1}: ${line.trim()}`);
+                });
+            }
+        }
+        expect(offenders).toEqual([]);
+    });
+    it('the guard actually rejects the shape that broke the Windows matrix', () => {
+        // Without this, a guard whose regex silently stopped matching would read as
+        // a clean bill of health forever — the failure mode of every structural test.
+        const rejects = (lines, i) => opensADirectory(lines[i]) && flushedNearby(lines, i);
+        // Verbatim shape of the store.test.ts regression this guard exists to stop.
+        const regression = [
+            'fs.renameSync(temporary, file);',
+            "const parent = fs.openSync(path.dirname(file), 'r');",
+            'try { fs.fsyncSync(parent); } finally { fs.closeSync(parent); }',
+        ];
+        expect(rejects(regression, 1)).toBe(true);
+        // The sanctioned replacement carries no directory open at all.
+        expect(regression.map((_, i) => i).some(i => rejects(['fsyncDirSync(path.dirname(file));'], 0))).toBe(false);
+        // Flushing a FILE descriptor stays legal — that is a real, portable fsync.
+        const fileFlush = ["const fd = fs.openSync(temporary, 'wx', 0o600);", 'fs.fsyncSync(fd);'];
+        expect(rejects(fileFlush, 0)).toBe(false);
+        // Opening a directory without flushing it (readdir-style handles) stays legal.
+        const openOnly = ["const parent = fs.openSync(path.dirname(file), 'r');", 'fs.closeSync(parent);'];
+        expect(rejects(openOnly, 0)).toBe(false);
+    });
+});

package/dist/tests/structural/native-release-artifacts.test.js

@@ -35,4 +35,18 @@ describe('native release artifacts', () => {
         expect(gitignore).toContain('cli/native-artifacts/');
         expect(tracked).toBe('');
     });
+    it('builds the fault-injection addon before every Jest suite without publishing it', () => {
+        const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(CLI_ROOT, 'package.json'), 'utf8'));
+        expect(pkg.scripts['native:test-build']).toContain('secure_fs_test');
+        for (const name of ['ci.yml', 'release.yml']) {
+            const workflow = fs_1.default.readFileSync(path_1.default.join(REPO_ROOT, '.github', 'workflows', name), 'utf8');
+            const testBuild = workflow.indexOf('run: npm run native:test-build');
+            const jest = workflow.indexOf('run: npx jest --runInBand --bail');
+            expect(testBuild).toBeGreaterThanOrEqual(0);
+            expect(testBuild).toBeLessThan(jest);
+            expect(workflow).toContain("'native/build/Release', 'secure_fs_test.node'");
+            expect(workflow).not.toContain('path: cli/prebuilds/${{ matrix.target }}/secure_fs_test.node');
+            expect(workflow).not.toContain('secure_fs_test.node\n');
+        }
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "9.8.0",
+  "version": "9.10.0",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"
@@ -18,7 +18,8 @@
     "doc": "docs"
   },
   "scripts": {
-    "native:build": "node-gyp rebuild --directory native && node scripts/package-native.js",
+    "native:build": "node-gyp configure --directory native && node-gyp build --directory native -- secure_fs && node scripts/package-native.js",
+    "native:test-build": "node-gyp configure --directory native && node-gyp build --directory native -- secure_fs_test",
     "native:package-check": "node scripts/assert-native-package.js",
     "build": "tsc && chmod +x dist/src/index.js",
     "typecheck": "tsc --noEmit",