@bash0816/claude-code 2.1.150 → 2.1.153-2

package/lib/termux-run-claude-native.sh

@@ -6,7 +6,6 @@ WORKDIR="${WORKDIR:-${HOME}/.claude-termux-native-package/launcher-workdir}"
 ENTRY_JS_OFFSET="${ENTRY_JS_OFFSET:?ENTRY_JS_OFFSET is required}"
 ENTRY_END_OFFSET="${ENTRY_END_OFFSET:?ENTRY_END_OFFSET is required}"
 CURRENT_CLAUDE_VERSION="${CURRENT_CLAUDE_VERSION:?CURRENT_CLAUDE_VERSION is required}"
-CLAUDE_TERMUX_PACKAGE_DIR="${CLAUDE_TERMUX_PACKAGE_DIR:?CLAUDE_TERMUX_PACKAGE_DIR is required}"
 TERMUX_TMPDIR="${TMPDIR:-/data/data/com.termux/files/usr/tmp}"
 SSL_CERT_DIR="${SSL_CERT_DIR:-/data/data/com.termux/files/usr/etc/tls}"
 SSL_CERT_FILE="${SSL_CERT_FILE:-/data/data/com.termux/files/usr/etc/tls/cert.pem}"
@@ -43,10 +42,6 @@ export CURRENT_CLAUDE_VERSION
 node - "$@" <<'NODE'
 const fs = require('fs');
 const path = require('path');
-const {
-  BLOCK_MESSAGE,
-  createGuardedChildProcess,
-} = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'native-update-guard.js'));
 
 const sourceBin = process.env.SOURCE_BIN;
 const workdir = process.env.WORKDIR;
@@ -78,20 +73,8 @@ function ensureEntryFile() {
   return extractedFile;
 }
 
-function stringWidth(value) {
-  const text = String(value ?? '');
-  if (typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function') {
-    const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
-    let width = 0;
-    for (const _segment of segmenter.segment(text)) width += 1;
-    return width;
-  }
-  return Array.from(text).length;
-}
-
 function createFakeRequire(realRequire) {
   const realChild = realRequire('child_process');
-
   function rewriteArgs(args) {
     if (
       Array.isArray(args) &&
@@ -104,18 +87,6 @@ function createFakeRequire(realRequire) {
     return args;
   }
 
-  const guardedChild = createGuardedChildProcess(
-    {
-      spawn: (...args) => realChild.spawn(...rewriteArgs(args)),
-      execFile: (...args) => realChild.execFile(...args),
-      exec: (...args) => realChild.exec(...args),
-      spawnSync: (...args) => realChild.spawnSync(...rewriteArgs(args)),
-      execFileSync: (...args) => realChild.execFileSync(...args),
-      execSync: (...args) => realChild.execSync(...args),
-    },
-    value => process.stderr.write(value),
-  );
-
   return function fakeRequire(id) {
     if (id === 'ws') {
       class WS {
@@ -130,11 +101,14 @@ function createFakeRequire(realRequire) {
     }
 
     if (id === 'child_process') {
-      return guardedChild;
-    }
-
-    if (id === 'node:child_process') {
-      return guardedChild;
+      return {
+        spawn: (...args) => realChild.spawn(...rewriteArgs(args)),
+        execFile: (...args) => realChild.execFile(...args),
+        exec: (...args) => realChild.exec(...args),
+        spawnSync: (...args) => realChild.spawnSync(...rewriteArgs(args)),
+        execFileSync: (...args) => realChild.execFileSync(...args),
+        execSync: (...args) => realChild.execSync(...args),
+      };
     }
 
     if (id.startsWith('/$bunfs/root/')) {
@@ -145,6 +119,318 @@ function createFakeRequire(realRequire) {
   };
 }
 
+function createBunShim() {
+  const childProcess = require('child_process');
+  const crypto = require('crypto');
+  const net = require('net');
+  const os = require('os');
+  const ansiPattern =
+    /[\u001B\u009B][[\]()#;?]*(?:(?:(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d\/#&.:=?%@~_]*)*)?(?:\u0007|\u001B\u005C|\u009C)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+
+  function stripANSI(value) {
+    if (typeof value !== 'string' || value.length === 0) return '';
+    return value.replace(ansiPattern, '');
+  }
+
+  function isZeroWidth(codePoint) {
+    return (
+      codePoint <= 0x1f ||
+      (codePoint >= 0x7f && codePoint <= 0x9f) ||
+      (codePoint >= 0x300 && codePoint <= 0x36f) ||
+      (codePoint >= 0x200b && codePoint <= 0x200f) ||
+      codePoint === 0xfeff ||
+      (codePoint >= 0xfe00 && codePoint <= 0xfe0f)
+    );
+  }
+
+  function isWide(codePoint) {
+    return (
+      (codePoint >= 0x1100 && codePoint <= 0x115f) ||
+      (codePoint >= 0x2329 && codePoint <= 0x232a) ||
+      (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+      (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+      (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+      (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+      (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+      (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+      (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+      (codePoint >= 0x1f300 && codePoint <= 0x1faf8) ||
+      (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+    );
+  }
+
+  function stringWidth(value) {
+    const text = stripANSI(typeof value === 'string' ? value : String(value ?? ''));
+    let width = 0;
+    for (const char of text) {
+      const codePoint = char.codePointAt(0);
+      if (isZeroWidth(codePoint)) continue;
+      width += isWide(codePoint) ? 2 : 1;
+    }
+    return width;
+  }
+
+  function normalizeInput(value) {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) return Buffer.from(value);
+    if (typeof value === 'string') return Buffer.from(value);
+    return Buffer.from(String(value ?? ''));
+  }
+
+  function hash(value) {
+    const digest = crypto.createHash('sha256').update(normalizeInput(value)).digest();
+    return digest.readUInt32LE(0);
+  }
+
+  function which(command) {
+    if (typeof command !== 'string' || command.length === 0) return null;
+    const pathValue = process.env.PATH || '';
+    const separator = os.platform() === 'win32' ? ';' : ':';
+    for (const entry of pathValue.split(separator)) {
+      if (!entry) continue;
+      const candidate = path.join(entry, command);
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+      } catch {}
+    }
+    return null;
+  }
+
+  function spawn(argv, options = {}) {
+    if (!Array.isArray(argv) || argv.length === 0) {
+      throw new TypeError('Bun.spawn expects a non-empty argv array');
+    }
+    const [command, ...args] = argv;
+    const terminal = options.terminal || null;
+
+    function resolveStdio(val, fallback) {
+      if (val === 'ignore' || val === 'inherit' || val === 'pipe') return val;
+      return fallback;
+    }
+
+    let stdioSpec;
+    if (terminal) {
+      stdioSpec = ['pipe', 'pipe', 'pipe'];
+    } else if (Array.isArray(options.stdio)) {
+      stdioSpec = options.stdio.map(s => resolveStdio(s, 'pipe'));
+    } else {
+      stdioSpec = [
+        resolveStdio(options.stdin, 'pipe'),
+        resolveStdio(options.stdout, 'pipe'),
+        resolveStdio(options.stderr, 'pipe'),
+      ];
+    }
+
+    const nodeChild = childProcess.spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      detached: options.detached,
+      windowsHide: options.windowsHide,
+      stdio: stdioSpec,
+    });
+
+    if (terminal) {
+      const fireData = chunk => {
+        if (!terminal._closed && terminal._options && typeof terminal._options.data === 'function') {
+          terminal._options.data(terminal, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+      };
+      nodeChild.stdout?.on('data', fireData);
+      nodeChild.stderr?.on('data', fireData);
+      const origWrite = terminal.write.bind(terminal);
+      terminal.write = data => {
+        if (nodeChild.stdin && !nodeChild.stdin.destroyed) {
+          nodeChild.stdin.write(Buffer.isBuffer(data) ? data : Buffer.from(data));
+        }
+        return origWrite(data);
+      };
+    }
+
+    nodeChild.exited = new Promise(resolve => {
+      nodeChild.once('exit', (code, signal) => resolve(code != null ? code : (signal ? 1 : 0)));
+    });
+
+    function makeTextReader(stream) {
+      return {
+        text() {
+          return new Promise((resolve, reject) => {
+            if (!stream) return resolve('');
+            const chunks = [];
+            stream.on('data', chunk => chunks.push(chunk));
+            stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+            stream.on('error', reject);
+          });
+        },
+      };
+    }
+    if (nodeChild.stdout) Object.assign(nodeChild.stdout, makeTextReader(nodeChild.stdout));
+    if (nodeChild.stderr) Object.assign(nodeChild.stderr, makeTextReader(nodeChild.stderr));
+    return nodeChild;
+  }
+
+  class TerminalShim {
+    constructor(options = {}) {
+      this._options = options;
+      this._cols = options.cols || 80;
+      this._rows = options.rows || 24;
+      this._closed = false;
+    }
+    write(data) {
+      if (this._closed) return;
+      if (this._options.data) this._options.data(this, Buffer.isBuffer(data) ? data : Buffer.from(data));
+    }
+    resize(cols, rows) {
+      this._cols = cols;
+      this._rows = rows;
+    }
+    close() {
+      this._closed = true;
+    }
+  }
+
+  function listen(options) {
+    const sockets = new Set();
+    const server = net.createServer(socket => {
+      sockets.add(socket);
+      const connection = {
+        data: undefined,
+        write(chunk) {
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          const ok = socket.write(buffer);
+          return ok ? buffer.length : 0;
+        },
+        end(chunk) {
+          socket.end(chunk);
+        },
+        destroy(error) {
+          socket.destroy(error);
+        },
+      };
+      socket.on('data', chunk => {
+        if (options.socket && typeof options.socket.data === 'function') {
+          options.socket.data(connection, chunk);
+        }
+      });
+      socket.on('drain', () => {
+        if (options.socket && typeof options.socket.drain === 'function') {
+          options.socket.drain(connection);
+        }
+      });
+      socket.on('close', () => {
+        sockets.delete(socket);
+        if (options.socket && typeof options.socket.close === 'function') {
+          options.socket.close(connection);
+        }
+      });
+      socket.on('error', error => {
+        if (options.socket && typeof options.socket.error === 'function') {
+          options.socket.error(connection, error);
+        }
+      });
+      if (options.socket && typeof options.socket.open === 'function') {
+        options.socket.open(connection);
+      }
+    });
+
+    server.listen(options.port || 0, options.hostname || '127.0.0.1');
+
+    return {
+      get port() {
+        const address = server.address();
+        return address && typeof address === 'object' ? address.port : 0;
+      },
+      stop(closeConnections) {
+        server.close();
+        if (closeConnections) {
+          for (const socket of sockets) socket.destroy();
+        }
+      },
+    };
+  }
+
+  const semver = {
+    order(left, right) {
+      const leftParts = String(left).replace(/^[^0-9]*/, '').split('.').map(Number);
+      const rightParts = String(right).replace(/^[^0-9]*/, '').split('.').map(Number);
+      const size = Math.max(leftParts.length, rightParts.length);
+      for (let index = 0; index < size; index += 1) {
+        const diff = (leftParts[index] || 0) - (rightParts[index] || 0);
+        if (diff !== 0) return diff > 0 ? 1 : -1;
+      }
+      return 0;
+    },
+    satisfies(version, range) {
+      const v = String(version).replace(/^[^0-9]*/, '');
+      const clean = String(range).trim();
+      const match = clean.match(/^([><=!^~]+)\s*([0-9][^\s]*)/);
+      if (!match) return true;
+      const [, op, rv] = match;
+      const cmp = semver.order(v, rv);
+      if (op === '>=' || op === '=>') return cmp >= 0;
+      if (op === '>') return cmp > 0;
+      if (op === '<=' || op === '=<') return cmp <= 0;
+      if (op === '<') return cmp < 0;
+      if (op === '==' || op === '=') return cmp === 0;
+      if (op === '!=') return cmp !== 0;
+      return true;
+    },
+  };
+
+  const YAML = {
+    parse(text) {
+      try {
+        const lines = String(text).split('\n');
+        const result = {};
+        for (const line of lines) {
+          const m = line.match(/^([^:#]+):\s*(.*)$/);
+          if (m) result[m[1].trim()] = m[2].trim().replace(/^["']|["']$/g, '');
+        }
+        return result;
+      } catch { return {}; }
+    },
+    stringify(obj) {
+      try {
+        return Object.entries(obj || {}).map(([k, v]) => `${k}: ${v}`).join('\n') + '\n';
+      } catch { return ''; }
+    },
+  };
+
+  class Transpiler {
+    constructor(_options) {}
+    transformSync(code) { return typeof code === 'string' ? code : ''; }
+    scanImports(code) {
+      const imports = [];
+      const reStatic = /(?:^|[^.])import\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/gm;
+      const reDynamic = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      const reRequire = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      let m;
+      while ((m = reStatic.exec(String(code))) !== null) imports.push({ path: m[1], kind: 'import-statement' });
+      while ((m = reDynamic.exec(String(code))) !== null) imports.push({ path: m[1], kind: 'dynamic-import' });
+      while ((m = reRequire.exec(String(code))) !== null) imports.push({ path: m[1], kind: 'require-call' });
+      return imports;
+    }
+  }
+
+  return {
+    version: '1.1.8',
+    embeddedFiles: [],
+    gc: typeof global.gc === 'function' ? () => global.gc() : () => {},
+    generateHeapSnapshot: () => Buffer.alloc(0),
+    hash,
+    listen,
+    semver,
+    spawn,
+    stdin: process.stdin,
+    stripANSI,
+    stringWidth,
+    Terminal: TerminalShim,
+    Transpiler,
+    which,
+    wrapAnsi: value => String(value ?? ''),
+    YAML,
+  };
+}
+
 async function main() {
   const extractedFile = ensureEntryFile();
   const code = fs.readFileSync(extractedFile, 'utf8');
@@ -166,7 +452,7 @@ async function main() {
     process.once('uncaughtException', onAsyncError);
     process.once('unhandledRejection', onAsyncError);
     Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
-    globalThis.Bun = { version: '1.1.8', stringWidth };
+    globalThis.Bun = createBunShim();
     process.argv = ['node', extractedFile, ...argv];
     process.exit = code => {
       throw new RequestedExit(code);
@@ -201,10 +487,6 @@ async function main() {
 }
 
 main().catch(error => {
-  if (error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED') {
-    console.error(BLOCK_MESSAGE);
-    process.exit(error.status || 1);
-  }
   console.error(error && error.stack ? error.stack : String(error));
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.150",
+  "version": "2.1.153-2",
   "description": "Termux-native Claude Code wrapper with audited native replay",
   "license": "MIT",
   "bin": {
@@ -17,6 +17,6 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   }
 }

package/lib/native-update-guard.js

@@ -1,257 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const EventEmitter = require('events');
-
-const OFFICIAL_PACKAGE = '@anthropic-ai/claude-code';
-const BLOCK_MESSAGE = [
-  'Official native self-update is disabled on Termux.',
-  'Run: claude update',
-].join('\n');
-
-function lastPathSegment(value) {
-  return String(value || '').replace(/\\/g, '/').split('/').pop();
-}
-
-function isNpmCommand(command) {
-  const text = String(command || '');
-  const leaf = lastPathSegment(text);
-  return leaf === 'npm' || leaf === 'npm-cli.js';
-}
-
-function isPnpmCommand(command) {
-  return lastPathSegment(command) === 'pnpm';
-}
-
-function isYarnCommand(command) {
-  const leaf = lastPathSegment(command);
-  return leaf === 'yarn' || leaf === 'yarnpkg';
-}
-
-function isNpxCommand(command) {
-  const leaf = lastPathSegment(command);
-  return leaf === 'npx' || leaf === 'pnpx';
-}
-
-function isEnvCommand(command) {
-  return lastPathSegment(command) === 'env';
-}
-
-function isCorepackCommand(command) {
-  return lastPathSegment(command) === 'corepack';
-}
-
-function isShellCommand(command) {
-  const leaf = lastPathSegment(command);
-  return leaf === 'sh' || leaf === 'bash';
-}
-
-function isSupportedOperation(value) {
-  return ['install', 'i', 'add', 'update', 'up', 'upgrade'].includes(String(value || ''));
-}
-
-function isOfficialTarget(value) {
-  return String(value || '') === OFFICIAL_PACKAGE || String(value || '').startsWith(`${OFFICIAL_PACKAGE}@`);
-}
-
-function normalizeCommand(command, args) {
-  let normalizedCommand = command;
-  let normalizedArgs = Array.isArray(args) ? args.slice() : [];
-
-  if (isEnvCommand(normalizedCommand)) {
-    while (normalizedArgs.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(String(normalizedArgs[0]))) {
-      normalizedArgs.shift();
-    }
-    if (normalizedArgs.length === 0) return { command: normalizedCommand, args: normalizedArgs };
-    normalizedCommand = normalizedArgs.shift();
-  }
-
-  if (isCorepackCommand(normalizedCommand)) {
-    if (normalizedArgs.length === 0) return { command: normalizedCommand, args: normalizedArgs };
-    normalizedCommand = normalizedArgs.shift();
-  }
-
-  return { command: normalizedCommand, args: normalizedArgs };
-}
-
-function hasOfficialTarget(args) {
-  return args.some(isOfficialTarget);
-}
-
-function shouldBlockNpmLike(command, args) {
-  if (!(isNpmCommand(command) || isPnpmCommand(command))) return false;
-  if (!args.find(isSupportedOperation)) return false;
-  return hasOfficialTarget(args);
-}
-
-function shouldBlockYarn(command, args) {
-  if (!isYarnCommand(command)) return false;
-  return String(args[0] || '') === 'global' && String(args[1] || '') === 'add' && hasOfficialTarget(args.slice(2));
-}
-
-function shouldBlockNpx(command, args) {
-  if (!isNpxCommand(command)) return false;
-  for (let index = 0; index < args.length; index += 1) {
-    const token = String(args[index] || '');
-    if (token === '-p' || token === '--package') {
-      if (isOfficialTarget(args[index + 1])) return true;
-      index += 1;
-      continue;
-    }
-    if (token.startsWith('--package=')) {
-      if (isOfficialTarget(token.slice('--package='.length))) return true;
-      continue;
-    }
-    if (!token.startsWith('-')) {
-      return isOfficialTarget(token);
-    }
-  }
-  return false;
-}
-
-function shouldBlockCommand(command, args) {
-  if (!Array.isArray(args)) return false;
-  const normalized = normalizeCommand(command, args);
-  return (
-    shouldBlockNpmLike(normalized.command, normalized.args) ||
-    shouldBlockYarn(normalized.command, normalized.args) ||
-    shouldBlockNpx(normalized.command, normalized.args)
-  );
-}
-
-function normalizeTokensForExec(tokens) {
-  if (tokens.length === 0) return tokens;
-  const normalized = normalizeCommand(tokens[0], tokens.slice(1));
-  return [normalized.command, ...normalized.args].filter(value => value !== undefined);
-}
-
-function unwrapShellCommand(command, args) {
-  if (!isShellCommand(command) || !Array.isArray(args) || args.length < 2) return null;
-  const first = String(args[0] || '');
-  const second = String(args[1] || '');
-  if ((first === '-c' || first === '-lc') && second) return second;
-  if (first === '-l' && String(args[1] || '') === '-c' && String(args[2] || '')) return String(args[2]);
-  return null;
-}
-
-function tokenizeShellString(command) {
-  const text = String(command || '').trim();
-  if (!text) return [];
-  return text.match(/(?:[^\s'"]+|'[^']*'|"[^"]*")+/g) || [];
-}
-
-function unquote(token) {
-  if (
-    (token.startsWith('"') && token.endsWith('"')) ||
-    (token.startsWith("'") && token.endsWith("'"))
-  ) {
-    return token.slice(1, -1);
-  }
-  return token;
-}
-
-function shouldBlockExecString(command) {
-  const tokens = normalizeTokensForExec(tokenizeShellString(command).map(unquote));
-  if (tokens.length === 0) return false;
-  const shellInner = unwrapShellCommand(tokens[0], tokens.slice(1));
-  if (shellInner) return shouldBlockExecString(shellInner);
-  return shouldBlockCommand(tokens[0], tokens.slice(1));
-}
-
-function createBlockedError(blockedStderr) {
-  const error = new Error(BLOCK_MESSAGE);
-  error.code = 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED';
-  error.status = 1;
-  error.stdout = Buffer.from('');
-  error.stderr = Buffer.from(blockedStderr);
-  return error;
-}
-
-function createBlockedSpawn(blockedStderr, stderrWriter, options) {
-  const child = new EventEmitter();
-  child.stdout = null;
-  child.stderr = null;
-  child.stdin = null;
-  child.pid = 0;
-  child.killed = false;
-  child.kill = () => false;
-  process.nextTick(() => {
-    if (!(options && options.stdio === 'ignore')) {
-      stderrWriter(blockedStderr);
-    }
-    child.emit('close', 1, null);
-    child.emit('exit', 1, null);
-  });
-  return child;
-}
-
-function createBlockedSpawnSync(blockedStderr, stderrWriter) {
-  stderrWriter(blockedStderr);
-  return {
-    pid: 0,
-    output: [null, Buffer.from(''), Buffer.from(blockedStderr)],
-    stdout: Buffer.from(''),
-    stderr: Buffer.from(blockedStderr),
-    status: 1,
-    signal: null,
-    error: createBlockedError(blockedStderr),
-  };
-}
-
-function createBlockedExecResult(blockedStderr, stderrWriter, callback) {
-  const child = createBlockedSpawn(blockedStderr, stderrWriter);
-  const error = createBlockedError(blockedStderr);
-  process.nextTick(() => {
-    if (typeof callback === 'function') {
-      callback(error, '', blockedStderr);
-    }
-  });
-  return child;
-}
-
-function shouldBlockSpawnArgs(args) {
-  if (!Array.isArray(args) || args.length === 0) return false;
-  const command = args[0];
-  const commandArgs = Array.isArray(args[1]) ? args[1] : [];
-  const shellInner = unwrapShellCommand(command, commandArgs);
-  if (shellInner) return shouldBlockExecString(shellInner);
-  return shouldBlockCommand(command, commandArgs);
-}
-
-function createGuardedChildProcess(realChild, stderrWriter = value => process.stderr.write(value)) {
-  const blockedStderr = `${BLOCK_MESSAGE}\n`;
-  return {
-    spawn: (...args) => {
-      if (shouldBlockSpawnArgs(args)) return createBlockedSpawn(blockedStderr, stderrWriter, args[2]);
-      return realChild.spawn(...args);
-    },
-    execFile: (...args) => {
-      if (shouldBlockSpawnArgs(args)) return createBlockedExecResult(blockedStderr, stderrWriter, args[args.length - 1]);
-      return realChild.execFile(...args);
-    },
-    exec: (...args) => {
-      if (shouldBlockExecString(args[0])) return createBlockedExecResult(blockedStderr, stderrWriter, args[args.length - 1]);
-      return realChild.exec(...args);
-    },
-    spawnSync: (...args) => {
-      if (shouldBlockSpawnArgs(args)) return createBlockedSpawnSync(blockedStderr, stderrWriter);
-      return realChild.spawnSync(...args);
-    },
-    execFileSync: (...args) => {
-      if (shouldBlockSpawnArgs(args)) throw createBlockedError(blockedStderr);
-      return realChild.execFileSync(...args);
-    },
-    execSync: (...args) => {
-      if (shouldBlockExecString(args[0])) throw createBlockedError(blockedStderr);
-      return realChild.execSync(...args);
-    },
-  };
-}
-
-module.exports = {
-  BLOCK_MESSAGE,
-  OFFICIAL_PACKAGE,
-  createGuardedChildProcess,
-  shouldBlockCommand,
-  shouldBlockExecString,
-};