endef 2.0.2 → 2.0.4

package/README.md

@@ -2,7 +2,7 @@
 
 `endef` 是一个纯 Node.js 的文件旁路转换工具。
 
-它适合这样的场景：某些常见源码或文本后缀的文件在系统读取、复制、粘贴、编辑器打开时出现乱码或异常，但通过 Node.js 脚本读取仍然正常。`endef` 会先把目标文件内容写到同目录的 `.endef` 副本里，再删除原文件，并用 `.endef` 副本内容新建原文件。
+它适合这样的场景：某些常见源码或文本后缀的文件在系统读取、复制、粘贴、编辑器打开时出现乱码或异常，但通过 Node.js 脚本读取仍然正常。`endef` 会先把目标文件内容写到同目录的 `.endef` 副本里，再用脚本批量删除原文件并把 `.endef` 改回原文件名。
 
 示例：
 
@@ -16,11 +16,10 @@ README.md -> README.md.endef -> README.md
 
 ## 特性
 
-- 纯 Node.js 实现，不依赖 Bash、find、xargs、grep 等 shell 工具
+- Node.js CLI，恢复阶段可自动调用 Bash 或 PowerShell 脚本
 - 默认旁路后缀为 `.endef`
 - `en` 默认转换所有匹配后缀的文件
-- `en --marker` 可以只转换命中 marker 的文件，marker 支持数组配置，也支持 CLI 手动指定多个
-- `de` 会删除原文件，用 `.endef` 临时副本内容新建原文件，再删除 `.endef`
+- `de` 会用脚本批量删除原文件，并把 `.endef` 临时副本改回原文件名
 - `pack` 会把恢复后的目录打包成 `.tar.gz`
 - 不引入生产依赖
 
@@ -42,31 +41,7 @@ npm install -g endef
 endef en /path/to/project
 ```
 
-只转换命中默认 marker 的文件：
-
-```bash
-endef en /path/to/project --marker
-```
-
-手动指定 marker：
-
-```bash
-endef en /path/to/project --marker E-SafeNet
-```
-
-指定多个 marker：
-
-```bash
-endef en /path/to/project --marker E-SafeNet --marker BadText
-```
-
-也可以用英文逗号分隔：
-
-```bash
-endef en /path/to/project --marker E-SafeNet,BadText
-```
-
-删除原文件，用 `.endef` 副本内容新建原文件，再删除 `.endef`：
+用脚本批量删除原文件，并把 `.endef` 改回原文件名：
 
 ```bash
 endef de /path/to/project
@@ -107,11 +82,11 @@ endef all [directory] [options]
 
 `en` 会扫描目标目录，把匹配后缀的文件读取出来，并写成同目录的 `.endef` 副本。
 
-`de` 会扫描目标目录中的 `.endef` 文件，删除对应的原文件，用 `.endef` 副本内容新建原文件，然后删除 `.endef` 副本。这个命令会直接修改文件，请在执行前确认目录和备份策略。
+`de` 会扫描目标目录中的 `.endef` 文件，并用外部脚本批量删除原文件、把 `.endef` 改回原文件名。默认模式是 `auto`：优先使用 Bash 的 `find + xargs -P`，没有 Bash 时在 Windows 上使用 PowerShell。这个命令会直接修改文件，请在执行前确认目录和备份策略。
 
 `pack` 会按当前配置扫描当前目录，把没有被 `excludeDirs` 排除的文件打包成 `.tar.gz`。如果输出文件已存在，会直接覆盖。
 
-`all` 会按顺序执行 `en`、`de`、`pack`，适合确认配置后一次性完成旁路转换、新建恢复和打包。
+`all` 会按顺序执行 `en`、`de`、`pack`，适合确认配置后一次性完成旁路转换、脚本恢复和打包。
 
 ## 参数
 
@@ -121,18 +96,17 @@ endef all [directory] [options]
 --ext <list>          目标文件后缀，多个值用英文逗号分隔
 --exclude <list>      排除目录名，多个值用英文逗号分隔
 --concurrency <n>     并发文件操作数量
---marker [text]       只为命中任意 marker 的文件生成副本
 --out <file>          压缩包输出名称
+--mode <mode>         de/all 恢复模式：auto、bash、powershell、node
 ```
 
 示例：
 
 ```bash
 endef en . --ext .js,.ts,.vue,.md --exclude node_modules,.git,dist
-endef en . --marker E-SafeNet --marker BadText
 endef de .
 endef pack recovered
-endef all . --marker --out recovered
+endef all . --out recovered
 ```
 
 ## 配置文件
@@ -150,7 +124,6 @@ endef all . --marker --out recovered
 ```json
 {
   "suffix": ".endef",
-  "markers": ["E-SafeNet"],
   "extensions": [
     ".js",
     ".jsx",
@@ -186,49 +159,33 @@ endef all . --marker --out recovered
 }
 ```
 
-## marker 模式
-
-默认情况下：
-
-```bash
-endef en .
-```
-
-会为所有匹配后缀的文件生成 `.endef` 副本。
-
-启用 marker 模式后：
-
-```bash
-endef en . --marker
-```
+## 恢复策略
 
-只会为命中任意 marker 的文件生成 `.endef` 副本。`--marker` 不带值时使用配置中的 `markers`，默认是：
+恢复时，`endef` 会把：
 
-```json
-["E-SafeNet"]
+```text
+file.ext.endef
 ```
 
-如果 CLI 指定了 marker，则使用 CLI 的值：
+恢复为：
 
-```bash
-endef en . --marker E-SafeNet --marker BadText
+```text
+file.ext
 ```
 
-## 恢复策略
-
-恢复时，`endef` 会把：
+`de` 默认使用脚本恢复。`auto` 模式会优先尝试 Bash，因为 `find + xargs -P` 可以并行处理大量文件；如果没有 Bash，则在 Windows 上使用单个 PowerShell 进程批量处理。恢复时会把：
 
 ```text
 file.ext.endef
 ```
 
-删除原文件后，用 `.endef` 内容新建：
+改回：
 
 ```text
 file.ext
 ```
 
-如果 `file.ext` 已经存在，会先被删除，然后用 `.endef` 副本内容创建新的 `file.ext`。创建成功后，`file.ext.endef` 会被删除。这个行为符合工具的核心假设：原文件可能已经被异常内容污染，而 `.endef` 是通过旁路读取保存出来的可恢复内容。
+如果 `file.ext` 已经存在，会先被删除。这个行为符合工具的核心假设：原文件可能已经被异常内容污染，而 `.endef` 是通过旁路读取保存出来的可恢复内容。
 
 ## 打包策略
 
@@ -286,10 +243,10 @@ endef de .
 endef pack
 ```
 
-同样支持 marker、排除目录和输出名称：
+同样支持排除目录和输出名称：
 
 ```bash
-endef all . --marker E-SafeNet,BadText --exclude node_modules,.git,dist --out recovered
+endef all . --exclude node_modules,.git,dist --out recovered
 ```
 
 ## 安全建议
@@ -297,7 +254,6 @@ endef all . --marker E-SafeNet,BadText --exclude node_modules,.git,dist --out re
 - 操作前尽量手动备份目录或磁盘
 - 优先在干净系统、离线环境或挂载出来的磁盘上运行
 - 先在小目录中测试 `endef en` 和 `endef de`
-- 不确定 marker 是否完整时，优先使用默认的全量 `endef en`
 - 不要直接运行恢复出来的未知脚本或可执行文件
 - 恢复后建议做杀毒、哈希校验和人工抽查
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "endef",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Recover text and source files through safe .endef sidecar copies.",
   "bin": {
     "endef": "bin/main.js"

package/src/config.js

@@ -4,7 +4,6 @@ const path = require('path')
 
 const defaultConfig = {
   suffix: '.endef',
-  markers: ['E-SafeNet'],
   extensions: [
     '.js',
     '.jsx',
@@ -36,7 +35,8 @@ const defaultConfig = {
   ],
   excludeDirs: ['node_modules', '.git', 'dist', '.next', '.nuxt', '.cache'],
   excludeFiles: ['.endef.json'],
-  concurrency: 32
+  concurrency: 32,
+  restoreMode: 'auto'
 }
 
 function loadConfig(cwd, explicitConfigFile, targetDirectory) {
@@ -73,35 +73,13 @@ function stripBom(value) {
 }
 
 function mergeConfig(base, next) {
-  const markers = normalizeMarkers(next.markers)
-
   return {
     ...base,
     ...next,
     extensions: Array.isArray(next.extensions) ? next.extensions : base.extensions,
     excludeDirs: Array.isArray(next.excludeDirs) ? next.excludeDirs : base.excludeDirs,
-    excludeFiles: Array.isArray(next.excludeFiles) ? next.excludeFiles : base.excludeFiles,
-    markers: markers.length > 0 ? markers : base.markers
+    excludeFiles: Array.isArray(next.excludeFiles) ? next.excludeFiles : base.excludeFiles
   }
 }
 
-function normalizeMarkers(value) {
-  if (Array.isArray(value)) {
-    return value.map(item => String(item).trim()).filter(Boolean)
-  }
-
-  return []
-}
-
-function splitMarkers(value) {
-  if (!value) {
-    return []
-  }
-
-  return String(value)
-    .split(',')
-    .map(item => item.trim())
-    .filter(Boolean)
-}
-
-module.exports = { defaultConfig, loadConfig, normalizeMarkers, splitMarkers }
+module.exports = { defaultConfig, loadConfig }

package/src/de.js

@@ -1,95 +1,233 @@
 const fs = require('fs/promises')
 const path = require('path')
+const { execFile } = require('child_process')
+const { promisify } = require('util')
 const { defaultConfig } = require('./config')
-const { createLimiter, walk } = require('./utils')
+
+const execFileAsync = promisify(execFile)
 
 async function restoreFiles(directory, options = {}) {
   const config = {
     ...defaultConfig,
     ...options,
-    directory: path.resolve(directory || process.cwd())
+    directory: path.resolve(directory || process.cwd()),
+    restoreMode: options.restoreMode || 'auto'
   }
-  const stats = createStats()
-  const limit = createLimiter(config.concurrency)
-  const tasks = []
+  const mode = await resolveRestoreMode(config.restoreMode)
 
-  await walk(config.directory, config, async filePath => {
-    if (!filePath.endsWith(config.suffix)) {
-      return
-    }
+  if (mode === 'bash') {
+    return restoreWithBash(config)
+  }
 
-    tasks.push(
-      limit(async () => {
-        await restoreOne(filePath, config, stats)
-      }).catch(error => {
-        stats.failed += 1
-        console.error(`Failed: ${filePath}`)
-        console.error(error && error.message ? error.message : error)
-      })
-    )
-  })
+  if (mode === 'powershell') {
+    return restoreWithPowerShell(config)
+  }
 
-  await Promise.all(tasks)
-  console.log(
-    `Done. restored=${stats.restored}, removed=${stats.removed}, created=${stats.created}, deleted=${stats.deleted}, failed=${stats.failed}`
-  )
-  return stats
+  return restoreWithNode(config)
 }
 
-async function restoreOne(filePath, config, stats) {
-  const targetPath = filePath.slice(0, -config.suffix.length)
-  const targetExists = await exists(targetPath)
-  const data = await fs.readFile(filePath)
+async function resolveRestoreMode(mode) {
+  if (mode !== 'auto') {
+    return mode
+  }
 
-  await fs.rm(targetPath, { force: true })
-  await waitForMissing(targetPath)
-  await fs.writeFile(targetPath, data, { flag: 'wx' })
-  await fs.rm(filePath, { force: true })
+  if (await hasCommand('bash', ['--version'])) {
+    return 'bash'
+  }
 
-  stats.restored += 1
-  if (targetExists) {
-    stats.removed += 1
+  if (process.platform === 'win32') {
+    return 'powershell'
   }
-  stats.created += 1
-  stats.deleted += 1
-  console.log(`Restored: ${filePath} -> ${targetPath}`)
+
+  return 'node'
 }
 
-async function exists(filePath) {
+async function hasCommand(command, args) {
   try {
-    await fs.access(filePath)
+    await execFileAsync(command, args, { windowsHide: true })
     return true
   } catch (error) {
     return false
   }
 }
 
-async function waitForMissing(filePath) {
-  for (let index = 0; index < 20; index += 1) {
-    if (!(await exists(filePath))) {
-      return
-    }
+async function restoreWithBash(config) {
+  const root = await toBashPath(config.directory)
+  const excludeDirs = config.excludeDirs.join('\n')
+  const jobs = String(config.concurrency || 32)
+  const script = `
+set -e
+root=$1
+suffix=$2
+jobs=$3
+cd "$root"
+find_args=(.)
+while IFS= read -r dir; do
+  if [ -n "$dir" ]; then
+    find_args+=( -path "*/$dir" -prune -o )
+  fi
+done <<< "$ENDEF_EXCLUDE_DIRS"
+find_args+=( -type f -name "*$suffix" -print0 )
+find "\${find_args[@]}" | xargs -0 -r -P "$jobs" -I{} bash -c '
+  suffix="$1"
+  file="$2"
+  target="\${file%$suffix}"
+  rm -f -- "$target"
+  mv -f -- "$file" "$target"
+  printf "%s\\0" "$target"
+' _ "$suffix" {}
+`
 
-    await delay(25)
+  const { stdout } = await execFileAsync('bash', ['-lc', script, '_', root, config.suffix, jobs], {
+    env: {
+      ...process.env,
+      ENDEF_EXCLUDE_DIRS: excludeDirs
+    },
+    maxBuffer: 1024 * 1024 * 64,
+    windowsHide: true
+  })
+  const restored = countNullSeparated(stdout)
+
+  console.log(`Done. mode=bash, restored=${restored}, failed=0`)
+  return {
+    mode: 'bash',
+    restored,
+    failed: 0
+  }
+}
+
+async function toBashPath(filePath) {
+  if (process.platform !== 'win32') {
+    return filePath
   }
 
-  throw new Error(`Target still exists after remove: ${filePath}`)
+  try {
+    const { stdout } = await execFileAsync('bash', ['-lc', 'cygpath -u "$1"', '_', filePath], {
+      windowsHide: true
+    })
+
+    return stdout.trim() || filePath
+  } catch (error) {
+    return filePath
+  }
 }
 
-function delay(ms) {
-  return new Promise(resolve => {
-    setTimeout(resolve, ms)
-  })
+async function restoreWithPowerShell(config) {
+  const script = `
+$root = $env:ENDEF_ROOT
+$suffix = $env:ENDEF_SUFFIX
+$excludeText = $env:ENDEF_EXCLUDE_DIRS
+$excludeDirs = @()
+if ($excludeText) {
+  $excludeDirs = $excludeText -split "\\n" | Where-Object { $_ }
+}
+$restored = 0
+Get-ChildItem -LiteralPath $root -Recurse -File -Filter "*$suffix" | Where-Object {
+  $cleanRoot = $root.TrimEnd('\\', '/')
+  $relative = $_.FullName.Substring($cleanRoot.Length).TrimStart('\\', '/')
+  $parts = $relative -split '[\\\\/]'
+  $skip = $false
+  foreach ($dir in $excludeDirs) {
+    if ($parts -contains $dir) {
+      $skip = $true
+      break
+    }
+  }
+  -not $skip
+} | ForEach-Object {
+  $target = $_.FullName.Substring(0, $_.FullName.Length - $suffix.Length)
+  Remove-Item -LiteralPath $target -Force -ErrorAction SilentlyContinue
+  Move-Item -LiteralPath $_.FullName -Destination $target -Force
+  $restored += 1
 }
+Write-Output $restored
+`
+  const { stdout } = await execFileAsync(
+    'powershell.exe',
+    [
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy',
+      'Bypass',
+      '-Command',
+      script
+    ],
+    {
+      env: {
+        ...process.env,
+        ENDEF_ROOT: config.directory,
+        ENDEF_SUFFIX: config.suffix,
+        ENDEF_EXCLUDE_DIRS: config.excludeDirs.join('\n')
+      },
+      maxBuffer: 1024 * 1024 * 64,
+      windowsHide: true
+    }
+  )
+  const restored = Number(stdout.trim()) || 0
 
-function createStats() {
+  console.log(`Done. mode=powershell, restored=${restored}, failed=0`)
   return {
+    mode: 'powershell',
+    restored,
+    failed: 0
+  }
+}
+
+async function restoreWithNode(config) {
+  const stats = {
     restored: 0,
-    removed: 0,
-    created: 0,
-    deleted: 0,
     failed: 0
   }
+
+  await restoreNodeDirectory(config.directory, config, stats)
+  console.log(`Done. mode=node, restored=${stats.restored}, failed=${stats.failed}`)
+  return {
+    mode: 'node',
+    restored: stats.restored,
+    failed: stats.failed
+  }
+}
+
+async function restoreNodeDirectory(directory, config, stats) {
+  const entries = await fs.readdir(directory, { withFileTypes: true })
+
+  await Promise.all(
+    entries.map(async entry => {
+      const filePath = path.join(directory, entry.name)
+
+      if (entry.isDirectory()) {
+        if (config.excludeDirs.includes(entry.name)) {
+          return
+        }
+
+        await restoreNodeDirectory(filePath, config, stats)
+        return
+      }
+
+      if (!entry.isFile() || !filePath.endsWith(config.suffix)) {
+        return
+      }
+
+      try {
+        const targetPath = filePath.slice(0, -config.suffix.length)
+        await fs.rm(targetPath, { force: true })
+        await fs.rename(filePath, targetPath)
+        stats.restored += 1
+      } catch (error) {
+        stats.failed += 1
+        console.error(`Failed: ${filePath}`)
+        console.error(error && error.message ? error.message : error)
+      }
+    })
+  )
+}
+
+function countNullSeparated(value) {
+  if (!value) {
+    return 0
+  }
+
+  return value.split('\0').filter(Boolean).length
 }
 
 module.exports = restoreFiles

package/src/en.js

@@ -29,11 +29,6 @@ async function processFiles(directory, options = {}) {
         const outputPath = `${filePath}${config.suffix}`
         const data = await fs.readFile(filePath)
 
-        if (config.markerFilter && !matchesAnyMarker(data, config.markers)) {
-          stats.skipped += 1
-          return
-        }
-
         await fs.writeFile(outputPath, data)
         console.log(`Written: ${outputPath}`)
         stats.written += 1
@@ -58,12 +53,4 @@ function createStats() {
   }
 }
 
-function matchesAnyMarker(data, markers) {
-  if (!Array.isArray(markers) || markers.length === 0) {
-    return false
-  }
-
-  return markers.some(marker => data.includes(marker))
-}
-
 module.exports = processFiles

package/src/pack.js

@@ -2,36 +2,93 @@ const fs = require('fs')
 const fsp = require('fs/promises')
 const path = require('path')
 const zlib = require('zlib')
+const { promisify } = require('util')
 const { once } = require('events')
 const { pipeline } = require('stream/promises')
 const { defaultConfig } = require('./config')
 const { walk } = require('./utils')
 
+const gunzip = promisify(zlib.gunzip)
+
 async function packFiles(directory, options = {}) {
-  const config = {
+  const config = createPackConfig(directory, options)
+  const outputPath = resolveOutputPath(config.directory, config.out)
+  const entries = await collectPackEntries(config, outputPath)
+
+  await fsp.rm(outputPath, { force: true })
+  await writeTarGz(config.directory, outputPath, entries)
+  console.log(`Packed: ${outputPath}`)
+  console.log(`Done. files=${entries.length}`)
+
+  return {
+    outputPath,
+    files: entries.length
+  }
+}
+
+function createPackConfig(directory, options) {
+  return {
     ...defaultConfig,
     ...options,
     directory: path.resolve(directory || process.cwd())
   }
-  const outputPath = resolveOutputPath(config.directory, config.out)
-  const files = []
+}
+
+async function collectPackEntries(config, outputPath) {
+  const entries = []
 
   await walk(config.directory, config, async filePath => {
-    if (path.resolve(filePath) === outputPath || filePath.endsWith(config.suffix)) {
+    if (shouldSkipPackFile(filePath, config, outputPath)) {
       return
     }
 
-    files.push(filePath)
+    entries.push(createEntry(config.directory, filePath, filePath))
   })
 
-  await fsp.rm(outputPath, { force: true })
-  await writeTarGz(config.directory, outputPath, files)
-  console.log(`Packed: ${outputPath}`)
-  console.log(`Done. files=${files.length}`)
+  return entries
+}
+
+async function collectRecoveryEntries(config, options = {}) {
+  const entries = []
+  const sidecarTargets = new Set()
+
+  await walk(config.directory, config, async filePath => {
+    if (filePath.endsWith(config.suffix)) {
+      sidecarTargets.add(path.resolve(filePath.slice(0, -config.suffix.length)))
+    }
+  })
+
+  await walk(config.directory, config, async filePath => {
+    const resolvedPath = path.resolve(filePath)
+
+    if (options.outputPath && resolvedPath === path.resolve(options.outputPath)) {
+      return
+    }
+
+    if (filePath.endsWith(config.suffix)) {
+      const targetPath = filePath.slice(0, -config.suffix.length)
+      entries.push(createEntry(config.directory, filePath, targetPath))
+      return
+    }
+
+    if (options.onlySidecars || sidecarTargets.has(resolvedPath)) {
+      return
+    }
+
+    entries.push(createEntry(config.directory, filePath, filePath))
+  })
+
+  return entries
+}
+
+function shouldSkipPackFile(filePath, config, outputPath) {
+  return path.resolve(filePath) === outputPath || filePath.endsWith(config.suffix)
+}
 
+function createEntry(rootDirectory, sourcePath, archiveTargetPath) {
   return {
-    outputPath,
-    files: files.length
+    sourcePath,
+    archivePath: toArchivePath(path.relative(rootDirectory, archiveTargetPath))
   }
 }
 
@@ -51,30 +108,77 @@ function normalizeOutputName(out) {
   return `${out}.tar.gz`
 }
 
-async function writeTarGz(rootDirectory, outputPath, files) {
+async function writeTarGz(rootDirectory, outputPath, entries) {
   await fsp.mkdir(path.dirname(outputPath), { recursive: true })
 
   const gzip = zlib.createGzip()
   const output = fs.createWriteStream(outputPath)
-  const writer = writeTarEntries(rootDirectory, files, gzip)
+  const writer = writeTarEntries(entries, gzip)
 
   await Promise.all([writer, pipeline(gzip, output)])
 }
 
-async function writeTarEntries(rootDirectory, files, stream) {
-  for (const filePath of files) {
-    const stat = await fsp.stat(filePath)
-    const archivePath = toArchivePath(path.relative(rootDirectory, filePath))
-
-    await writeToStream(stream, createHeader(archivePath, stat))
+async function writeTarEntries(entries, stream) {
+  for (const entry of entries) {
+    const stat = await fsp.stat(entry.sourcePath)
 
-    await writeFileToStream(filePath, stream)
+    await writeToStream(stream, createHeader(entry.archivePath, stat))
+    await writeFileToStream(entry.sourcePath, stream)
     await writeToStream(stream, Buffer.alloc(paddingSize(stat.size)))
   }
 
   stream.end(Buffer.alloc(1024))
 }
 
+async function extractTarGz(archivePath, directory) {
+  const archive = await fsp.readFile(archivePath)
+  const data = await gunzip(archive)
+  let offset = 0
+  let extracted = 0
+
+  while (offset + 512 <= data.length) {
+    const header = data.subarray(offset, offset + 512)
+
+    if (header.every(value => value === 0)) {
+      break
+    }
+
+    const entry = readHeader(header)
+    offset += 512
+
+    const content = data.subarray(offset, offset + entry.size)
+    const outputPath = path.resolve(directory, entry.name)
+
+    if (!outputPath.startsWith(path.resolve(directory) + path.sep)) {
+      throw new Error(`Unsafe archive path: ${entry.name}`)
+    }
+
+    await fsp.mkdir(path.dirname(outputPath), { recursive: true })
+    await fsp.rm(outputPath, { force: true })
+    await fsp.writeFile(outputPath, content, { flag: 'wx' })
+
+    offset += entry.size + paddingSize(entry.size)
+    extracted += 1
+  }
+
+  return extracted
+}
+
+async function removeSidecars(directory, config) {
+  let deleted = 0
+
+  await walk(directory, config, async filePath => {
+    if (!filePath.endsWith(config.suffix)) {
+      return
+    }
+
+    await fsp.rm(filePath, { force: true })
+    deleted += 1
+  })
+
+  return deleted
+}
+
 async function writeFileToStream(filePath, stream) {
   for await (const chunk of fs.createReadStream(filePath)) {
     await writeToStream(stream, chunk)
@@ -113,6 +217,20 @@ function createHeader(filePath, stat) {
   return header
 }
 
+function readHeader(header) {
+  const name = readString(header, 0, 100)
+  const prefix = readString(header, 345, 155)
+
+  return {
+    name: prefix ? `${prefix}/${name}` : name,
+    size: parseInt(readString(header, 124, 12).trim() || '0', 8)
+  }
+}
+
+function readString(buffer, offset, length) {
+  return buffer.subarray(offset, offset + length).toString('utf8').replace(/\0.*$/, '')
+}
+
 function splitTarPath(filePath) {
   if (Buffer.byteLength(filePath) <= 100) {
     return {
@@ -156,3 +274,9 @@ function paddingSize(size) {
 }
 
 module.exports = packFiles
+module.exports.createPackConfig = createPackConfig
+module.exports.collectRecoveryEntries = collectRecoveryEntries
+module.exports.extractTarGz = extractTarGz
+module.exports.removeSidecars = removeSidecars
+module.exports.resolveOutputPath = resolveOutputPath
+module.exports.writeTarGz = writeTarGz

package/src/run.js

@@ -1,7 +1,7 @@
 const enF = require('./en')
 const deF = require('./de')
 const packF = require('./pack')
-const { loadConfig, splitMarkers } = require('./config')
+const { loadConfig } = require('./config')
 
 function printHelp() {
   console.log(`Usage:
@@ -16,16 +16,14 @@ Options:
   --ext <list>          Comma separated target extensions
   --exclude <list>      Comma separated excluded directory names
   --concurrency <n>     Concurrent file operation limit
-  --marker [text]       Only create sidecar files when any marker is found
   --out <file>          Archive output name
+  --mode <mode>         Restore mode for de/all: auto, bash, powershell, node
 `)
 }
 
 function parseArgs(command, args) {
   const result = {
     directory: process.cwd(),
-    markerFilter: undefined,
-    markers: [],
     positionals: []
   }
 
@@ -98,20 +96,14 @@ function parseArgs(command, args) {
       continue
     }
 
-    if (arg.startsWith('--marker=')) {
-      result.markerFilter = true
-      result.markers.push(...splitMarkers(arg.slice('--marker='.length)))
+    if (arg.startsWith('--mode=')) {
+      result.restoreMode = arg.slice('--mode='.length)
       continue
     }
 
-    if (arg === '--marker') {
-      result.markerFilter = true
-
-      if (args[index + 1] && !args[index + 1].startsWith('-')) {
-        result.markers.push(...splitMarkers(args[index + 1]))
-        index += 1
-      }
-
+    if (arg === '--mode') {
+      result.restoreMode = args[index + 1]
+      index += 1
       continue
     }
 
@@ -160,8 +152,7 @@ async function run(args) {
   const options = {
     ...config,
     ...cliOptions,
-    directory: cliOptions.directory || config.directory || process.cwd(),
-    markers: cliOptions.markers && cliOptions.markers.length > 0 ? cliOptions.markers : config.markers
+    directory: cliOptions.directory || config.directory || process.cwd()
   }
 
   if (command === 'en') {