@bash0816/claude-code 2.1.159-9 → 2.1.161-1

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

@@ -6,6 +6,7 @@ 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}"
@@ -39,9 +40,24 @@ export ENTRY_JS_OFFSET
 export ENTRY_END_OFFSET
 export CURRENT_CLAUDE_VERSION
 
-node - "$@" <<'NODE'
+_pf=0
+for _a in "$@"; do
+  case "$_a" in
+    -p|--print) _pf=1; break ;;
+    --) break ;;
+  esac
+done
+
+if [ "$_pf" = "1" ] && [ "${CLAUDE_TERMUX_STDIN:-}" != "inherit" ]; then
+  _helper=$(mktemp "${TMPDIR:-/tmp}/claude-helper.XXXXXX.js")
+  trap 'rm -f "$_helper"' EXIT HUP INT TERM
+  cat <<'NODE' > "$_helper"
 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;
@@ -59,8 +75,6 @@ class RequestedExit extends Error {
 
 function ensureEntryFile() {
   const extractedFile = path.join(workdir, `cli.${entryJsOffset}.${entryEndOffset}.bare-path.js`);
-  if (fs.existsSync(extractedFile)) return extractedFile;
-
   const len = entryEndOffset - entryJsOffset;
   if (!(len > 0)) throw new Error('invalid replay offsets');
 
@@ -73,13 +87,157 @@ 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 parseScalar(value) {
+  const text = String(value ?? '').trim();
+  if (text === '') return '';
+  if (text === 'true') return true;
+  if (text === 'false') return false;
+  if (text === 'null' || text === '~') return null;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(text)) return Number(text);
+  if (
+    (text.startsWith('"') && text.endsWith('"')) ||
+    (text.startsWith("'") && text.endsWith("'"))
+  ) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function parseInlineArray(value) {
+  const inner = String(value ?? '').trim().slice(1, -1).trim();
+  if (inner === '') return [];
+  const items = [];
+  let current = '';
+  let quote = null;
+
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i];
+    if (quote) {
+      if (ch === quote && inner[i - 1] !== '\\') quote = null;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ',') {
+      items.push(parseScalar(current));
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current !== '') items.push(parseScalar(current));
+  return items;
+}
+
+function yamlParse(text) {
+  const source = String(text ?? '');
+  const result = {};
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const idx = line.indexOf(':');
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    const rawValue = line.slice(idx + 1).trim();
+    if (!key) continue;
+    result[key] = rawValue.startsWith('[') && rawValue.endsWith(']')
+      ? parseInlineArray(rawValue)
+      : parseScalar(rawValue);
+  }
+  return result;
+}
+
+function yamlStringify(value) {
+  if (!value || typeof value !== 'object') return String(value ?? '');
+  const lines = [];
+  for (const [key, raw] of Object.entries(value)) {
+    if (Array.isArray(raw)) {
+      lines.push(`${key}: [${raw.map(item => JSON.stringify(String(item))).join(', ')}]`);
+    } else if (raw === null) {
+      lines.push(`${key}: null`);
+    } else if (typeof raw === 'string') {
+      lines.push(`${key}: ${JSON.stringify(raw)}`);
+    } else {
+      lines.push(`${key}: ${String(raw)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+function createYamlShim() {
+  const yaml = {
+    parse: yamlParse,
+    stringify: yamlStringify,
+  };
+  yaml.YAML = yaml;
+  yaml.default = yaml;
+  return yaml;
+}
+
 function createFakeRequire(realRequire) {
+  const realChild = realRequire('child_process');
   const realVm = realRequire('vm');
 
   function injectBunIntoContext(context) {
     if (!context || typeof context !== 'object') return context;
     try {
-      if (!Object.prototype.hasOwnProperty.call(context, 'Bun')) {
+      if (!Object.prototype.hasOwnProperty.call(context, '__claudeYaml')) {
+        Object.defineProperty(context, '__claudeYaml', {
+          value: globalThis.__claudeYaml,
+          configurable: true,
+          writable: true,
+        });
+      }
+      if (!Object.prototype.hasOwnProperty.call(context, '__claudeBunShim')) {
+        Object.defineProperty(context, '__claudeBunShim', {
+          value: globalThis.__claudeBunShim,
+          configurable: true,
+          writable: true,
+        });
+      }
+      if (!Object.prototype.hasOwnProperty.call(context, '__claudeBun')) {
+        Object.defineProperty(context, '__claudeBun', {
+          value: globalThis.__claudeBunShim,
+          configurable: true,
+          writable: true,
+        });
+      }
+      if (Object.prototype.hasOwnProperty.call(context, 'Bun')) {
+        if (context.Bun && typeof context.Bun === 'object' && context.Bun !== globalThis.Bun) {
+          try {
+            context.Bun = globalThis.Bun;
+          } catch {
+            Object.defineProperty(context, 'Bun', {
+              value: globalThis.Bun,
+              configurable: true,
+              writable: true,
+            });
+          }
+        }
+        if (!context.Bun || typeof context.Bun !== 'object') {
+          Object.defineProperty(context, 'Bun', {
+            value: globalThis.Bun,
+            configurable: true,
+            writable: true,
+          });
+        }
+      } else {
         Object.defineProperty(context, 'Bun', {
           value: globalThis.Bun,
           configurable: true,
@@ -90,23 +248,6 @@ function createFakeRequire(realRequire) {
     return context;
   }
 
-  if (!realVm.__bunShimPatched) {
-    const origCreateContext = realVm.createContext.bind(realVm);
-    const origRunInNewContext = realVm.runInNewContext.bind(realVm);
-    realVm.createContext = (ctx, ...rest) => origCreateContext(injectBunIntoContext(ctx), ...rest);
-    realVm.runInNewContext = (code, ctx, ...rest) => origRunInNewContext(code, injectBunIntoContext(ctx), ...rest);
-    const ScriptProto = realVm.Script && realVm.Script.prototype;
-    if (ScriptProto && !ScriptProto.__bunShimPatched) {
-      const origRunInContext = ScriptProto.runInContext;
-      const origRunInNewCtx = ScriptProto.runInNewContext;
-      ScriptProto.runInContext = function(ctx, ...rest) { return origRunInContext.call(this, injectBunIntoContext(ctx), ...rest); };
-      ScriptProto.runInNewContext = function(ctx, ...rest) { return origRunInNewCtx.call(this, injectBunIntoContext(ctx), ...rest); };
-      Object.defineProperty(ScriptProto, '__bunShimPatched', { value: true });
-    }
-    Object.defineProperty(realVm, '__bunShimPatched', { value: true });
-  }
-
-  const realChild = realRequire('child_process');
   function rewriteArgs(args) {
     if (
       Array.isArray(args) &&
@@ -119,6 +260,18 @@ 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 {
@@ -132,18 +285,56 @@ function createFakeRequire(realRequire) {
       return { default: WS, WebSocket: WS };
     }
 
+    if (id === 'vm' || id === 'node:vm') {
+      if (!realVm.__claudeBunShimPatched) {
+        const originalCreateContext = realVm.createContext.bind(realVm);
+        const originalRunInNewContext = realVm.runInNewContext.bind(realVm);
+        const originalRunInContext = realVm.runInContext.bind(realVm);
+        const originalRunInThisContext = realVm.runInThisContext && realVm.runInThisContext.bind(realVm);
+        const scriptProto = realVm.Script && realVm.Script.prototype;
+
+        realVm.createContext = (contextObject, ...rest) =>
+          originalCreateContext(injectBunIntoContext(contextObject), ...rest);
+        realVm.runInNewContext = (code, contextObject, ...rest) =>
+          originalRunInNewContext(code, injectBunIntoContext(contextObject), ...rest);
+        realVm.runInContext = (code, contextObject, ...rest) =>
+          originalRunInContext(code, injectBunIntoContext(contextObject), ...rest);
+        if (originalRunInThisContext) {
+          realVm.runInThisContext = (code, ...rest) => originalRunInThisContext(code, ...rest);
+        }
+
+        if (scriptProto && !scriptProto.__claudeBunShimPatched) {
+          const originalScriptRunInContext = scriptProto.runInContext;
+          const originalScriptRunInNewContext = scriptProto.runInNewContext;
+          const originalScriptRunInThisContext = scriptProto.runInThisContext;
+
+          scriptProto.runInContext = function (contextObject, ...rest) {
+            return originalScriptRunInContext.call(this, injectBunIntoContext(contextObject), ...rest);
+          };
+          scriptProto.runInNewContext = function (contextObject, ...rest) {
+            return originalScriptRunInNewContext.call(this, injectBunIntoContext(contextObject), ...rest);
+          };
+          if (originalScriptRunInThisContext) {
+            scriptProto.runInThisContext = function (...rest) {
+              return originalScriptRunInThisContext.call(this, ...rest);
+            };
+          }
+
+          Object.defineProperty(scriptProto, '__claudeBunShimPatched', { value: true });
+        }
+
+        Object.defineProperty(realVm, '__claudeBunShimPatched', { value: true });
+      }
+      return realVm;
+    }
+
     if (id === 'child_process') {
-      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),
-      };
+      return guardedChild;
     }
 
-    if (id === 'vm') return realVm;
+    if (id === 'node:child_process') {
+      return guardedChild;
+    }
 
     if (id.startsWith('/$bunfs/root/')) {
       throw new Error('bunfs require blocked: ' + id);
@@ -153,511 +344,411 @@ function createFakeRequire(realRequire) {
   };
 }
 
-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;
-const ansiPatternSingle = new RegExp(ansiPattern.source);
-const debugBunShim = process.env.CLAUDE_TERMUX_DEBUG_BUN_SHIM === '1';
+async function main() {
+  const extractedFile = ensureEntryFile();
+  const code = fs.readFileSync(extractedFile, 'utf8');
+  const patchedCode = code.replace(
+    /^function\(exports, require, module, __filename, __dirname\) \{/,
+    'function(exports, require, module, __filename, __dirname) {var __claudeBun = globalThis.__claudeBunShim;',
+  ).replace(
+    /\btypeof Bun\b/g,
+    'typeof __claudeBun',
+  ).replace(
+    /\bBun\./g,
+    '__claudeBun.',
+  ).replace(
+    /function t5q\(q\)\{return Bun\.YAML\.parse\(q\)\}/g,
+    'function t5q(q){return globalThis.__claudeYaml.parse(q)}',
+  ).replace(
+    /function VK6\(q\)\{return Bun\.YAML\.stringify\(q,null,2\)\+`/g,
+    'function VK6(q){return globalThis.__claudeYaml.stringify(q,null,2)+`',
+  );
+  const fn = eval('(' + patchedCode.replace(/\)\s*$/, '') + ')');
 
-function stripANSI(text) {
-  if (typeof text !== 'string' || text.length === 0) return '';
-  return text.replace(ansiPattern, '');
-}
+  const originalArgv = process.argv.slice();
+  const originalExit = process.exit;
+  const originalBun = process.versions.bun;
+  const hadGlobalBun = Object.prototype.hasOwnProperty.call(globalThis, 'Bun');
+  const originalGlobalBun = globalThis.Bun;
+  const asyncErrors = [];
 
-function codePointWidth(codePoint) {
-  if (
-    codePoint <= 0x1f ||
-    (codePoint >= 0x7f && codePoint <= 0x9f) ||
-    (codePoint >= 0x300 && codePoint <= 0x36f) ||
-    (codePoint >= 0x200b && codePoint <= 0x200f) ||
-    codePoint === 0xfeff ||
-    (codePoint >= 0xfe00 && codePoint <= 0xfe0f)
-  ) {
-    return 0;
+  globalThis.__claudeYaml = createYamlShim();
+  if (!globalThis.__claudeBunShim || typeof globalThis.__claudeBunShim !== 'object') {
+    globalThis.__claudeBunShim = {};
   }
-
-  if (
-    (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)
-  ) {
-    return 2;
+  const fakeRequire = createFakeRequire(require);
+  function onAsyncError(error) {
+    asyncErrors.push(error);
   }
 
-  return 1;
-}
+  try {
+    process.once('uncaughtException', onAsyncError);
+    process.once('unhandledRejection', onAsyncError);
+    Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
+    const _realChild = require('child_process');
+    globalThis.Bun = {
+      version: '1.1.8',
+      stringWidth,
+      which: (cmd) => {
+        try {
+          return _realChild.execFileSync('which', [String(cmd)], { encoding: 'utf8' }).trim() || null;
+        } catch { return null; }
+      },
+      semver: (() => {
+        const _cmp = (a, b) => {
+          const pa = String(a).replace(/[^0-9.]/g,'').split('.').map(Number);
+          const pb = String(b).replace(/[^0-9.]/g,'').split('.').map(Number);
+          for (let i = 0; i < 3; i++) { const d = (pa[i]||0)-(pb[i]||0); if (d) return d > 0 ? 1 : -1; }
+          return 0;
+        };
+        const _satisfies = (ver, range) => {
+          const s = String(range).trim();
+          const m = s.match(/^([><=!]{1,2})\s*([\d]+(?:\.[\d]+){0,2})$/);
+          if (m) {
+            const op = m[1], c = _cmp(ver, m[2]);
+            if (op === '>') return c > 0;
+            if (op === '>=') return c >= 0;
+            if (op === '<') return c < 0;
+            if (op === '<=') return c <= 0;
+            if (op === '=' || op === '==') return c === 0;
+            if (op === '!=') return c !== 0;
+          }
+          if (/^[\d]+(?:\.[\d]+){0,2}$/.test(s)) return _cmp(ver, s) === 0;
+          return false;
+        };
+        return {
+          order: (a, b) => _cmp(a, b),
+          compare: (a, b) => _cmp(a, b),
+          satisfies: (ver, range) => _satisfies(ver, range),
+          gt: (a, b) => _cmp(a, b) > 0,
+          gte: (a, b) => _cmp(a, b) >= 0,
+          lt: (a, b) => _cmp(a, b) < 0,
+          lte: (a, b) => _cmp(a, b) <= 0,
+        };
+      })(),
+      YAML: globalThis.__claudeYaml,
+    };
+    Object.assign(globalThis.__claudeBunShim, globalThis.Bun);
+    if (typeof globalThis.__claudeBunShim.gc !== 'function') {
+      globalThis.__claudeBunShim.gc = () => {};
+    }
+    globalThis.__claudeBun = globalThis.__claudeBunShim;
+    globalThis.Bun = globalThis.__claudeBunShim;
+    process.argv = ['node', extractedFile, ...argv];
+    process.exit = code => {
+      throw new RequestedExit(code);
+    };
 
-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);
-    width += codePointWidth(codePoint);
+    const moduleLike = { exports: {} };
+    const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
+    if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
+    await new Promise(resolve => setTimeout(resolve, 5000));
+    if (asyncErrors.length > 0) throw asyncErrors[0];
+  } catch (error) {
+    if (error instanceof RequestedExit) {
+      process.exitCode = error.code;
+      return;
+    }
+    throw error;
+  } finally {
+    process.removeListener('uncaughtException', onAsyncError);
+    process.removeListener('unhandledRejection', onAsyncError);
+    process.argv = originalArgv;
+    process.exit = originalExit;
+    try {
+      if (originalBun === undefined) {
+        delete process.versions.bun;
+      } else {
+        Object.defineProperty(process.versions, 'bun', { value: originalBun, configurable: true });
+      }
+    } catch {}
+    delete globalThis.__claudeYaml;
+    delete globalThis.__claudeBunShim;
+    delete globalThis.__claudeBun;
+    if (hadGlobalBun) globalThis.Bun = originalGlobalBun;
+    else delete globalThis.Bun;
   }
-  return width;
 }
 
-function toHashBytes(value) {
-  if (Buffer.isBuffer(value)) return Buffer.from(value);
-  if (value instanceof Uint8Array) return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
-  if (value instanceof ArrayBuffer) return Buffer.from(value);
-  if (ArrayBuffer.isView(value)) {
-    return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+main().catch(error => {
+  if (error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED') {
+    console.error(BLOCK_MESSAGE);
+    process.exit(error.status || 1);
   }
-  return Buffer.from(String(value ?? ''));
-}
-
-function hashValue(value, seed = 0) {
-  const FNV_OFFSET_BASIS_64 = 0xcbf29ce484222325n;
-  const FNV_PRIME_64 = 0x100000001b3n;
-  const MASK_64 = 0xffffffffffffffffn;
+  console.error(error && error.stack ? error.stack : String(error));
+  process.exit(1);
+});
+NODE
+  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="${CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC:-1}"
+  export ENABLE_CLAUDEAI_MCP_SERVERS="${ENABLE_CLAUDEAI_MCP_SERVERS:-0}"
+  export CLAUDE_CODE_SIMPLE="${CLAUDE_CODE_SIMPLE:-0}"
+  node "$_helper" "$@" </dev/null
+  _status=$?
+  rm -f "$_helper"
+  trap - EXIT HUP INT TERM
+  exit "$_status"
+else
+  _bootstrap=$(mktemp "${TMPDIR:-/tmp}/claude-bootstrap.XXXXXX.js")
+  trap 'rm -f "$_bootstrap"' EXIT HUP INT TERM
+  cat <<'NODE' > "$_bootstrap"
+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 seedNumber = typeof seed === 'bigint' ? Number(seed) : Number(seed);
-  const seedValue = Number.isFinite(seedNumber) ? Math.trunc(seedNumber) : 0;
-  let result = BigInt.asUintN(64, FNV_OFFSET_BASIS_64 ^ BigInt(seedValue));
+const sourceBin = process.env.SOURCE_BIN;
+const workdir = process.env.WORKDIR;
+const entryJsOffset = Number(process.env.ENTRY_JS_OFFSET);
+const entryEndOffset = Number(process.env.ENTRY_END_OFFSET);
+const argv = process.argv.slice(2);
 
-  const bytes = toHashBytes(value);
-  for (const byte of bytes) {
-    result ^= BigInt(byte);
-    result = (result * FNV_PRIME_64) & MASK_64;
+class RequestedExit extends Error {
+  constructor(code) {
+    super(`process.exit ${code}`);
+    this.name = 'RequestedExit';
+    this.code = code;
   }
-
-  return BigInt(result);
 }
 
-function which(cmd) {
-  const fs = require('fs');
-  const path = require('path');
-
-  if (typeof cmd !== 'string' || cmd.length === 0) return null;
-
-  const isExecutable = candidate => {
-    try {
-      fs.accessSync(candidate, fs.constants.X_OK);
-      const stat = fs.statSync(candidate);
-      return stat.isFile();
-    } catch {
-      return false;
-    }
-  };
+function ensureEntryFile() {
+  const extractedFile = path.join(workdir, `cli.${entryJsOffset}.${entryEndOffset}.bare-path.js`);
+  const len = entryEndOffset - entryJsOffset;
+  if (!(len > 0)) throw new Error('invalid replay offsets');
 
-  if (cmd.includes(path.sep)) {
-    return isExecutable(cmd) ? path.resolve(cmd) : null;
-  }
+  const fd = fs.openSync(sourceBin, 'r');
+  const buf = Buffer.alloc(len);
+  fs.readSync(fd, buf, 0, len, entryJsOffset);
+  fs.closeSync(fd);
 
-  const searchPath = process.env.PATH || '';
-  for (const entry of searchPath.split(path.delimiter)) {
-    if (!entry) continue;
-    const candidate = path.join(entry, cmd);
-    if (isExecutable(candidate)) return candidate;
-  }
-  return null;
+  fs.writeFileSync(extractedFile, buf.toString('utf8').replace(/[\0\s]+$/g, ''));
+  return extractedFile;
 }
 
-function wrapAnsi(str, columns, options) {
-  const input = typeof str === 'string' ? str : String(str ?? '');
-  const widthLimit = Number(columns);
-  if (!Number.isFinite(widthLimit) || widthLimit <= 0) return input;
-
-  const wordWrap = !options || options.wordWrap !== false;
-  const hard = !!(options && options.hard);
-
-  if (!wordWrap || hard) {
-    const result = [];
+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 (let i = 0; i < input.length; ) {
-      const char = input[i];
-
-      if (char === '\u001b' || char === '\u009b') {
-        const match = input.slice(i).match(ansiPatternSingle);
-        if (match && match.index === 0) {
-          result.push(match[0]);
-          i += match[0].length;
-          continue;
-        }
-      }
-
-      if (char === '\n') {
-        result.push(char);
-        width = 0;
-        i += 1;
-        continue;
-      }
-
-      const codePoint = input.codePointAt(i);
-      const charText = String.fromCodePoint(codePoint);
-      const charWidth = codePointWidth(codePoint);
-
-      if (width > 0 && width + charWidth > widthLimit) {
-        result.push('\n');
-        width = 0;
-      }
-
-      result.push(charText);
-      width += charWidth;
-      i += charText.length;
-    }
-
-    return result.join('');
+    for (const _segment of segmenter.segment(text)) width += 1;
+    return width;
   }
+  return Array.from(text).length;
+}
 
-  const result = [];
-  let line = '';
-  let lineWidth = 0;
-  let pendingSpaces = '';
-
-  for (let i = 0; i < input.length; ) {
-    const char = input[i];
-
-    if (char === '\u001b' || char === '\u009b') {
-      const match = input.slice(i).match(ansiPatternSingle);
-      if (match && match.index === 0) {
-        line += match[0];
-        i += match[0].length;
-        continue;
-      }
-    }
+function parseScalar(value) {
+  const text = String(value ?? '').trim();
+  if (text === '') return '';
+  if (text === 'true') return true;
+  if (text === 'false') return false;
+  if (text === 'null' || text === '~') return null;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(text)) return Number(text);
+  if (
+    (text.startsWith('"') && text.endsWith('"')) ||
+    (text.startsWith("'") && text.endsWith("'"))
+  ) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
 
-    if (char === '\n') {
-      if (line.length > 0) result.push(line);
-      result.push('\n');
-      line = '';
-      lineWidth = 0;
-      pendingSpaces = '';
-      i += 1;
+function parseInlineArray(value) {
+  const inner = String(value ?? '').trim().slice(1, -1).trim();
+  if (inner === '') return [];
+  const items = [];
+  let current = '';
+  let quote = null;
+
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i];
+    if (quote) {
+      if (ch === quote && inner[i - 1] !== '\\') quote = null;
+      current += ch;
       continue;
     }
-
-    const codePoint = input.codePointAt(i);
-    const charText = String.fromCodePoint(codePoint);
-    if (charText === ' ' || charText === '\t') {
-      pendingSpaces += charText;
-      i += charText.length;
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
       continue;
     }
-
-    let end = i + charText.length;
-    while (end < input.length) {
-      const nextChar = input[end];
-      if (nextChar === '\n' || nextChar === ' ' || nextChar === '\t' || nextChar === '\u001b' || nextChar === '\u009b') {
-        break;
-      }
-      const nextCodePoint = input.codePointAt(end);
-      end += String.fromCodePoint(nextCodePoint).length;
-    }
-
-    const text = input.slice(i, end);
-    const textWidth = stringWidth(text);
-    const pendingWidth = pendingSpaces ? stringWidth(pendingSpaces) : 0;
-
-    if (lineWidth > 0 && lineWidth + pendingWidth + textWidth > widthLimit) {
-      result.push(line);
-      result.push('\n');
-      line = '';
-      lineWidth = 0;
-      pendingSpaces = '';
+    if (ch === ',') {
+      items.push(parseScalar(current));
+      current = '';
+      continue;
     }
+    current += ch;
+  }
 
-    if (lineWidth > 0 && pendingSpaces) {
-      line += pendingSpaces;
-      lineWidth += pendingWidth;
-    }
-    pendingSpaces = '';
+  if (current !== '') items.push(parseScalar(current));
+  return items;
+}
 
-    line += text;
-    lineWidth += textWidth;
-    i = end;
+function yamlParse(text) {
+  const source = String(text ?? '');
+  const result = {};
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const idx = line.indexOf(':');
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    const rawValue = line.slice(idx + 1).trim();
+    if (!key) continue;
+    result[key] = rawValue.startsWith('[') && rawValue.endsWith(']')
+      ? parseInlineArray(rawValue)
+      : parseScalar(rawValue);
   }
+  return result;
+}
 
-  if (pendingSpaces && lineWidth > 0) {
-    line += pendingSpaces;
+function yamlStringify(value) {
+  if (!value || typeof value !== 'object') return String(value ?? '');
+  const lines = [];
+  for (const [key, raw] of Object.entries(value)) {
+    if (Array.isArray(raw)) {
+      lines.push(`${key}: [${raw.map(item => JSON.stringify(String(item))).join(', ')}]`);
+    } else if (raw === null) {
+      lines.push(`${key}: null`);
+    } else if (typeof raw === 'string') {
+      lines.push(`${key}: ${JSON.stringify(raw)}`);
+    } else {
+      lines.push(`${key}: ${String(raw)}`);
+    }
   }
-  if (line.length > 0) result.push(line);
-
-  return result.join('');
+  return lines.join('\n');
 }
 
-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 ''; }
-  },
-};
-
-function parseSemverVersion(value) {
-  const text = String(value ?? '').trim().replace(/^[v=]/, '');
-  const match = text.match(/^(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?(?:\.(0|[1-9]\d*))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/);
-  if (!match) return null;
-  return {
-    parts: [match[1], match[2] ?? '0', match[3] ?? '0'].map(Number),
-    pre: match[4] ? match[4].split('.') : null,
+function createYamlShim() {
+  const yaml = {
+    parse: yamlParse,
+    stringify: yamlStringify,
   };
+  yaml.YAML = yaml;
+  yaml.default = yaml;
+  return yaml;
 }
 
-function comparePrerelease(a, b) {
-  const size = Math.max(a.length, b.length);
-  for (let i = 0; i < size; i++) {
-    if (a[i] === undefined) return -1;
-    if (b[i] === undefined) return 1;
-    const aNum = /^\d+$/.test(a[i]);
-    const bNum = /^\d+$/.test(b[i]);
-    if (aNum && bNum) { const d = Number(a[i]) - Number(b[i]); if (d) return d < 0 ? -1 : 1; }
-    else if (aNum) return -1;
-    else if (bNum) return 1;
-    else if (a[i] < b[i]) return -1;
-    else if (a[i] > b[i]) return 1;
-  }
-  return 0;
-}
+function createFakeRequire(realRequire) {
+  const realChild = realRequire('child_process');
+  const realVm = realRequire('vm');
 
-const semver = {
-  order(left, right) {
-    const a = parseSemverVersion(left), b = parseSemverVersion(right);
-    if (!a || !b) return NaN;
-    for (let i = 0; i < 3; i++) {
-      const d = a.parts[i] - b.parts[i];
-      if (d) return d < 0 ? -1 : 1;
-    }
-    if (a.pre && !b.pre) return -1;
-    if (!a.pre && b.pre) return 1;
-    if (a.pre && b.pre) return comparePrerelease(a.pre, b.pre);
-    return 0;
-  },
-  satisfies(version, range) {
-    if (!version || !range) return false;
-    const v = String(version).replace(/^[v=]/, '');
-    const clean = String(range).trim();
-    if (!clean) return false;
-    if (clean.includes('||')) return clean.split('||').some(r => semver.satisfies(v, r.trim()));
-    const parts = clean.split(/\s+/).filter(Boolean);
-    if (parts.length > 1) return parts.every(p => semver.satisfies(v, p));
-    const caret = clean.match(/^\^([0-9].*)$/);
-    if (caret) {
-      const p = parseSemverVersion(caret[1]);
-      if (!p) return false;
-      const upper = p.parts[0] > 0 ? (p.parts[0] + 1) + '.0.0'
-        : p.parts[1] > 0 ? '0.' + (p.parts[1] + 1) + '.0'
-        : '0.0.' + (p.parts[2] + 1);
-      return semver.satisfies(v, '>=' + caret[1]) && semver.satisfies(v, '<' + upper);
-    }
-    const tilde = clean.match(/^~([0-9].*)$/);
-    if (tilde) {
-      const p = parseSemverVersion(tilde[1]);
-      if (!p) return false;
-      const original = tilde[1].split('.');
-      const upper = original.length >= 2
-        ? p.parts[0] + '.' + (p.parts[1] + 1) + '.0'
-        : (p.parts[0] + 1) + '.0.0';
-      return semver.satisfies(v, '>=' + tilde[1]) && semver.satisfies(v, '<' + upper);
-    }
-    const m = clean.match(/^([><=!]{1,2})\s*([0-9].*)$/);
-    if (m) {
-      const cmp = semver.order(v, m[2]);
-      if (!Number.isFinite(cmp)) return false;
-      return m[1] === '>=' ? cmp >= 0 : m[1] === '>' ? cmp > 0 :
-             m[1] === '<=' ? cmp <= 0 : m[1] === '<' ? cmp < 0 :
-             m[1] === '=' || m[1] === '==' ? cmp === 0 : m[1] === '!=' ? cmp !== 0 : false;
+  function rewriteArgs(args) {
+    if (
+      Array.isArray(args) &&
+      args[0] === 'xdg-open' &&
+      Array.isArray(args[1]) &&
+      typeof args[1][0] === 'string'
+    ) {
+      return ['termux-open-url', [args[1][0]], ...args.slice(2)];
     }
-    const exact = parseSemverVersion(clean);
-    return exact ? semver.order(v, clean) === 0 : false;
-  },
-};
-
-function bunSpawn(argv, options) {
-  const childProcess = require('child_process');
-  options = options || {};
-  if (!Array.isArray(argv) || argv.length === 0) {
-    throw new TypeError('Bun.spawn expects a non-empty argv array');
-  }
-  const command = argv[0];
-  const args = argv.slice(1);
-  const terminal = options.terminal || null;
-
-  function resolveStdio(val, fallback) {
-    if (val === 'ignore' || val === 'inherit' || val === 'pipe') return val;
-    return fallback;
+    return args;
   }
 
-  let stdioSpec;
-  if (terminal) {
-    stdioSpec = ['pipe', 'pipe', 'pipe'];
-  } else if (Array.isArray(options.stdio)) {
-    stdioSpec = options.stdio.map(function(s) { return resolveStdio(s, 'pipe'); });
-  } else {
-    stdioSpec = [
-      resolveStdio(options.stdin, 'pipe'),
-      resolveStdio(options.stdout, 'pipe'),
-      resolveStdio(options.stderr, 'pipe'),
-    ];
-  }
+  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),
+  );
 
-  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 = function(chunk) {
-      if (!terminal._closed && terminal._options && typeof terminal._options.data === 'function') {
-        terminal._options.data(terminal, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-      }
-    };
-    if (nodeChild.stdout) nodeChild.stdout.on('data', fireData);
-    if (nodeChild.stderr) nodeChild.stderr.on('data', fireData);
-    const origWrite = terminal.write.bind(terminal);
-    terminal.write = function(data) {
-      if (nodeChild.stdin && !nodeChild.stdin.destroyed) {
-        nodeChild.stdin.write(Buffer.isBuffer(data) ? data : Buffer.from(data));
+  return function fakeRequire(id) {
+    if (id === 'ws') {
+      class WS {
+        on() {}
+        once() {}
+        addEventListener() {}
+        close() {}
+        send() {}
+        ping() {}
       }
-      return origWrite(data);
-    };
-  }
+      return { default: WS, WebSocket: WS };
+    }
 
-  nodeChild.exited = new Promise(function(resolve) {
-    nodeChild.once('exit', function(code, signal) {
-      resolve(code != null ? code : (signal ? 1 : 0));
-    });
-  });
-
-  function makeTextReader(stream) {
-    return {
-      text: function() {
-        return new Promise(function(resolve, reject) {
-          if (!stream) return resolve('');
-          const chunks = [];
-          stream.on('data', function(chunk) { chunks.push(chunk); });
-          stream.on('end', function() { 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;
-}
+    if (id === 'vm' || id === 'node:vm') {
+      if (!realVm.__claudeBunShimPatched) {
+        const originalCreateContext = realVm.createContext.bind(realVm);
+        const originalRunInNewContext = realVm.runInNewContext.bind(realVm);
+        const originalRunInContext = realVm.runInContext.bind(realVm);
+        const originalRunInThisContext = realVm.runInThisContext && realVm.runInThisContext.bind(realVm);
+        const scriptProto = realVm.Script && realVm.Script.prototype;
+
+        realVm.createContext = (contextObject, ...rest) =>
+          originalCreateContext(injectBunIntoContext(contextObject), ...rest);
+        realVm.runInNewContext = (code, contextObject, ...rest) =>
+          originalRunInNewContext(code, injectBunIntoContext(contextObject), ...rest);
+        realVm.runInContext = (code, contextObject, ...rest) =>
+          originalRunInContext(code, injectBunIntoContext(contextObject), ...rest);
+        if (originalRunInThisContext) {
+          realVm.runInThisContext = (code, ...rest) => originalRunInThisContext(code, ...rest);
+        }
 
-class TerminalShim {
-  constructor(options) {
-    options = 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;
-  }
-}
+        if (scriptProto && !scriptProto.__claudeBunShimPatched) {
+          const originalScriptRunInContext = scriptProto.runInContext;
+          const originalScriptRunInNewContext = scriptProto.runInNewContext;
+          const originalScriptRunInThisContext = scriptProto.runInThisContext;
+
+          scriptProto.runInContext = function (contextObject, ...rest) {
+            return originalScriptRunInContext.call(this, injectBunIntoContext(contextObject), ...rest);
+          };
+          scriptProto.runInNewContext = function (contextObject, ...rest) {
+            return originalScriptRunInNewContext.call(this, injectBunIntoContext(contextObject), ...rest);
+          };
+          if (originalScriptRunInThisContext) {
+            scriptProto.runInThisContext = function (...rest) {
+              return originalScriptRunInThisContext.call(this, ...rest);
+            };
+          }
+
+          Object.defineProperty(scriptProto, '__claudeBunShimPatched', { value: true });
+        }
 
-function bunListen(options) {
-  const net = require('net');
-  options = options || {};
-  const sockets = new Set();
-  const server = net.createServer(function(socket) {
-    sockets.add(socket);
-    const connection = {
-      data: undefined,
-      write: function(chunk) {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        const ok = socket.write(buffer);
-        return ok ? buffer.length : 0;
-      },
-      end: function(chunk) { socket.end(chunk); },
-      destroy: function(error) { socket.destroy(error); },
-    };
-    socket.on('data', function(chunk) {
-      if (options.socket && typeof options.socket.data === 'function') {
-        options.socket.data(connection, chunk);
-      }
-    });
-    socket.on('drain', function() {
-      if (options.socket && typeof options.socket.drain === 'function') {
-        options.socket.drain(connection);
-      }
-    });
-    socket.on('close', function() {
-      sockets.delete(socket);
-      if (options.socket && typeof options.socket.close === 'function') {
-        options.socket.close(connection);
-      }
-    });
-    socket.on('error', function(error) {
-      if (options.socket && typeof options.socket.error === 'function') {
-        options.socket.error(connection, error);
+        Object.defineProperty(realVm, '__claudeBunShimPatched', { value: true });
       }
-    });
-    if (options.socket && typeof options.socket.open === 'function') {
-      options.socket.open(connection);
+      return realVm;
     }
-  });
-  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: function(closeConnections) {
-      server.close();
-      if (closeConnections) {
-        for (const socket of sockets) socket.destroy();
-      }
-    },
-  };
-}
 
-class BunTranspiler {
-  constructor(_options) {}
-  transformSync(code) { return typeof code === 'string' ? code : ''; }
-  scanImports(code) {
-    const imports = [];
-    const str = String(code);
-    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(str)) !== null) imports.push({ path: m[1], kind: 'import-statement' });
-    while ((m = reDynamic.exec(str)) !== null) imports.push({ path: m[1], kind: 'dynamic-import' });
-    while ((m = reRequire.exec(str)) !== null) imports.push({ path: m[1], kind: 'require-call' });
-    return imports;
-  }
+    if (id === 'child_process') {
+      return guardedChild;
+    }
+
+    if (id === 'node:child_process') {
+      return guardedChild;
+    }
+
+    if (id.startsWith('/$bunfs/root/')) {
+      throw new Error('bunfs require blocked: ' + id);
+    }
+
+    return realRequire(id);
+  };
 }
 
 async function main() {
   const extractedFile = ensureEntryFile();
   const code = fs.readFileSync(extractedFile, 'utf8');
-  const fn = eval('(' + code);
+  const patchedCode = code.replace(
+    /^function\(exports, require, module, __filename, __dirname\) \{/,
+    'function(exports, require, module, __filename, __dirname) {var __claudeBun = globalThis.__claudeBunShim;',
+  ).replace(
+    /\btypeof Bun\b/g,
+    'typeof __claudeBun',
+  ).replace(
+    /\bBun\./g,
+    '__claudeBun.',
+  ).replace(
+    /function t5q\(q\)\{return Bun\.YAML\.parse\(q\)\}/g,
+    'function t5q(q){return globalThis.__claudeYaml.parse(q)}',
+  ).replace(
+    /function VK6\(q\)\{return Bun\.YAML\.stringify\(q,null,2\)\+`/g,
+    'function VK6(q){return globalThis.__claudeYaml.stringify(q,null,2)+`',
+  );
+  const fn = eval('(' + patchedCode.replace(/\)\s*$/, '') + ')');
 
   const originalArgv = process.argv.slice();
   const originalExit = process.exit;
@@ -666,6 +757,10 @@ async function main() {
   const originalGlobalBun = globalThis.Bun;
   const asyncErrors = [];
 
+  globalThis.__claudeYaml = createYamlShim();
+  if (!globalThis.__claudeBunShim || typeof globalThis.__claudeBunShim !== 'object') {
+    globalThis.__claudeBunShim = {};
+  }
   const fakeRequire = createFakeRequire(require);
   function onAsyncError(error) {
     asyncErrors.push(error);
@@ -675,38 +770,55 @@ async function main() {
     process.once('uncaughtException', onAsyncError);
     process.once('unhandledRejection', onAsyncError);
     Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
-    const BunShim = {
+    const _realChild = require('child_process');
+    globalThis.Bun = {
       version: '1.1.8',
       stringWidth,
-      hash: hashValue,
-      which,
-      spawn: bunSpawn,
-      wrapAnsi,
-      stripANSI,
-      semver,
-      Terminal: TerminalShim,
-      listen: bunListen,
-      Transpiler: BunTranspiler,
-      YAML,
-      gc: (sync) => {
+      which: (cmd) => {
         try {
-          if (typeof global.gc === 'function') global.gc(sync === false ? false : true);
-        } catch {}
+          return _realChild.execFileSync('which', [String(cmd)], { encoding: 'utf8' }).trim() || null;
+        } catch { return null; }
       },
-      generateHeapSnapshot: () => Buffer.alloc(0),
-      stdin: { stream: null },
-      embeddedFiles: [],
+      semver: (() => {
+        const _cmp = (a, b) => {
+          const pa = String(a).replace(/[^0-9.]/g,'').split('.').map(Number);
+          const pb = String(b).replace(/[^0-9.]/g,'').split('.').map(Number);
+          for (let i = 0; i < 3; i++) { const d = (pa[i]||0)-(pb[i]||0); if (d) return d > 0 ? 1 : -1; }
+          return 0;
+        };
+        const _satisfies = (ver, range) => {
+          const s = String(range).trim();
+          const m = s.match(/^([><=!]{1,2})\s*([\d]+(?:\.[\d]+){0,2})$/);
+          if (m) {
+            const op = m[1], c = _cmp(ver, m[2]);
+            if (op === '>') return c > 0;
+            if (op === '>=') return c >= 0;
+            if (op === '<') return c < 0;
+            if (op === '<=') return c <= 0;
+            if (op === '=' || op === '==') return c === 0;
+            if (op === '!=') return c !== 0;
+          }
+          if (/^[\d]+(?:\.[\d]+){0,2}$/.test(s)) return _cmp(ver, s) === 0;
+          return false;
+        };
+        return {
+          order: (a, b) => _cmp(a, b),
+          compare: (a, b) => _cmp(a, b),
+          satisfies: (ver, range) => _satisfies(ver, range),
+          gt: (a, b) => _cmp(a, b) > 0,
+          gte: (a, b) => _cmp(a, b) >= 0,
+          lt: (a, b) => _cmp(a, b) < 0,
+          lte: (a, b) => _cmp(a, b) <= 0,
+        };
+      })(),
+      YAML: globalThis.__claudeYaml,
     };
-    const BunProxy = new Proxy(BunShim, {
-      get(target, key, receiver) {
-        if (!(key in target) && typeof key !== 'symbol' && debugBunShim) {
-          console.error('[BunShim missing]', key);
-        }
-        return Reflect.get(target, key, receiver);
-      },
-    });
-    globalThis.Bun = BunProxy;
-
+    Object.assign(globalThis.__claudeBunShim, globalThis.Bun);
+    if (typeof globalThis.__claudeBunShim.gc !== 'function') {
+      globalThis.__claudeBunShim.gc = () => {};
+    }
+    globalThis.__claudeBun = globalThis.__claudeBunShim;
+    globalThis.Bun = globalThis.__claudeBunShim;
     process.argv = ['node', extractedFile, ...argv];
     process.exit = code => {
       throw new RequestedExit(code);
@@ -715,7 +827,8 @@ async function main() {
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
-    await new Promise(resolve => setTimeout(resolve, 200));
+    const _waitMs = Number(process.env.CLAUDE_TERMUX_PRINT_WAIT_MS || 200);
+    await new Promise(resolve => setTimeout(resolve, _waitMs));
     if (asyncErrors.length > 0) throw asyncErrors[0];
   } catch (error) {
     if (error instanceof RequestedExit) {
@@ -735,13 +848,27 @@ async function main() {
         Object.defineProperty(process.versions, 'bun', { value: originalBun, configurable: true });
       }
     } catch {}
+    delete globalThis.__claudeYaml;
+    delete globalThis.__claudeBunShim;
+    delete globalThis.__claudeBun;
+    if (hadGlobalBun) globalThis.Bun = originalGlobalBun;
   }
 }
 
-main().then(() => {
-  process.exit(process.exitCode ?? 0);
-}).catch(error => {
+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);
 });
 NODE
+  export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="${CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC:-1}"
+  export ENABLE_CLAUDEAI_MCP_SERVERS="${ENABLE_CLAUDEAI_MCP_SERVERS:-0}"
+  node "$_bootstrap" "$@"
+  _status=$?
+  rm -f "$_bootstrap"
+  trap - EXIT HUP INT TERM
+  exit "$_status"
+fi