From 49d62e20a4a1a10c36d8d5aa640884f395fceb05 Mon Sep 17 00:00:00 2001 From: Juergen Kunz Date: Thu, 5 Mar 2026 14:01:00 +0000 Subject: [PATCH] fix(fs): replace execSync and fsync workarounds with atomic async FsHelpers operations to avoid XFS races and shell dependencies --- changelog.md | 8 ++++++ ts/00_commitinfo_data.ts | 2 +- ts/mod_compiler/classes.tscompiler.ts | 37 +-------------------------- ts/mod_unpack/classes.tsunpacker.ts | 25 ++++++++++-------- 4 files changed, 24 insertions(+), 48 deletions(-) diff --git a/changelog.md b/changelog.md index 96e0c8f..9d70228 100644 --- a/changelog.md +++ b/changelog.md @@ -1,5 +1,13 @@ # Changelog +## 2026-03-05 - 4.1.14 - fix(fs) +replace execSync and fsync workarounds with atomic async FsHelpers operations to avoid XFS races and shell dependencies + +- Removed child_process.execSync usage and shell mv/rm commands in mod_unpack and mod_compiler. +- Removed syncDirectoryTree and fsync-based workaround from the compiler module. +- Use FsHelpers.move and FsHelpers.removeDirectory (async rename/remove) for atomic filesystem operations during unpack. +- Await performUnpack directly and simplify unpack flow to improve portability and reliability on XFS and other filesystems. + ## 2026-03-05 - 4.1.13 - fix(mod_unpack) Use child_process.execSync (mv/rm) to perform unpack atomically, replacing async fs operations and logs to avoid ENOENT/partial directory listings on XFS diff --git a/ts/00_commitinfo_data.ts b/ts/00_commitinfo_data.ts index 5591464..7c2b7fe 100644 --- a/ts/00_commitinfo_data.ts +++ b/ts/00_commitinfo_data.ts @@ -3,6 +3,6 @@ */ export const commitinfo = { name: '@git.zone/tsbuild', - version: '4.1.13', + version: '4.1.14', description: 'A tool for compiling TypeScript files using the latest nightly features, offering flexible APIs and a CLI for streamlined development.' } diff --git a/ts/mod_compiler/classes.tscompiler.ts b/ts/mod_compiler/classes.tscompiler.ts index cf7c2cf..9ef52de 100644 --- a/ts/mod_compiler/classes.tscompiler.ts +++ b/ts/mod_compiler/classes.tscompiler.ts @@ -1,8 +1,5 @@ import type { CompilerOptions, Diagnostic, Program } from 'typescript'; import typescript from 'typescript'; -import * as fs from 'fs'; -import * as path from 'path'; -import { execSync } from 'child_process'; import * as smartdelay from '@push.rocks/smartdelay'; import * as smartpromise from '@push.rocks/smartpromise'; import * as smartpath from '@push.rocks/smartpath'; @@ -370,18 +367,7 @@ export class TsCompiler { // Perform unpack if compilation succeeded if (result.errorSummary.totalErrors === 0) { - // Force XFS to commit all pending directory entries before unpacking. - // TypeScript's writeFileSync creates entries that may reside in XFS's - // delayed log. Without sync, readdir can return partial results. - execSync('sync'); - this.syncDirectoryTree(destDir); - - try { - await performUnpack(pattern, destDir, this.cwd); - } catch (unpackErr: any) { - console.error(` ⚠️ Unpack error for ${destPath}: ${unpackErr.message}`); - } - + await performUnpack(pattern, destDir, this.cwd); successfulOutputDirs.push(destDir); } @@ -504,27 +490,6 @@ export class TsCompiler { return success; } - /** - * Recursively fsync all directories in a tree. - * Forces XFS to commit pending directory entries from its log. - */ - private syncDirectoryTree(dirPath: string): void { - try { - const fd = fs.openSync(dirPath, 'r'); - fs.fsyncSync(fd); - fs.closeSync(fd); - - const entries = fs.readdirSync(dirPath, { withFileTypes: true }); - for (const entry of entries) { - if (entry.isDirectory()) { - this.syncDirectoryTree(path.join(dirPath, entry.name)); - } - } - } catch { - // Ignore errors (directory may not exist) - } - } - /** * Merge multiple error summaries into one */ diff --git a/ts/mod_unpack/classes.tsunpacker.ts b/ts/mod_unpack/classes.tsunpacker.ts index f65550e..eb7eca3 100644 --- a/ts/mod_unpack/classes.tsunpacker.ts +++ b/ts/mod_unpack/classes.tsunpacker.ts @@ -1,5 +1,4 @@ import * as path from 'path'; -import { execSync } from 'child_process'; import { TsPublishConfig } from '../mod_config/index.js'; import { FsHelpers } from '../mod_fs/index.js'; @@ -83,10 +82,9 @@ export class TsUnpacker { /** * Perform the unpack operation - flatten nested output directories. * - * Uses shell commands (mv, rm) via execSync for reliability. Node.js async - * fs operations (rename, rm) can race on XFS filesystems where metadata - * commits are delayed, causing ENOENT or partial directory listings. - * Shell commands execute as direct syscalls without libuv's async layer. + * Renames the nested directory to a temp location, removes the dest dir, + * then renames the temp dir back as dest. Uses only rename operations + * which are atomic at the kernel level. * * Returns true if unpacking was performed, false if skipped. */ @@ -102,12 +100,17 @@ export class TsUnpacker { const nestedPath = this.getNestedPath(); const tempPath = this.destDir + '.__unpack_temp__'; - // Use shell commands for atomic, sequential filesystem operations. - // This avoids race conditions between Node.js async fs operations on XFS. - execSync(`rm -rf "${tempPath}"`, { stdio: 'ignore' }); - execSync(`mv "${nestedPath}" "${tempPath}"`, { stdio: 'ignore' }); - execSync(`rm -rf "${this.destDir}"`, { stdio: 'ignore' }); - execSync(`mv "${tempPath}" "${this.destDir}"`, { stdio: 'ignore' }); + // Step 1: Clean up any leftover temp dir from a previous failed run + await FsHelpers.removeDirectory(tempPath); + + // Step 2: Rename nested → temp + await FsHelpers.move(nestedPath, tempPath); + + // Step 3: Remove dest dir (now contains only sibling folders) + await FsHelpers.removeDirectory(this.destDir); + + // Step 4: Rename temp → dest + await FsHelpers.move(tempPath, this.destDir); return true; }