@bash0816/claude-code 2.1.143 → 2.1.150-1

package/README.md

@@ -1,17 +1,19 @@
-# @bash0816/claude-code
+# @bash0816/cluade-code
 
 Termux-native Claude Code wrapper package.
 
 Termux 向け Claude Code native wrapper package です。
 
-This package is the current Termux wrapper package line.
+Legacy compatibility package:
 
-この package は現行の Termux wrapper package 系です。
+互換維持用の legacy package:
+
+- canonical package: `@bash0816/claude-code`
 
 ## Install / インストール
 
 ```sh
-npm install -g @bash0816/claude-code@latest
+npm install -g @bash0816/cluade-code@latest
 ```
 
 If an older audited launcher from this repository already exists at `$PREFIX/bin/claude`, migrate through the updated launcher.
@@ -27,37 +29,19 @@ If npm reports `EEXIST` before package scripts run, use a one-time forced migrat
 package script 実行前に npm が `EEXIST` を返す場合は、初回だけ forced migration を使います。
 
 ```sh
-npm install -g --force @bash0816/claude-code@latest
+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 versions:
+Specific audited version:
 
 監査済みの固定 version:
 
-Current quick examples:
-
-現在の quick example:
-
 ```sh
-npm install -g @bash0816/claude-code@2.1.118
-npm install -g @bash0816/claude-code@2.1.119
-npm install -g @bash0816/claude-code@2.1.121
-npm install -g @bash0816/claude-code@2.1.122
-npm install -g @bash0816/claude-code@2.1.123
-npm install -g @bash0816/claude-code@2.1.126
-npm install -g @bash0816/claude-code@2.1.128
-npm install -g @bash0816/claude-code@2.1.136
-npm install -g @bash0816/claude-code@2.1.137
-npm install -g @bash0816/claude-code@2.1.138
-npm install -g @bash0816/claude-code@2.1.139
-npm install -g @bash0816/claude-code@2.1.140
-npm install -g @bash0816/claude-code@2.1.141
-npm install -g @bash0816/claude-code@2.1.142
-npm install -g @bash0816/claude-code@2.1.143
+npm install -g @bash0816/cluade-code@2.1.123
 ```
 
 ## Update / 更新
@@ -66,9 +50,17 @@ npm install -g @bash0816/claude-code@2.1.143
 claude update
 ```
 
-`claude update` installs the latest audited package version.
+`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.
 
-`claude update` は最新の監査済み package version を install します。
+この最終 bridge package は package version `2.1.123` で凍結し、同期済み metadata 集合から既定では監査済み native `2.1.150` を起動します。
 
 ```sh
 npm install -g @bash0816/claude-code@<latest_audited_version>
@@ -82,10 +74,10 @@ Normal launch also checks the same manifest with a short timeout and prints a no
 
 - Only audited versions in `config/claude-native-audited-versions.json` can run.
 - `config/claude-native-audited-versions.json` にある監査済み version だけを実行できます。
-- `2.1.118`, `2.1.119`, `2.1.121`, `2.1.122`, `2.1.123`, `2.1.126`, `2.1.128`, `2.1.136`, `2.1.137`, `2.1.138`, `2.1.139`, `2.1.140`, `2.1.141`, `2.1.142`, `2.1.143` are included in the package metadata.
-- `2.1.118`、`2.1.119`、`2.1.121`、`2.1.122`、`2.1.123`、`2.1.126`、`2.1.128`、`2.1.136`、`2.1.137`、`2.1.138`、`2.1.139`、`2.1.140`、`2.1.141`、`2.1.142`、`2.1.143` を package metadata に含めています。
-- The metadata file is the source of truth for the currently audited set.
-- 現在の監査済み version 集合の source of truth は metadata file です。
+- 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.

package/bin/claude

@@ -14,7 +14,8 @@ done
 PACKAGE_DIR=$(CDPATH= cd -- "$(dirname -- "${SELF}")/.." && pwd)
 CONFIG_FILE="${PACKAGE_DIR}/config/claude-native-audited-versions.json"
 PACKAGE_VERSION=$(node -e 'const fs=require("fs"); const path=require("path"); const p=JSON.parse(fs.readFileSync(path.join(process.argv[1],"package.json"),"utf8")); process.stdout.write(p.version)' "${PACKAGE_DIR}")
-CLAUDE_VERSION="${CLAUDE_TERMUX_CLAUDE_VERSION:-${PACKAGE_VERSION}}"
+DEFAULT_NATIVE_VERSION=$(node -e 'const fs=require("fs"); const path=require("path"); const p=JSON.parse(fs.readFileSync(path.join(process.argv[1],"config","claude-termux-release-manifest.json"),"utf8")); process.stdout.write(String(p.default_native_version || p.latest_audited_version || ""))' "${PACKAGE_DIR}")
+CLAUDE_VERSION="${CLAUDE_TERMUX_CLAUDE_VERSION:-${DEFAULT_NATIVE_VERSION:-${PACKAGE_VERSION}}}"
 UPDATE_HELPER="${PACKAGE_DIR}/lib/check-updates.js"
 
 if [ "${1:-}" = "update" ]; then
@@ -57,6 +58,5 @@ WORKDIR="${CACHE_DIR}/launcher-workdir" \
 ENTRY_JS_OFFSET="${ENTRY_JS_OFFSET}" \
 ENTRY_END_OFFSET="${ENTRY_END_OFFSET}" \
 CURRENT_CLAUDE_VERSION="${CLAUDE_VERSION}" \
-CLAUDE_TERMUX_PACKAGE_DIR="${PACKAGE_DIR}" \
 CLAUDE_NATIVE_UPDATE_CHECK=0 \
 exec sh "${PACKAGE_DIR}/lib/termux-run-claude-native.sh" "$@"

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

@@ -104,6 +104,27 @@
       "entry_js_offset": 216602500,
       "entry_end_offset": 231151175,
       "status": "termux_verified"
+    },
+    "2.1.144": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.144",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.144",
+      "entry_js_offset": 216877940,
+      "entry_end_offset": 231466269,
+      "status": "termux_verified"
+    },
+    "2.1.150": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.150",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.150",
+      "entry_js_offset": 221278436,
+      "entry_end_offset": 236586147,
+      "status": "termux_verified"
+    },
+    "2.1.150-1": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.150",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.150",
+      "entry_js_offset": 221278436,
+      "entry_end_offset": 236586147,
+      "status": "termux_verified"
     }
   }
 }

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

@@ -1,8 +1,13 @@
 {
   "manifest_version": 1,
   "package_name": "@bash0816/claude-code",
-  "latest_audited_version": "2.1.143",
-  "latest_candidate_version": "2.1.143",
-  "previous_stable_version": "2.1.142",
-  "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
+  "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.123",
+  "default_native_version": "2.1.150-1",
+  "latest_audited_version": "2.1.150-1",
+  "latest_candidate_version": "2.1.150-1",
+  "previous_stable_version": "2.1.150",
+  "manifest_url": "https://raw.githubusercontent.com/bash0816/CluadeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

package/lib/check-updates.js

@@ -19,6 +19,9 @@ const timeoutMs = Number(process.env.CLAUDE_TERMUX_UPDATE_TIMEOUT_MS || '1200');
 const ttlMs = Number(process.env.CLAUDE_TERMUX_UPDATE_CACHE_TTL_MS || String(24 * 60 * 60 * 1000));
 const skipCheck = process.env.CLAUDE_TERMUX_SKIP_UPDATE_CHECK === '1';
 const manifestUrl = process.env.CLAUDE_TERMUX_MANIFEST_URL || localManifest.manifest_url;
+const canonicalManifestUrl = process.env.CLAUDE_TERMUX_CANONICAL_MANIFEST_URL || localManifest.canonical_manifest_url || '';
+const canonicalPackageName = process.env.CLAUDE_TERMUX_CANONICAL_PACKAGE_NAME || localManifest.canonical_package_name || '';
+const canonicalRepositoryUrl = process.env.CLAUDE_TERMUX_CANONICAL_REPOSITORY_URL || localManifest.canonical_repository_url || '';
 
 function compareVersions(a, b) {
   const aParts = String(a).split('.').map(Number);
@@ -102,10 +105,64 @@ async function resolveManifest(forceRefresh) {
   }
 }
 
-function updateNoticeCache(cache, latestVersion) {
+async function resolveCanonicalManifest() {
+  if (!canonicalManifestUrl || !canonicalPackageName || canonicalPackageName === pkg.name) {
+    return null;
+  }
+
+  if (skipCheck) {
+    return {
+      packageName: canonicalPackageName,
+      latestVersion: localManifest.latest_audited_version || pkg.version,
+      repositoryUrl: canonicalRepositoryUrl,
+    };
+  }
+
+  try {
+    const manifest = await fetchManifest(canonicalManifestUrl);
+    return {
+      packageName: manifest.package_name || canonicalPackageName,
+      latestVersion: manifest.latest_audited_version || localManifest.latest_audited_version || pkg.version,
+      repositoryUrl: canonicalRepositoryUrl,
+    };
+  } catch {
+    return {
+      packageName: canonicalPackageName,
+      latestVersion: localManifest.latest_audited_version || pkg.version,
+      repositoryUrl: canonicalRepositoryUrl,
+    };
+  }
+}
+
+async function resolveTarget(forceRefresh) {
+  const base = await resolveManifest(forceRefresh);
+  const canonical = await resolveCanonicalManifest();
+  if (!canonical) {
+    return {
+      manifest: base.manifest,
+      cache: base.cache,
+      packageName: base.manifest.package_name || pkg.name,
+      targetVersion: base.manifest.latest_audited_version || localManifest.latest_audited_version || pkg.version,
+      repositoryUrl: '',
+      migration: false,
+    };
+  }
+
+  return {
+    manifest: base.manifest,
+    cache: base.cache,
+    packageName: canonical.packageName,
+    targetVersion: canonical.latestVersion,
+    repositoryUrl: canonical.repositoryUrl,
+    migration: canonical.packageName !== pkg.name,
+  };
+}
+
+function updateNoticeCache(cache, packageName, latestVersion) {
   const nextCache = {
     ...cache,
     last_notice: {
+      package_name: packageName,
       current_version: currentVersion,
       latest_audited_version: latestVersion,
       notified_at: Date.now(),
@@ -114,16 +171,17 @@ function updateNoticeCache(cache, latestVersion) {
   writeCache(nextCache);
 }
 
-function shouldNotify(cache, latestVersion) {
+function shouldNotify(cache, packageName, latestVersion) {
   const lastNotice = cache.last_notice;
   if (!lastNotice) return true;
+  if (lastNotice.package_name !== packageName) return true;
   if (lastNotice.current_version !== currentVersion) return true;
   if (lastNotice.latest_audited_version !== latestVersion) return true;
   return Date.now() - Number(lastNotice.notified_at || 0) >= ttlMs;
 }
 
-function installTarget(targetVersion) {
-  const spec = `${pkg.name}@${targetVersion}`;
+function installTarget(packageName, targetVersion) {
+  const spec = `${packageName}@${targetVersion}`;
   const command = `npm install -g ${spec}`;
 
   if (dryRun) {
@@ -140,25 +198,40 @@ function installTarget(targetVersion) {
 }
 
 async function runNotify() {
-  const { manifest, cache } = await resolveManifest(false);
-  const latest = manifest.latest_audited_version || localManifest.latest_audited_version || pkg.version;
-  if (compareVersions(currentVersion, latest) >= 0) return 0;
-  if (!shouldNotify(cache, latest)) return 0;
+  const target = await resolveTarget(false);
+  const latest = target.targetVersion;
+  const packageName = target.packageName;
+  const migration = target.migration;
+  if (!migration && compareVersions(currentVersion, latest) >= 0) return 0;
+  if (!shouldNotify(target.cache, packageName, latest)) return 0;
+
+  if (migration) {
+    console.error(`Legacy package detected: ${pkg.name}`);
+    console.error(`Canonical package available: ${packageName}@${latest}`);
+    if (target.repositoryUrl) {
+      console.error(`Canonical repository: ${target.repositoryUrl}`);
+    }
+    console.error('Run: claude update');
+    updateNoticeCache(target.cache, packageName, latest);
+    return 0;
+  }
 
   console.error(`Audited update available: ${currentVersion} -> ${latest}`);
   console.error('Run: claude update');
-  updateNoticeCache(cache, latest);
+  updateNoticeCache(target.cache, packageName, latest);
   return 0;
 }
 
 async function runUpdate() {
-  const { manifest } = await resolveManifest(true);
-  const target = manifest.latest_audited_version || localManifest.latest_audited_version || pkg.version;
-  if (compareVersions(currentVersion, target) >= 0) {
+  const target = await resolveTarget(true);
+  if (!target.migration && compareVersions(currentVersion, target.targetVersion) >= 0) {
     console.error(`Already on latest audited version: ${currentVersion}`);
     return 0;
   }
-  return installTarget(target);
+  if (target.migration) {
+    console.error(`Migrating from legacy package ${pkg.name} to canonical package ${target.packageName}@${target.targetVersion}`);
+  }
+  return installTarget(target.packageName, target.targetVersion);
 }
 
 async function main() {

package/lib/postinstall.js

@@ -10,8 +10,9 @@ if (process.env.CLAUDE_TERMUX_SKIP_POSTINSTALL === '1') {
 
 const packageDir = path.resolve(__dirname, '..');
 const pkg = require(path.join(packageDir, 'package.json'));
+const manifest = require(path.join(packageDir, 'config', 'claude-termux-release-manifest.json'));
 const script = path.join(__dirname, 'prepare-native.js');
-const version = process.env.CLAUDE_TERMUX_CLAUDE_VERSION || pkg.version;
+const version = process.env.CLAUDE_TERMUX_CLAUDE_VERSION || manifest.default_native_version || manifest.latest_audited_version || pkg.version;
 
 const result = cp.spawnSync(process.execPath, [script, version], {
   stdio: 'inherit',

package/lib/prepare-native.js

@@ -9,11 +9,9 @@ const path = require('path');
 const packageDir = path.resolve(__dirname, '..');
 const config = require(path.join(packageDir, 'config', 'claude-native-audited-versions.json'));
 const pkg = require(path.join(packageDir, 'package.json'));
-const version = process.argv[2] || pkg.version;
+const manifest = require(path.join(packageDir, 'config', 'claude-termux-release-manifest.json'));
+const version = process.argv[2] || manifest.default_native_version || manifest.latest_audited_version || pkg.version;
 const item = config.versions[version];
-const curlRetries = process.env.CLAUDE_TERMUX_FETCH_RETRIES || '4';
-const curlConnectTimeout = process.env.CLAUDE_TERMUX_FETCH_CONNECT_TIMEOUT || '20';
-const curlMaxTime = process.env.CLAUDE_TERMUX_FETCH_MAX_TIME || '300';
 
 if (!item) {
   console.error(`Unsupported audited Claude Code version: ${version}`);
@@ -31,14 +29,18 @@ if (fs.existsSync(sourceBin)) {
 }
 
 fs.mkdirSync(versionDir, { recursive: true });
-const packDir = fs.mkdtempSync(path.join(os.tmpdir(), `claude-code-${version}-`));
+const packDir = fs.mkdtempSync(path.join(os.tmpdir(), `cluade-code-${version}-`));
 
 try {
-  const tgzPath = fetchNativeTarball(item.native_spec, packDir);
+  run('npm', ['pack', item.native_spec, '--pack-destination', packDir]);
+  const tgz = fs.readdirSync(packDir).find(name => name.endsWith('.tgz'));
+  if (!tgz) {
+    throw new Error('npm pack did not produce a tgz');
+  }
 
   const extractDir = path.join(packDir, 'native');
   fs.mkdirSync(extractDir, { recursive: true });
-  run('tar', ['-xzf', tgzPath, '-C', extractDir]);
+  run('tar', ['-xzf', path.join(packDir, tgz), '-C', extractDir]);
 
   fs.rmSync(nativeDest, { recursive: true, force: true });
   fs.mkdirSync(path.dirname(nativeDest), { recursive: true });
@@ -55,50 +57,6 @@ function run(command, args) {
   }
 }
 
-function runCapture(command, args) {
-  const result = cp.spawnSync(command, args, {
-    stdio: ['ignore', 'pipe', 'inherit'],
-    encoding: 'utf8',
-  });
-  if (result.status !== 0) {
-    throw new Error(`${command} ${args.join(' ')} failed`);
-  }
-  return result.stdout.trim();
-}
-
-function fetchNativeTarball(spec, packDir) {
-  const directTarball = path.join(packDir, 'native-package.tgz');
-
-  try {
-    const tarballUrl = runCapture('npm', ['view', spec, 'dist.tarball', '--json']).replace(/^"|"$/g, '');
-    if (!tarballUrl) {
-      throw new Error(`npm view did not return dist.tarball for ${spec}`);
-    }
-    run('curl', [
-      '--fail',
-      '--location',
-      '--retry', String(curlRetries),
-      '--connect-timeout', String(curlConnectTimeout),
-      '--max-time', String(curlMaxTime),
-      '--output', directTarball,
-      tarballUrl,
-    ]);
-    if (fs.existsSync(directTarball)) {
-      return directTarball;
-    }
-  } catch (error) {
-    console.error(`Direct tarball fetch failed for ${spec}; falling back to npm pack.`);
-    console.error(error && error.message ? error.message : String(error));
-  }
-
-  run('npm', ['pack', spec, '--pack-destination', packDir]);
-  const tgz = fs.readdirSync(packDir).find(name => name.endsWith('.tgz'));
-  if (!tgz) {
-    throw new Error('npm pack did not produce a tgz');
-  }
-  return path.join(packDir, tgz);
-}
-
 function validateOffsets(file, audited) {
   const buf = fs.readFileSync(file);
   const start = Number(audited.entry_js_offset);

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,189 @@ 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 child = childProcess.spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      detached: options.detached,
+      stdio: options.stdio || 'pipe',
+      windowsHide: options.windowsHide,
+    });
+    child.exited = new Promise(resolve => {
+      child.once('exit', (code, signal) => resolve({ code, signal }));
+    });
+    return child;
+  }
+
+  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).split('.').map(Number);
+      const rightParts = String(right).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;
+      }
+      return 0;
+    },
+  };
+
+  return {
+    version: '1.1.8',
+    gc: typeof global.gc === 'function' ? () => global.gc() : () => {},
+    hash,
+    listen,
+    semver,
+    spawn,
+    stdin: process.stdin,
+    stripANSI,
+    stringWidth,
+    which,
+    wrapAnsi: value => String(value ?? ''),
+  };
+}
+
 async function main() {
   const extractedFile = ensureEntryFile();
   const code = fs.readFileSync(extractedFile, 'utf8');
@@ -166,7 +323,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 +358,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.143",
+  "version": "2.1.150-1",
   "description": "Termux-native Claude Code wrapper with audited native replay",
   "license": "MIT",
   "bin": {

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,
-};

package/lib/native-update-guard.test.js

@@ -1,310 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const EventEmitter = require('events');
-
-const {
-  BLOCK_MESSAGE,
-  createGuardedChildProcess,
-  shouldBlockCommand,
-  shouldBlockExecString,
-} = require('./native-update-guard.js');
-
-test('blocks npm install of official package', () => {
-  assert.equal(
-    shouldBlockCommand('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']),
-    true,
-  );
-});
-
-test('blocks npm update of official package via absolute npm path', () => {
-  assert.equal(
-    shouldBlockCommand('/usr/bin/npm', ['update', '-g', '@anthropic-ai/claude-code']),
-    true,
-  );
-});
-
-test('does not block canonical package install', () => {
-  assert.equal(
-    shouldBlockCommand('npm', ['install', '-g', '@bash0816/claude-code@2.1.137']),
-    false,
-  );
-});
-
-test('blocks exec string that installs official package', () => {
-  assert.equal(
-    shouldBlockExecString('npm install -g @anthropic-ai/claude-code@latest'),
-    true,
-  );
-});
-
-test('does not block unrelated exec string', () => {
-  assert.equal(
-    shouldBlockExecString('npm install -g @bash0816/claude-code@2.1.137'),
-    false,
-  );
-});
-
-test('blocks env npm install of official package', () => {
-  assert.equal(
-    shouldBlockCommand('env', ['FOO=bar', 'npm', 'install', '-g', '@anthropic-ai/claude-code@latest']),
-    true,
-  );
-});
-
-test('blocks npx official package invocation', () => {
-  assert.equal(shouldBlockCommand('npx', ['@anthropic-ai/claude-code']), true);
-});
-
-test('blocks npx package option official package invocation', () => {
-  assert.equal(shouldBlockCommand('npx', ['-p', '@anthropic-ai/claude-code', 'claude']), true);
-  assert.equal(shouldBlockCommand('npx', ['--package=@anthropic-ai/claude-code', 'claude']), true);
-});
-
-test('blocks pnpm add of official package', () => {
-  assert.equal(
-    shouldBlockCommand('pnpm', ['add', '-g', '@anthropic-ai/claude-code']),
-    true,
-  );
-});
-
-test('blocks yarn global add of official package', () => {
-  assert.equal(
-    shouldBlockCommand('yarn', ['global', 'add', '@anthropic-ai/claude-code']),
-    true,
-  );
-});
-
-test('blocks corepack pnpm add of official package', () => {
-  assert.equal(
-    shouldBlockCommand('corepack', ['pnpm', 'add', '-g', '@anthropic-ai/claude-code']),
-    true,
-  );
-});
-
-test('blocks corepack yarn global add of official package', () => {
-  assert.equal(
-    shouldBlockCommand('corepack', ['yarn', 'global', 'add', '@anthropic-ai/claude-code']),
-    true,
-  );
-});
-
-test('does not block corepack pnpm add of canonical package', () => {
-  assert.equal(
-    shouldBlockCommand('corepack', ['pnpm', 'add', '-g', '@bash0816/claude-code@2.1.137']),
-    false,
-  );
-});
-
-test('blocks exec string through env npm', () => {
-  assert.equal(
-    shouldBlockExecString('env FOO=bar npm install -g @anthropic-ai/claude-code@latest'),
-    true,
-  );
-});
-
-test('blocks exec string through corepack yarn', () => {
-  assert.equal(
-    shouldBlockExecString('corepack yarn global add @anthropic-ai/claude-code'),
-    true,
-  );
-});
-
-test('blocks exec string through sh -c npm install', () => {
-  assert.equal(
-    shouldBlockExecString('sh -c "npm install -g @anthropic-ai/claude-code"'),
-    true,
-  );
-});
-
-test('blocks exec string through bash -lc pnpm add', () => {
-  assert.equal(
-    shouldBlockExecString('bash -lc "pnpm add -g @anthropic-ai/claude-code"'),
-    true,
-  );
-});
-
-test('does not block canonical exec string through bash -lc', () => {
-  assert.equal(
-    shouldBlockExecString('bash -lc "npm install -g @bash0816/claude-code@2.1.137"'),
-    false,
-  );
-});
-
-test('does not block unrelated shell exec string', () => {
-  assert.equal(shouldBlockExecString('sh -c "echo ok"'), false);
-});
-
-function createRealChildStub() {
-  const calls = [];
-  return {
-    calls,
-    spawn(...args) {
-      calls.push(['spawn', args]);
-      return { kind: 'spawn', args };
-    },
-    execFile(...args) {
-      calls.push(['execFile', args]);
-      return { kind: 'execFile', args };
-    },
-    exec(...args) {
-      calls.push(['exec', args]);
-      return { kind: 'exec', args };
-    },
-    spawnSync(...args) {
-      calls.push(['spawnSync', args]);
-      return { kind: 'spawnSync', args, status: 0 };
-    },
-    execFileSync(...args) {
-      calls.push(['execFileSync', args]);
-      return Buffer.from('ok');
-    },
-    execSync(...args) {
-      calls.push(['execSync', args]);
-      return Buffer.from('ok');
-    },
-  };
-}
-
-test('guarded spawn blocks official npm update without delegating', async () => {
-  const writes = [];
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
-
-  const child = guarded.spawn('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']);
-  assert.equal(child instanceof EventEmitter, true);
-
-  const result = await new Promise(resolve => {
-    child.once('close', (code, signal) => resolve({ code, signal }));
-  });
-
-  assert.deepEqual(result, { code: 1, signal: null });
-  assert.deepEqual(realChild.calls, []);
-  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
-});
-
-test('guarded spawn delegates canonical install', () => {
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, () => {});
-  const result = guarded.spawn('npm', ['install', '-g', '@bash0816/claude-code@2.1.137']);
-
-  assert.equal(result.kind, 'spawn');
-  assert.equal(realChild.calls.length, 1);
-});
-
-test('guarded execFile blocks official npm update callback path', async () => {
-  const writes = [];
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
-
-  const callbackResult = await new Promise(resolve => {
-    guarded.execFile(
-      'npm',
-      ['update', '-g', '@anthropic-ai/claude-code'],
-      (error, stdout, stderr) => resolve({ error, stdout, stderr }),
-    );
-  });
-
-  assert.equal(callbackResult.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
-  assert.equal(callbackResult.stdout, '');
-  assert.equal(callbackResult.stderr, `${BLOCK_MESSAGE}\n`);
-  assert.deepEqual(realChild.calls, []);
-  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
-});
-
-test('guarded exec blocks official npm update shell string', async () => {
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, () => {});
-
-  const callbackResult = await new Promise(resolve => {
-    guarded.exec(
-      'npm install -g @anthropic-ai/claude-code@latest',
-      (error, stdout, stderr) => resolve({ error, stdout, stderr }),
-    );
-  });
-
-  assert.equal(callbackResult.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
-  assert.equal(callbackResult.stdout, '');
-  assert.equal(callbackResult.stderr, `${BLOCK_MESSAGE}\n`);
-  assert.deepEqual(realChild.calls, []);
-});
-
-test('guarded spawnSync blocks official npm update with status 1', () => {
-  const writes = [];
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
-  const result = guarded.spawnSync('npm', ['update', '-g', '@anthropic-ai/claude-code']);
-
-  assert.equal(result.status, 1);
-  assert.equal(Buffer.isBuffer(result.stderr), true);
-  assert.equal(String(result.stderr), `${BLOCK_MESSAGE}\n`);
-  assert.equal(result.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
-  assert.deepEqual(realChild.calls, []);
-  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
-});
-
-test('guarded execFileSync throws on official npm update', () => {
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, () => {});
-
-  assert.throws(
-    () => guarded.execFileSync('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']),
-    error => error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED',
-  );
-  assert.deepEqual(realChild.calls, []);
-});
-
-test('guarded execSync throws on official npm update shell string', () => {
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, () => {});
-
-  assert.throws(
-    () => guarded.execSync('npm update -g @anthropic-ai/claude-code'),
-    error => error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED',
-  );
-  assert.deepEqual(realChild.calls, []);
-});
-
-test('guarded spawn blocks official npm update through sh -c', async () => {
-  const writes = [];
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
-
-  const child = guarded.spawn('/bin/sh', ['-c', 'npm install -g @anthropic-ai/claude-code']);
-  const result = await new Promise(resolve => {
-    child.once('close', (code, signal) => resolve({ code, signal }));
-  });
-
-  assert.deepEqual(result, { code: 1, signal: null });
-  assert.deepEqual(realChild.calls, []);
-  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
-});
-
-test('guarded execFile blocks official update through bash -lc', async () => {
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, () => {});
-
-  const callbackResult = await new Promise(resolve => {
-    guarded.execFile(
-      '/usr/bin/bash',
-      ['-lc', 'pnpm add -g @anthropic-ai/claude-code'],
-      (error, stdout, stderr) => resolve({ error, stdout, stderr }),
-    );
-  });
-
-  assert.equal(callbackResult.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
-  assert.equal(callbackResult.stdout, '');
-  assert.equal(callbackResult.stderr, `${BLOCK_MESSAGE}\n`);
-  assert.deepEqual(realChild.calls, []);
-});
-
-test('guarded spawn delegates canonical shell install', () => {
-  const realChild = createRealChildStub();
-  const guarded = createGuardedChildProcess(realChild, () => {});
-  const result = guarded.spawn('/bin/sh', ['-c', 'npm install -g @bash0816/claude-code@2.1.137']);
-
-  assert.equal(result.kind, 'spawn');
-  assert.equal(realChild.calls.length, 1);
-});