@bash0816/claude-code 2.1.154 → 2.1.157-1

package/README.md

@@ -1,84 +1,31 @@
 # @bash0816/cluade-code
 
-Termux-native Claude Code wrapper package.
+> **This package has been renamed.**
+> Please migrate to the canonical package: [@bash0816/claude-code](https://www.npmjs.com/package/@bash0816/claude-code)
 
-Termux 向け Claude Code native wrapper package です。
+## Migration / 移行
 
-Legacy compatibility package:
+Run the following command to migrate:
 
-互換維持用の legacy package:
-
-- canonical package: `@bash0816/claude-code`
-
-## Install / インストール
+移行するには以下を実行してください:
 
 ```sh
-npm install -g @bash0816/cluade-code@latest
+npm uninstall -g @bash0816/cluade-code
+npm install -g @bash0816/claude-code@latest
 ```
 
-If an older audited launcher from this repository already exists at `$PREFIX/bin/claude`, migrate through the updated launcher.
+Or use the built-in migration:
 
-この repository の古い監査済み launcher が `$PREFIX/bin/claude` にある場合は、更新済み launcher 経由で移行します。
+内蔵の migration を使う場合:
 
 ```sh
 claude update
 ```
 
-If npm reports `EEXIST` before package scripts run, use a one-time forced migration.
-
-package script 実行前に npm が `EEXIST` を返す場合は、初回だけ forced migration を使います。
-
-```sh
-npm install -g --force @bash0816/cluade-code@latest
-```
-
-After npm owns the `claude` bin link, normal `npm install -g` updates work.
-
-npm が `claude` bin link を管理する状態になれば、通常の `npm install -g` 更新が使えます。
-
-Specific audited version:
-
-監査済みの固定 version:
-
-```sh
-npm install -g @bash0816/cluade-code@2.1.123
-```
-
-## Update / 更新
-
-```sh
-claude update
-```
-
-`claude update` checks the GitHub release manifest and installs the latest audited package version.
-
-`claude update` は GitHub release manifest を確認し、最新の監査済み package version を install します。
-
-For the final legacy bridge release, `claude update` migrates this typo package to the canonical package.
-
-最終 legacy bridge release では、`claude update` がこの typo package から canonical package へ移行します。
-
-This final bridge package is frozen at package version `2.1.123` and launches audited native `2.1.150` by default from the synced metadata set.
-
-この最終 bridge package は package version `2.1.123` で凍結し、同期済み metadata 集合から既定では監査済み native `2.1.150` を起動します。
-
-```sh
-npm install -g @bash0816/claude-code@<latest_audited_version>
-```
-
-Normal launch also checks the same manifest with a short timeout and prints a notice when a newer audited version is available.
-
-通常起動時も、同じ manifest を短い timeout で確認し、新しい監査済み version があれば通知します。
+## Note
 
-## Policy / 方針
+This is a legacy compatibility package with a typo in the package name.
+All new releases are published under [@bash0816/claude-code](https://www.npmjs.com/package/@bash0816/claude-code).
 
-- Only audited versions in `config/claude-native-audited-versions.json` can run.
-- `config/claude-native-audited-versions.json` にある監査済み version だけを実行できます。
-- This legacy package is frozen at `2.1.123` and exists only as a migration bridge to `@bash0816/claude-code`.
-- この legacy package は `2.1.123` で凍結しており、`@bash0816/claude-code` への migration bridge としてのみ存在します。
-- The metadata file remains the source of truth for the audited version set.
-- 監査済み version 集合の source of truth は引き続き metadata file です。
-- Native artifacts are cached under `${HOME}/.claude-termux-native-package`.
-- native artifact は `${HOME}/.claude-termux-native-package` に cache します。
-- If native preparation fails, the command exits with an error.
-- native preparation に失敗した場合、command は error で終了します。
+このパッケージはパッケージ名に typo がある legacy 互換パッケージです。
+新しいリリースはすべて [@bash0816/claude-code](https://www.npmjs.com/package/@bash0816/claude-code) で公開されています。

package/config/claude-native-audited-versions.json

@@ -181,6 +181,27 @@
       "entry_js_offset": 222957396,
       "entry_end_offset": 238482842,
       "status": "termux_verified"
+    },
+    "2.1.156": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.156",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.156",
+      "entry_js_offset": 222957812,
+      "entry_end_offset": 238483519,
+      "status": "termux_verified"
+    },
+    "2.1.157": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.157",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.157",
+      "entry_js_offset": 223210916,
+      "entry_end_offset": 238725072,
+      "status": "termux_verified"
+    },
+    "2.1.157-1": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.157",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.157",
+      "entry_js_offset": 223210916,
+      "entry_end_offset": 238725072,
+      "status": "candidate"
     }
   }
 }

package/config/claude-termux-release-manifest.json

@@ -4,10 +4,10 @@
   "canonical_package_name": "@bash0816/claude-code",
   "canonical_manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json",
   "canonical_repository_url": "https://github.com/bash0816/ClaudeCode-Termux",
-  "bridge_package_version": "2.1.154",
-  "default_native_version": "2.1.154",
-  "latest_audited_version": "2.1.154",
-  "latest_candidate_version": "2.1.154",
-  "previous_stable_version": "2.1.126",
+  "bridge_package_version": "2.1.157-1",
+  "default_native_version": "2.1.157-1",
+  "latest_audited_version": "2.1.157",
+  "latest_candidate_version": "2.1.157-1",
+  "previous_stable_version": "2.1.157",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

package/lib/check-updates.js

@@ -235,7 +235,29 @@ async function runUpdate() {
     return 0;
   }
   if (target.migration) {
-    console.error(`Migrating from legacy package ${pkg.name} to canonical package ${target.packageName}@${target.targetVersion}`);
+    console.error(`Migrating from ${pkg.name} to ${target.packageName}@${target.targetVersion}`);
+    if (dryRun) {
+      console.log(`npm uninstall -g ${pkg.name}`);
+      console.log(`npm install -g ${target.packageName}@${target.targetVersion}`);
+      return 0;
+    }
+    console.error(`Step 1: Uninstalling ${pkg.name}...`);
+    const uninstall = cp.spawnSync('npm', ['uninstall', '-g', pkg.name], { stdio: 'inherit', env: process.env });
+    if (uninstall.status !== 0) {
+      console.error(`Uninstall failed (exit ${uninstall.status}). Cannot safely continue migration.`);
+      console.error(`Run manually:`);
+      console.error(`  npm uninstall -g ${pkg.name}`);
+      console.error(`  npm install -g ${target.packageName}@${target.targetVersion}`);
+      return 1;
+    }
+    console.error(`Step 2: Installing ${target.packageName}@${target.targetVersion}...`);
+    const result = cp.spawnSync('npm', ['install', '-g', `${target.packageName}@${target.targetVersion}`], { stdio: 'inherit', env: process.env });
+    if (result.status !== 0) {
+      console.error(`Install failed. To restore, run:`);
+      console.error(`  npm install -g ${target.packageName}@${target.targetVersion}`);
+      console.error(`  # or to restore legacy: npm install -g ${pkg.name}@${pkg.version}`);
+    }
+    return result.status === null ? 1 : result.status;
   }
   return installTarget(target.packageName, target.targetVersion);
 }

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

@@ -74,7 +74,6 @@ function ensureEntryFile() {
 }
 
 function createFakeRequire(realRequire) {
-  const realChild = realRequire('child_process');
   const realVm = realRequire('vm');
 
   function injectBunIntoContext(context) {
@@ -107,6 +106,7 @@ function createFakeRequire(realRequire) {
     Object.defineProperty(realVm, '__bunShimPatched', { value: true });
   }
 
+  const realChild = realRequire('child_process');
   function rewriteArgs(args) {
     if (
       Array.isArray(args) &&
@@ -120,8 +120,6 @@ function createFakeRequire(realRequire) {
   }
 
   return function fakeRequire(id) {
-    if (id === 'vm') return realVm;
-
     if (id === 'ws') {
       class WS {
         on() {}
@@ -145,6 +143,8 @@ function createFakeRequire(realRequire) {
       };
     }
 
+    if (id === 'vm') return realVm;
+
     if (id.startsWith('/$bunfs/root/')) {
       throw new Error('bunfs require blocked: ' + id);
     }
@@ -153,321 +153,511 @@ 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;
+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';
 
-  function stripANSI(value) {
-    if (typeof value !== 'string' || value.length === 0) return '';
-    return value.replace(ansiPattern, '');
-  }
+function stripANSI(text) {
+  if (typeof text !== 'string' || text.length === 0) return '';
+  return text.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 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;
   }
 
-  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)
-    );
+  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;
   }
 
-  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;
+  return 1;
+}
+
+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);
   }
+  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 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);
   }
+  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;
 
-  function hash(value) {
-    const digest = crypto.createHash('sha256').update(normalizeInput(value)).digest();
-    return digest.readUInt32LE(0);
+  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 bytes = toHashBytes(value);
+  for (const byte of bytes) {
+    result ^= BigInt(byte);
+    result = (result * FNV_PRIME_64) & MASK_64;
   }
 
-  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 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;
     }
-    return null;
+  };
+
+  if (cmd.includes(path.sep)) {
+    return isExecutable(cmd) ? path.resolve(cmd) : null;
   }
 
-  function spawn(argv, options = {}) {
-    if (!Array.isArray(argv) || argv.length === 0) {
-      throw new TypeError('Bun.spawn expects a non-empty argv array');
+  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;
+}
+
+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 = [];
+    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;
     }
-    const [command, ...args] = argv;
-    const terminal = options.terminal || null;
 
-    function resolveStdio(val, fallback) {
-      if (val === 'ignore' || val === 'inherit' || val === 'pipe') return val;
-      return fallback;
+    return result.join('');
+  }
+
+  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;
+      }
     }
 
-    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'),
-      ];
+    if (char === '\n') {
+      if (line.length > 0) result.push(line);
+      result.push('\n');
+      line = '';
+      lineWidth = 0;
+      pendingSpaces = '';
+      i += 1;
+      continue;
     }
 
-    const nodeChild = childProcess.spawn(command, args, {
-      cwd: options.cwd,
-      env: options.env || process.env,
-      detached: options.detached,
-      windowsHide: options.windowsHide,
-      stdio: stdioSpec,
-    });
+    const codePoint = input.codePointAt(i);
+    const charText = String.fromCodePoint(codePoint);
+    if (charText === ' ' || charText === '\t') {
+      pendingSpaces += charText;
+      i += charText.length;
+      continue;
+    }
 
-    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);
-      };
+    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;
     }
 
-    nodeChild.exited = new Promise(resolve => {
-      nodeChild.once('exit', (code, signal) => resolve(code != null ? code : (signal ? 1 : 0)));
-    });
+    const text = input.slice(i, end);
+    const textWidth = stringWidth(text);
+    const pendingWidth = pendingSpaces ? stringWidth(pendingSpaces) : 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 (lineWidth > 0 && lineWidth + pendingWidth + textWidth > widthLimit) {
+      result.push(line);
+      result.push('\n');
+      line = '';
+      lineWidth = 0;
+      pendingSpaces = '';
+    }
+
+    if (lineWidth > 0 && pendingSpaces) {
+      line += pendingSpaces;
+      lineWidth += pendingWidth;
     }
-    if (nodeChild.stdout) Object.assign(nodeChild.stdout, makeTextReader(nodeChild.stdout));
-    if (nodeChild.stderr) Object.assign(nodeChild.stderr, makeTextReader(nodeChild.stderr));
-    return nodeChild;
+    pendingSpaces = '';
+
+    line += text;
+    lineWidth += textWidth;
+    i = end;
+  }
+
+  if (pendingSpaces && lineWidth > 0) {
+    line += pendingSpaces;
   }
+  if (line.length > 0) result.push(line);
+
+  return result.join('');
+}
 
-  class TerminalShim {
-    constructor(options = {}) {
-      this._options = options;
-      this._cols = options.cols || 80;
-      this._rows = options.rows || 24;
-      this._closed = false;
+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 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;
+}
+
+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;
     }
-    write(data) {
-      if (this._closed) return;
-      if (this._options.data) this._options.data(this, Buffer.isBuffer(data) ? data : Buffer.from(data));
+    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);
     }
-    resize(cols, rows) {
-      this._cols = cols;
-      this._rows = rows;
+    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);
     }
-    close() {
-      this._closed = true;
+    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;
     }
+    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 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);
+  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(function(s) { return 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 = 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 origWrite(data);
+    };
+  }
 
-    server.listen(options.port || 0, options.hostname || '127.0.0.1');
+  nodeChild.exited = new Promise(function(resolve) {
+    nodeChild.once('exit', function(code, signal) {
+      resolve(code != null ? code : (signal ? 1 : 0));
+    });
+  });
 
+  function makeTextReader(stream) {
     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();
-        }
+      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;
+}
 
-  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;
-    },
-  };
+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;
+  }
+}
 
-  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 {}; }
+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);
+      }
+    });
+    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;
     },
-    stringify(obj) {
-      try {
-        return Object.entries(obj || {}).map(([k, v]) => `${k}: ${v}`).join('\n') + '\n';
-      } catch { return ''; }
+    stop: function(closeConnections) {
+      server.close();
+      if (closeConnections) {
+        for (const socket of sockets) socket.destroy();
+      }
     },
   };
+}
 
-  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;
-    }
+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;
   }
-
-  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');
+  const fn = eval('(' + code);
 
   const originalArgv = process.argv.slice();
   const originalExit = process.exit;
@@ -476,6 +666,7 @@ async function main() {
   const originalGlobalBun = globalThis.Bun;
   const asyncErrors = [];
 
+  const fakeRequire = createFakeRequire(require);
   function onAsyncError(error) {
     asyncErrors.push(error);
   }
@@ -484,14 +675,43 @@ async function main() {
     process.once('uncaughtException', onAsyncError);
     process.once('unhandledRejection', onAsyncError);
     Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
-    globalThis.Bun = createBunShim();
-    const fakeRequire = createFakeRequire(require);
+    const BunShim = {
+      version: '1.1.8',
+      stringWidth,
+      hash: hashValue,
+      which,
+      spawn: bunSpawn,
+      wrapAnsi,
+      stripANSI,
+      semver,
+      Terminal: TerminalShim,
+      listen: bunListen,
+      Transpiler: BunTranspiler,
+      YAML,
+      gc: (sync) => {
+        try {
+          if (typeof global.gc === 'function') global.gc(sync === false ? false : true);
+        } catch {}
+      },
+      generateHeapSnapshot: () => Buffer.alloc(0),
+      stdin: { stream: null },
+      embeddedFiles: [],
+    };
+    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;
+
     process.argv = ['node', extractedFile, ...argv];
     process.exit = code => {
       throw new RequestedExit(code);
     };
 
-    const fn = eval('(' + code);
     const moduleLike = { exports: {} };
     const maybePromise = fn(moduleLike.exports, fakeRequire, moduleLike, extractedFile, workdir);
     if (maybePromise && typeof maybePromise.then === 'function') await maybePromise;
@@ -515,14 +735,12 @@ async function main() {
         Object.defineProperty(process.versions, 'bun', { value: originalBun, configurable: true });
       }
     } catch {}
-    try {
-      if (hadGlobalBun) globalThis.Bun = originalGlobalBun;
-      else delete globalThis.Bun;
-    } catch {}
   }
 }
 
-main().catch(error => {
+main().then(() => {
+  process.exit(process.exitCode ?? 0);
+}).catch(error => {
   console.error(error && error.stack ? error.stack : String(error));
   process.exit(1);
 });

package/package.json

@@ -1,15 +1,11 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.154",
+  "version": "2.1.157-1",
   "description": "Termux-native Claude Code wrapper with audited native replay",
   "license": "MIT",
   "bin": {
     "claude": "bin/claude"
   },
-  "scripts": {
-    "preinstall": "node lib/preinstall.js",
-    "postinstall": "node lib/postinstall.js"
-  },
   "files": [
     "bin",
     "lib",
@@ -17,6 +13,6 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=18"
   }
 }