endef 1.0.9 → 2.0.0

package/README.md

@@ -0,0 +1,312 @@
+# endef
+
+`endef` 是一个纯 Node.js 的文件旁路转换工具。
+
+它适合这样的场景：某些常见源码或文本后缀的文件在系统读取、复制、粘贴、编辑器打开时出现乱码或异常，但通过 Node.js 脚本读取仍然正常。`endef` 会先把目标文件内容写到同目录的 `.endef` 副本里，再把 `.endef` 副本内容刷回原文件，并删除临时副本。
+
+示例：
+
+```text
+src/App.vue -> src/App.vue.endef -> src/App.vue
+src/main.ts -> src/main.ts.endef -> src/main.ts
+README.md -> README.md.endef -> README.md
+```
+
+> `endef` 不是杀毒工具，也不能保证绕过所有拦截方式。建议在干净系统、离线磁盘、PE 或 Linux Live 环境里使用，恢复后仍然需要做安全扫描和人工抽查。
+
+## 特性
+
+- 纯 Node.js 实现，不依赖 Bash、find、xargs、grep 等 shell 工具
+- 默认旁路后缀为 `.endef`
+- `en` 默认转换所有匹配后缀的文件
+- `en --marker` 可以只转换命中 marker 的文件，marker 支持数组配置，也支持 CLI 手动指定多个
+- `de` 会把 `.endef` 内容写回原文件，并删除 `.endef` 临时副本
+- `pack` 会把恢复后的目录打包成 `.tar.gz`
+- 不引入生产依赖
+
+## 环境要求
+
+推荐 Node.js 22 或更高版本。
+
+## 安装
+
+```bash
+npm install -g endef
+```
+
+## 快速开始
+
+生成 `.endef` 副本：
+
+```bash
+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`：
+
+```bash
+endef de /path/to/project
+```
+
+打包当前目录：
+
+```bash
+endef pack
+```
+
+默认会使用当前目录名生成压缩包。例如当前目录是 `foo`，会生成：
+
+```text
+foo.tar.gz
+```
+
+指定输出文件名：
+
+```bash
+endef pack recovered
+```
+
+会生成：
+
+```text
+recovered.tar.gz
+```
+
+## 命令
+
+```text
+endef en [directory] [options]
+endef de [directory] [options]
+endef pack [name] [options]
+endef all [directory] [options]
+```
+
+`en` 会扫描目标目录，把匹配后缀的文件读取出来，并写成同目录的 `.endef` 副本。
+
+`de` 会扫描目标目录中的 `.endef` 文件，把副本内容写回原文件，然后删除 `.endef` 副本。这个命令会直接修改文件，请在执行前确认目录和备份策略。
+
+`pack` 会按当前配置扫描当前目录，把没有被 `excludeDirs` 排除的文件打包成 `.tar.gz`。如果输出文件已存在，会直接覆盖。
+
+`all` 会按顺序执行 `en`、`de`、`pack`，适合确认配置后一次性完成旁路转换、写回和打包。
+
+## 参数
+
+```text
+--config <file>       使用指定配置文件
+--suffix <suffix>     旁路文件后缀，默认：.endef
+--ext <list>          目标文件后缀，多个值用英文逗号分隔
+--exclude <list>      排除目录名，多个值用英文逗号分隔
+--concurrency <n>     并发文件操作数量
+--marker [text]       只为命中任意 marker 的文件生成副本
+--out <file>          压缩包输出名称
+```
+
+示例：
+
+```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` 会按下面的顺序读取配置，后面的配置覆盖前面的配置：
+
+```text
+用户目录：~/.endef/config.json
+当前目录：.endef.json
+命令参数：优先级最高
+```
+
+配置示例：
+
+```json
+{
+  "suffix": ".endef",
+  "markers": ["E-SafeNet"],
+  "extensions": [
+    ".js",
+    ".jsx",
+    ".cjs",
+    ".mjs",
+    ".mts",
+    ".ts",
+    ".tsx",
+    ".vue",
+    ".md",
+    ".yaml",
+    ".yml",
+    ".json",
+    ".type.ts",
+    ".scss",
+    ".css",
+    ".html",
+    ".txt",
+    ".env",
+    ".c",
+    ".h",
+    ".hpp",
+    ".java",
+    ".svn-base",
+    ".lock",
+    ".git",
+    ".gitconfig",
+    ".less"
+  ],
+  "excludeDirs": ["node_modules", ".git", "dist", ".next", ".nuxt", ".cache"],
+  "excludeFiles": [".endef.json"],
+  "concurrency": 32
+}
+```
+
+## marker 模式
+
+默认情况下：
+
+```bash
+endef en .
+```
+
+会为所有匹配后缀的文件生成 `.endef` 副本。
+
+启用 marker 模式后：
+
+```bash
+endef en . --marker
+```
+
+只会为命中任意 marker 的文件生成 `.endef` 副本。`--marker` 不带值时使用配置中的 `markers`，默认是：
+
+```json
+["E-SafeNet"]
+```
+
+如果 CLI 指定了 marker，则使用 CLI 的值：
+
+```bash
+endef en . --marker E-SafeNet --marker BadText
+```
+
+## 恢复策略
+
+恢复时，`endef` 会把：
+
+```text
+file.ext.endef
+```
+
+写回：
+
+```text
+file.ext
+```
+
+然后删除：
+
+```text
+file.ext.endef
+```
+
+如果 `file.ext` 已经存在，会被 `.endef` 副本内容覆盖。这个行为符合工具的核心假设：原文件可能已经被异常内容污染，而 `.endef` 是通过旁路读取保存出来的可恢复内容。
+
+## 打包策略
+
+打包命令：
+
+```bash
+endef pack
+```
+
+默认输出会使用当前目录名。例如当前目录是 `foo`，默认输出：
+
+```text
+foo.tar.gz
+```
+
+如果指定：
+
+```bash
+endef pack baz
+```
+
+则输出：
+
+```text
+baz.tar.gz
+```
+
+`pack` 会沿用配置里的 `excludeDirs`，也支持命令行临时指定：
+
+```bash
+endef pack --exclude node_modules,.git,dist
+```
+
+打包时会自动跳过：
+
+- 被 `excludeDirs` 排除的目录
+- 输出压缩包自身
+- 残留的 `.endef` 临时副本
+
+压缩包格式是 `.tar.gz`，不需要额外生产依赖。
+
+## 一步执行
+
+如果已经确认配置，可以使用：
+
+```bash
+endef all .
+```
+
+它等价于依次执行：
+
+```bash
+endef en .
+endef de .
+endef pack
+```
+
+同样支持 marker、排除目录和输出名称：
+
+```bash
+endef all . --marker E-SafeNet,BadText --exclude node_modules,.git,dist --out recovered
+```
+
+## 安全建议
+
+- 操作前尽量手动备份目录或磁盘
+- 优先在干净系统、离线环境或挂载出来的磁盘上运行
+- 先在小目录中测试 `endef en` 和 `endef de`
+- 不确定 marker 是否完整时，优先使用默认的全量 `endef en`
+- 不要直接运行恢复出来的未知脚本或可执行文件
+- 恢复后建议做杀毒、哈希校验和人工抽查
+
+## License
+
+MIT

package/bin/main.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-// ECMAScript module loader
-_import = require('esm')(module /*, options*/)
 
-const { run: start } = _import('../src/run')
+const { run } = require('../src/run')
 
-start(process.argv)
+run(process.argv).catch(error => {
+  console.error(error && error.message ? error.message : error)
+  process.exitCode = 1
+})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "endef",
-  "version": "1.0.9",
-  "description": "Encrypt or Decrypt Files Test",
+  "version": "2.0.0",
+  "description": "Recover text and source files through safe .endef sidecar copies.",
   "bin": {
     "endef": "bin/main.js"
   },
@@ -12,10 +12,17 @@
     "bin",
     "src"
   ],
-  "license": "MIT",
-  "dependencies": {
-    "esm": "^3.2.25"
+  "keywords": [
+    "file-recovery",
+    "sidecar",
+    "restore",
+    "cli",
+    "nodejs"
+  ],
+  "engines": {
+    "node": ">=22"
   },
+  "license": "MIT",
   "devDependencies": {
     "prettier": "^2.8.8"
   },

package/src/config.js

@@ -0,0 +1,107 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+const defaultConfig = {
+  suffix: '.endef',
+  markers: ['E-SafeNet'],
+  extensions: [
+    '.js',
+    '.jsx',
+    '.cjs',
+    '.mjs',
+    '.mts',
+    '.ts',
+    '.tsx',
+    '.vue',
+    '.md',
+    '.yaml',
+    '.yml',
+    '.json',
+    '.type.ts',
+    '.scss',
+    '.css',
+    '.html',
+    '.txt',
+    '.env',
+    '.c',
+    '.h',
+    '.hpp',
+    '.java',
+    '.svn-base',
+    '.lock',
+    '.git',
+    '.gitconfig',
+    '.less'
+  ],
+  excludeDirs: ['node_modules', '.git', 'dist', '.next', '.nuxt', '.cache'],
+  excludeFiles: ['.endef.json'],
+  concurrency: 32
+}
+
+function loadConfig(cwd, explicitConfigFile, targetDirectory) {
+  const configFiles = [path.join(os.homedir(), '.endef', 'config.json'), path.join(cwd, '.endef.json')]
+  const targetConfigFile = targetDirectory ? path.join(path.resolve(cwd, targetDirectory), '.endef.json') : ''
+
+  if (targetConfigFile && targetConfigFile !== configFiles[1]) {
+    configFiles.push(targetConfigFile)
+  }
+
+  if (explicitConfigFile) {
+    configFiles.push(path.resolve(cwd, explicitConfigFile))
+  }
+
+  return configFiles.reduce(
+    (config, file) => {
+      if (!fs.existsSync(file)) {
+        return config
+      }
+
+      try {
+        const nextConfig = JSON.parse(stripBom(fs.readFileSync(file, 'utf8')))
+        return mergeConfig(config, nextConfig)
+      } catch (error) {
+        throw new Error(`Cannot read config ${file}: ${error.message}`)
+      }
+    },
+    { ...defaultConfig }
+  )
+}
+
+function stripBom(value) {
+  return value.charCodeAt(0) === 0xfeff ? value.slice(1) : 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
+  }
+}
+
+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 }

package/src/de.js

@@ -1,13 +1,57 @@
-import { spawn } from 'child_process'
-import { resolve } from 'path'
+const fs = require('fs/promises')
+const path = require('path')
+const { defaultConfig } = require('./config')
+const { createLimiter, walk } = require('./utils')
 
-export const deSrc = resolve(__dirname)
-export const curDir = process.cwd()
+async function restoreFiles(directory, options = {}) {
+  const config = {
+    ...defaultConfig,
+    ...options,
+    directory: path.resolve(directory || process.cwd())
+  }
+  const stats = createStats()
+  const limit = createLimiter(config.concurrency)
+  const tasks = []
 
-export default function (args3) {
-  spawn(`bash`, [`${deSrc}\/de.sh ${curDir} ${args3}`], {
-    cwd: curDir,
-    stdio: 'inherit',
-    shell: process.platform === 'win32'
+  await walk(config.directory, config, async filePath => {
+    if (!filePath.endsWith(config.suffix)) {
+      return
+    }
+
+    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)
+      })
+    )
   })
+
+  await Promise.all(tasks)
+  console.log(`Done. restored=${stats.restored}, deleted=${stats.deleted}, failed=${stats.failed}`)
+  return stats
 }
+
+async function restoreOne(filePath, config, stats) {
+  const targetPath = filePath.slice(0, -config.suffix.length)
+  const data = await fs.readFile(filePath, 'utf8')
+
+  await fs.writeFile(targetPath, data, 'utf8')
+  await fs.rm(filePath, { force: true })
+
+  stats.restored += 1
+  stats.deleted += 1
+  console.log(`Restored: ${filePath} -> ${targetPath}`)
+}
+
+function createStats() {
+  return {
+    restored: 0,
+    deleted: 0,
+    failed: 0
+  }
+}
+
+module.exports = restoreFiles

package/src/en.js

@@ -1,54 +1,69 @@
-import fs from 'fs';
-import path from 'path';
-
-export default function processFiles(directory, fileExtensions, excludedDirectories = []) {
-  fs.readdir(directory, (err, files) => {
-    if (err) {
-      console.error('Error reading directory:', err);
-      return;
+const fs = require('fs/promises')
+const path = require('path')
+const { defaultConfig } = require('./config')
+const { createLimiter, matchesExtension, walk } = require('./utils')
+
+async function processFiles(directory, options = {}) {
+  const config = {
+    ...defaultConfig,
+    ...options,
+    directory: path.resolve(directory || process.cwd())
+  }
+  const stats = createStats()
+  const limit = createLimiter(config.concurrency)
+  const tasks = []
+
+  await walk(config.directory, config, async filePath => {
+    if (config.excludeFiles.includes(path.basename(filePath))) {
+      stats.skipped += 1
+      return
     }
 
-    files.forEach(file => {
-      const filePath = path.join(directory, file);
+    if (!matchesExtension(filePath, config.extensions) || filePath.endsWith(config.suffix)) {
+      stats.skipped += 1
+      return
+    }
 
-      fs.stat(filePath, (err, stats) => {
-        if (err) {
-          console.error('Error stating file:', err);
-          return;
-        }
+    tasks.push(
+      limit(async () => {
+        const outputPath = `${filePath}${config.suffix}`
+        const data = await fs.readFile(filePath, 'utf8')
 
-        if (stats.isDirectory()) {
-          // 排除指定的文件夹
-          if (excludedDirectories.includes(file)) {
-            return;
-          }
-          processFiles(filePath, fileExtensions, excludedDirectories); // 递归处理子目录
-        } else {
-          // 处理文件
-          const fileExtension = path.extname(filePath);
-          // 检查文件后缀名是否符合要求
-          if (fileExtensions.includes(fileExtension)) {
-            fs.readFile(filePath, 'utf8', (err, data) => {
-              if (err) {
-                console.error('Error reading file:', err);
-                return;
-              }
-
-              const tempFilePath = filePath + '._$_foobar';
-
-              // 写入临时文件
-              fs.writeFile(tempFilePath, data, 'utf8', err => {
-                if (err) {
-                  console.error('Error writing temp file:', err);
-                  return;
-                }
-
-                console.log('Temp file written:', tempFilePath);
-              });
-            });
-          }
+        if (config.markerFilter && !matchesAnyMarker(data, config.markers)) {
+          stats.skipped += 1
+          return
         }
-      });
-    });
-  });
-}
+
+        await fs.writeFile(outputPath, data, 'utf8')
+        console.log(`Written: ${outputPath}`)
+        stats.written += 1
+      }).catch(error => {
+        stats.failed += 1
+        console.error(`Failed: ${filePath}`)
+        console.error(error && error.message ? error.message : error)
+      })
+    )
+  })
+
+  await Promise.all(tasks)
+  console.log(`Done. written=${stats.written}, skipped=${stats.skipped}, failed=${stats.failed}`)
+  return stats
+}
+
+function createStats() {
+  return {
+    written: 0,
+    skipped: 0,
+    failed: 0
+  }
+}
+
+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

@@ -0,0 +1,158 @@
+const fs = require('fs')
+const fsp = require('fs/promises')
+const path = require('path')
+const zlib = require('zlib')
+const { once } = require('events')
+const { pipeline } = require('stream/promises')
+const { defaultConfig } = require('./config')
+const { walk } = require('./utils')
+
+async function packFiles(directory, options = {}) {
+  const config = {
+    ...defaultConfig,
+    ...options,
+    directory: path.resolve(directory || process.cwd())
+  }
+  const outputPath = resolveOutputPath(config.directory, config.out)
+  const files = []
+
+  await walk(config.directory, config, async filePath => {
+    if (path.resolve(filePath) === outputPath || filePath.endsWith(config.suffix)) {
+      return
+    }
+
+    files.push(filePath)
+  })
+
+  await fsp.rm(outputPath, { force: true })
+  await writeTarGz(config.directory, outputPath, files)
+  console.log(`Packed: ${outputPath}`)
+  console.log(`Done. files=${files.length}`)
+
+  return {
+    outputPath,
+    files: files.length
+  }
+}
+
+function resolveOutputPath(directory, out) {
+  const outputName = out ? normalizeOutputName(out) : defaultArchiveName(directory)
+  const outputPath = path.isAbsolute(outputName) ? outputName : path.join(directory, outputName)
+
+  return path.resolve(outputPath)
+}
+
+function defaultArchiveName(directory) {
+  const name = path.basename(path.resolve(directory))
+  return `${name || 'endef'}.tar.gz`
+}
+
+function normalizeOutputName(out) {
+  return `${out}.tar.gz`
+}
+
+async function writeTarGz(rootDirectory, outputPath, files) {
+  await fsp.mkdir(path.dirname(outputPath), { recursive: true })
+
+  const gzip = zlib.createGzip()
+  const output = fs.createWriteStream(outputPath)
+  const writer = writeTarEntries(rootDirectory, files, 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))
+
+    await writeFileToStream(filePath, stream)
+    await writeToStream(stream, Buffer.alloc(paddingSize(stat.size)))
+  }
+
+  stream.end(Buffer.alloc(1024))
+}
+
+async function writeFileToStream(filePath, stream) {
+  for await (const chunk of fs.createReadStream(filePath)) {
+    await writeToStream(stream, chunk)
+  }
+}
+
+async function writeToStream(stream, chunk) {
+  if (!stream.write(chunk)) {
+    await once(stream, 'drain')
+  }
+}
+
+function toArchivePath(filePath) {
+  return filePath.split(path.sep).join('/')
+}
+
+function createHeader(filePath, stat) {
+  const header = Buffer.alloc(512, 0)
+  const tarPath = splitTarPath(filePath)
+
+  writeString(header, tarPath.name, 0, 100)
+  writeOctal(header, 0o644, 100, 8)
+  writeOctal(header, 0, 108, 8)
+  writeOctal(header, 0, 116, 8)
+  writeOctal(header, stat.size, 124, 12)
+  writeOctal(header, Math.floor(stat.mtimeMs / 1000), 136, 12)
+  header.fill(0x20, 148, 156)
+  header[156] = '0'.charCodeAt(0)
+  writeString(header, 'ustar', 257, 6)
+  writeString(header, '00', 263, 2)
+  writeString(header, tarPath.prefix, 345, 155)
+
+  const checksum = header.reduce((sum, value) => sum + value, 0)
+  writeOctal(header, checksum, 148, 8)
+
+  return header
+}
+
+function splitTarPath(filePath) {
+  if (Buffer.byteLength(filePath) <= 100) {
+    return {
+      name: filePath,
+      prefix: ''
+    }
+  }
+
+  const parts = filePath.split('/')
+
+  for (let index = 1; index < parts.length; index += 1) {
+    const prefix = parts.slice(0, index).join('/')
+    const name = parts.slice(index).join('/')
+
+    if (Buffer.byteLength(prefix) <= 155 && Buffer.byteLength(name) <= 100) {
+      return { name, prefix }
+    }
+  }
+
+  throw new Error(`Tar path is too long: ${filePath}`)
+}
+
+function writeString(buffer, value, offset, length) {
+  const data = Buffer.from(value)
+
+  if (data.length > length) {
+    throw new Error(`Tar header field is too long: ${value}`)
+  }
+
+  data.copy(buffer, offset)
+}
+
+function writeOctal(buffer, value, offset, length) {
+  const data = value.toString(8).padStart(length - 1, '0') + '\0'
+  buffer.write(data, offset, length, 'ascii')
+}
+
+function paddingSize(size) {
+  const remainder = size % 512
+  return remainder === 0 ? 0 : 512 - remainder
+}
+
+module.exports = packFiles

package/src/run.js

@@ -1,12 +1,202 @@
-import enF from './en'
-import deF from './de'
+const enF = require('./en')
+const deF = require('./de')
+const packF = require('./pack')
+const { loadConfig, splitMarkers } = require('./config')
 
-export async function run(args) {
-  if (args[2] === 'en') {
-    enF(process.cwd(), ['.js', '.jsx', '.cjs', '.mjs', '.mts', '.ts', '.tsx', '.vue', '.md', '.yaml', '.type.ts', '.scss'], ['node_modules', '.git'])
+function printHelp() {
+  console.log(`Usage:
+  endef en [directory] [options]
+  endef de [directory] [options]
+  endef pack [name] [options]
+  endef all [directory] [options]
+
+Options:
+  --config <file>       Use a specific config file
+  --suffix <suffix>     Sidecar suffix, default: .endef
+  --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
+`)
+}
+
+function parseArgs(command, args) {
+  const result = {
+    directory: process.cwd(),
+    markerFilter: undefined,
+    markers: [],
+    positionals: []
+  }
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+
+    if (arg.startsWith('--suffix=')) {
+      result.suffix = arg.slice('--suffix='.length)
+      continue
+    }
+
+    if (arg === '--suffix') {
+      result.suffix = args[index + 1]
+      index += 1
+      continue
+    }
+
+    if (arg.startsWith('--config=')) {
+      result.configFile = arg.slice('--config='.length)
+      continue
+    }
+
+    if (arg === '--config') {
+      result.configFile = args[index + 1]
+      index += 1
+      continue
+    }
+
+    if (arg.startsWith('--ext=')) {
+      result.extensions = splitList(arg.slice('--ext='.length))
+      continue
+    }
+
+    if (arg === '--ext') {
+      result.extensions = splitList(args[index + 1])
+      index += 1
+      continue
+    }
+
+    if (arg.startsWith('--exclude=')) {
+      result.excludeDirs = splitList(arg.slice('--exclude='.length))
+      continue
+    }
+
+    if (arg === '--exclude') {
+      result.excludeDirs = splitList(args[index + 1])
+      index += 1
+      continue
+    }
+
+    if (arg.startsWith('--concurrency=')) {
+      result.concurrency = Number(arg.slice('--concurrency='.length))
+      continue
+    }
+
+    if (arg.startsWith('--out=')) {
+      result.out = arg.slice('--out='.length)
+      continue
+    }
+
+    if (arg === '--out') {
+      result.out = args[index + 1]
+      index += 1
+      continue
+    }
+
+    if (arg === '--concurrency') {
+      result.concurrency = Number(args[index + 1])
+      index += 1
+      continue
+    }
+
+    if (arg.startsWith('--marker=')) {
+      result.markerFilter = true
+      result.markers.push(...splitMarkers(arg.slice('--marker='.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
+      }
+
+      continue
+    }
+
+    if (!arg.startsWith('-')) {
+      result.positionals.push(arg)
+    }
+  }
+
+  applyPositionals(command, result)
+  return result
+}
+
+function applyPositionals(command, result) {
+  if (command === 'pack') {
+    result.out = result.out || result.positionals[0]
+    delete result.positionals
+    return
+  }
+
+  result.directory = result.positionals[0] || result.directory
+  delete result.positionals
+}
+
+function splitList(value) {
+  if (!value) {
+    return []
+  }
+
+  return value
+    .split(',')
+    .map(item => item.trim())
+    .filter(Boolean)
+}
+
+async function run(args) {
+  const command = args[2]
+
+  if (!command || command === '-h' || command === '--help') {
+    printHelp()
+    return
+  }
+
+  const parsed = parseArgs(command, args.slice(3))
+  const config = loadConfig(process.cwd(), parsed.configFile, parsed.directory)
+  const cliOptions = omitUndefined(parsed)
+  const options = {
+    ...config,
+    ...cliOptions,
+    directory: cliOptions.directory || config.directory || process.cwd(),
+    markers: cliOptions.markers && cliOptions.markers.length > 0 ? cliOptions.markers : config.markers
+  }
+
+  if (command === 'en') {
+    await enF(options.directory, options)
+    return
+  }
+
+  if (command === 'de') {
+    await deF(options.directory, options)
+    return
+  }
+
+  if (command === 'pack') {
+    await packF(options.directory, options)
+    return
   }
 
-  if (args[2] === 'de') {
-    deF(args[3] || 'none')
+  if (command === 'all') {
+    await enF(options.directory, options)
+    await deF(options.directory, options)
+    await packF(options.directory, options)
+    return
   }
+
+  printHelp()
+}
+
+function omitUndefined(value) {
+  return Object.keys(value).reduce((result, key) => {
+    if (value[key] !== undefined) {
+      result[key] = value[key]
+    }
+
+    return result
+  }, {})
 }
+
+module.exports = { run }

package/src/utils.js

@@ -0,0 +1,68 @@
+const fs = require('fs/promises')
+const path = require('path')
+
+async function walk(directory, config, onFile) {
+  let entries
+
+  try {
+    entries = await fs.opendir(directory)
+  } catch (error) {
+    console.error(`Cannot read directory: ${directory}`)
+    console.error(error && error.message ? error.message : error)
+    return
+  }
+
+  for await (const entry of entries) {
+    const filePath = path.join(directory, entry.name)
+
+    if (entry.isDirectory()) {
+      if (config.excludeDirs.includes(entry.name)) {
+        continue
+      }
+
+      await walk(filePath, config, onFile)
+      continue
+    }
+
+    if (entry.isFile()) {
+      await onFile(filePath)
+    }
+  }
+}
+
+function matchesExtension(filePath, extensions) {
+  const normalizedPath = filePath.toLowerCase()
+  return extensions.some(extension => normalizedPath.endsWith(extension.toLowerCase()))
+}
+
+function createLimiter(concurrency) {
+  const max = Number.isFinite(concurrency) && concurrency > 0 ? concurrency : 32
+  const queue = []
+  let active = 0
+
+  return function limit(task) {
+    return new Promise((resolve, reject) => {
+      queue.push({ task, resolve, reject })
+      runNext()
+    })
+  }
+
+  function runNext() {
+    if (active >= max || queue.length === 0) {
+      return
+    }
+
+    const item = queue.shift()
+    active += 1
+
+    Promise.resolve()
+      .then(item.task)
+      .then(item.resolve, item.reject)
+      .finally(() => {
+        active -= 1
+        runNext()
+      })
+  }
+}
+
+module.exports = { walk, matchesExtension, createLimiter }

package/src/de.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-
-# 处理文件名并重命名
-process_filename() {
-  local file=$1
-  local filename=$(basename "$file")
-  local dir=$(dirname "$file")
-
-  # 判断文件名是否以指定字符串结尾
-  if [[ $filename =~ \._\$_foobar$ ]]; then
-    local new_filename=${filename%%._$_foobar*}  # 移除指定字符串
-    local new_path="$dir/$new_filename"  # 构建新的文件路径
-
-    # 判断新文件名对应的文件是否存在
-    if [[ -f "$new_path" ]]; then
-      if grep -q "E-SafeNet" "$new_path" || [[ $2 == "over" ]]; then
-        rm "$new_path"  # 删除包含特定内容的文件
-        mv "$file" "$new_path"  # 重命名文件
-        echo "Renamed: $filename -> $new_filename"
-      else
-        rm "$file"  # 删除不包含特定内容的文件
-        echo "Deleted: $filename"
-      fi
-    fi
-  fi
-}
-
-# 指定目标目录
-directory="$1"  # 替换为您的目录路径
-
-# 导出函数以便在并行处理中使用
-export -f process_filename
-
-# 处理文件名并重命名（并行处理）
-find "$directory" -type f -print0 | \
-  xargs -0 -P "$(nproc)" -I{} bash -c 'process_filename "$@"' _ {} "$2"