@bash0816/claude-code 2.1.122

package/README.md

@@ -0,0 +1,92 @@
+# @bash0816/claude-code
+
+Termux-native Claude Code wrapper package.
+
+Termux 向け Claude Code native wrapper package です。
+
+Canonical repository:
+
+正規 repository:
+
+- `https://github.com/bash0816/ClaudeCode-Termux`
+
+This package is part of the move from the legacy typo repository to `ClaudeCode-Termux`.
+
+この package は、旧 typo repository から `ClaudeCode-Termux` へ移行する正規導線です。
+
+## Install / インストール
+
+```sh
+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.
+
+この repository の古い監査済み launcher が `$PREFIX/bin/claude` にある場合は、更新済み launcher 経由で移行します。
+
+```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/claude-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:
+
+監査済みの固定 version:
+
+```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
+```
+
+Development override:
+
+開発・検証用 override:
+
+```sh
+CLAUDE_TERMUX_CLAUDE_VERSION=2.1.118 claude --version
+CLAUDE_TERMUX_CLAUDE_VERSION=2.1.119 claude --version
+CLAUDE_TERMUX_CLAUDE_VERSION=2.1.121 claude --version
+CLAUDE_TERMUX_CLAUDE_VERSION=2.1.122 claude --version
+```
+
+## 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 します。
+
+```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 があれば通知します。
+
+## Policy / 方針
+
+- 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`, and `2.1.122` are included in the package metadata.
+- `2.1.118`、`2.1.119`、`2.1.121`、`2.1.122` を package metadata に含めています。
+- 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 で終了します。

package/bin/claude

@@ -0,0 +1,61 @@
+#!/usr/bin/env sh
+set -eu
+
+SELF="$0"
+while [ -L "${SELF}" ]; do
+  DIR=$(CDPATH= cd -- "$(dirname -- "${SELF}")" && pwd)
+  TARGET=$(readlink "${SELF}")
+  case "${TARGET}" in
+    /*) SELF="${TARGET}" ;;
+    *) SELF="${DIR}/${TARGET}" ;;
+  esac
+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}}"
+UPDATE_HELPER="${PACKAGE_DIR}/lib/check-updates.js"
+
+if [ "${1:-}" = "update" ]; then
+  shift
+  exec node "${UPDATE_HELPER}" update "${CLAUDE_VERSION}" "$@"
+fi
+
+node "${UPDATE_HELPER}" notify "${CLAUDE_VERSION}" || true
+
+json_field() {
+  node -e '
+const fs = require("fs");
+const config = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+const version = process.argv[2];
+const field = process.argv[3];
+const item = config.versions[version];
+if (!item || item[field] === undefined) {
+  process.exit(1);
+}
+process.stdout.write(String(item[field]));
+' "${CONFIG_FILE}" "${CLAUDE_VERSION}" "$1"
+}
+
+ENTRY_JS_OFFSET=$(json_field entry_js_offset)
+ENTRY_END_OFFSET=$(json_field entry_end_offset)
+CACHE_DIR="${CLAUDE_TERMUX_PACKAGE_CACHE:-${HOME}/.claude-termux-native-package}/versions/${CLAUDE_VERSION}"
+SOURCE_BIN="${CACHE_DIR}/app/node_modules/@anthropic-ai/claude-code-linux-arm64/claude"
+
+if [ ! -f "${SOURCE_BIN}" ]; then
+  node "${PACKAGE_DIR}/lib/prepare-native.js" "${CLAUDE_VERSION}"
+fi
+
+if [ ! -f "${SOURCE_BIN}" ]; then
+  echo "Failed to prepare native Claude Code binary: ${SOURCE_BIN}" >&2
+  exit 1
+fi
+
+SOURCE_BIN="${SOURCE_BIN}" \
+WORKDIR="${CACHE_DIR}/launcher-workdir" \
+ENTRY_JS_OFFSET="${ENTRY_JS_OFFSET}" \
+ENTRY_END_OFFSET="${ENTRY_END_OFFSET}" \
+CURRENT_CLAUDE_VERSION="${CLAUDE_VERSION}" \
+CLAUDE_NATIVE_UPDATE_CHECK=0 \
+exec sh "${PACKAGE_DIR}/lib/termux-run-claude-native.sh" "$@"

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

@@ -0,0 +1,32 @@
+{
+  "versions": {
+    "2.1.118": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.118",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.118",
+      "entry_js_offset": 224788180,
+      "entry_end_offset": 238022890,
+      "status": "termux_verified"
+    },
+    "2.1.119": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.119",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.119",
+      "entry_js_offset": 229972324,
+      "entry_end_offset": 243693409,
+      "status": "termux_verified"
+    },
+    "2.1.121": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.121",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.121",
+      "entry_js_offset": 231769700,
+      "entry_end_offset": 245677986,
+      "status": "termux_verified"
+    },
+    "2.1.122": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.122",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.122",
+      "entry_js_offset": 232193716,
+      "entry_end_offset": 246143358,
+      "status": "termux_verified"
+    }
+  }
+}

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

@@ -0,0 +1,8 @@
+{
+  "manifest_version": 1,
+  "package_name": "@bash0816/claude-code",
+  "latest_audited_version": "2.1.122",
+  "latest_candidate_version": "2.1.122",
+  "previous_stable_version": "2.1.121",
+  "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/dev/config/claude-termux-release-manifest.json"
+}

package/lib/check-updates.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+'use strict';
+
+const cp = require('child_process');
+const fs = require('fs');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+
+const packageDir = path.resolve(__dirname, '..');
+const pkg = require(path.join(packageDir, 'package.json'));
+const localManifest = require(path.join(packageDir, 'config', 'claude-termux-release-manifest.json'));
+const mode = process.argv[2] || 'notify';
+const currentVersion = process.argv[3] || pkg.version;
+const dryRun = process.argv.includes('--dry-run');
+const cacheRoot = process.env.CLAUDE_TERMUX_PACKAGE_CACHE || path.join(os.homedir(), '.claude-termux-native-package');
+const cacheFile = path.join(cacheRoot, 'update-check.json');
+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;
+
+function compareVersions(a, b) {
+  const aParts = String(a).split('.').map(Number);
+  const bParts = String(b).split('.').map(Number);
+  const len = Math.max(aParts.length, bParts.length);
+  for (let index = 0; index < len; index += 1) {
+    const diff = (aParts[index] || 0) - (bParts[index] || 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+function readCache() {
+  try {
+    return JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeCache(cache) {
+  fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+  fs.writeFileSync(cacheFile, JSON.stringify(cache, null, 2) + '\n');
+}
+
+function fetchManifest(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: timeoutMs }, response => {
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`manifest fetch failed: HTTP ${response.statusCode}`));
+        return;
+      }
+
+      let body = '';
+      response.setEncoding('utf8');
+      response.on('data', chunk => {
+        body += chunk;
+      });
+      response.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy(new Error('manifest fetch timeout'));
+    });
+    req.on('error', reject);
+  });
+}
+
+async function resolveManifest(forceRefresh) {
+  if (skipCheck) {
+    return { manifest: localManifest, cache: readCache() };
+  }
+
+  const cache = readCache();
+  const now = Date.now();
+  if (!forceRefresh && cache.manifest && cache.fetched_at && now - cache.fetched_at < ttlMs) {
+    return { manifest: cache.manifest, cache };
+  }
+
+  try {
+    const manifest = await fetchManifest(manifestUrl);
+    const nextCache = {
+      ...cache,
+      fetched_at: now,
+      manifest,
+    };
+    writeCache(nextCache);
+    return { manifest, cache: nextCache };
+  } catch {
+    if (cache.manifest) {
+      return { manifest: cache.manifest, cache };
+    }
+    return { manifest: localManifest, cache };
+  }
+}
+
+function updateNoticeCache(cache, latestVersion) {
+  const nextCache = {
+    ...cache,
+    last_notice: {
+      current_version: currentVersion,
+      latest_audited_version: latestVersion,
+      notified_at: Date.now(),
+    },
+  };
+  writeCache(nextCache);
+}
+
+function shouldNotify(cache, latestVersion) {
+  const lastNotice = cache.last_notice;
+  if (!lastNotice) 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}`;
+  const command = `npm install -g ${spec}`;
+
+  if (dryRun) {
+    console.log(command);
+    return 0;
+  }
+
+  console.error(`Updating to audited version ${targetVersion}`);
+  const result = cp.spawnSync('npm', ['install', '-g', spec], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  return result.status === null ? 1 : result.status;
+}
+
+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;
+
+  console.error(`Audited update available: ${currentVersion} -> ${latest}`);
+  console.error('Run: claude update');
+  updateNoticeCache(cache, 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) {
+    console.error(`Already on latest audited version: ${currentVersion}`);
+    return 0;
+  }
+  return installTarget(target);
+}
+
+async function main() {
+  if (mode === 'notify') {
+    process.exitCode = await runNotify();
+    return;
+  }
+
+  if (mode === 'update') {
+    process.exitCode = await runUpdate();
+    return;
+  }
+
+  throw new Error(`Unknown mode: ${mode}`);
+}
+
+main().catch(error => {
+  console.error(error && error.stack ? error.stack : String(error));
+  process.exit(1);
+});

package/lib/postinstall.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+'use strict';
+
+const cp = require('child_process');
+const path = require('path');
+
+if (process.env.CLAUDE_TERMUX_SKIP_POSTINSTALL === '1') {
+  process.exit(0);
+}
+
+const packageDir = path.resolve(__dirname, '..');
+const pkg = require(path.join(packageDir, 'package.json'));
+const script = path.join(__dirname, 'prepare-native.js');
+const version = process.env.CLAUDE_TERMUX_CLAUDE_VERSION || pkg.version;
+
+const result = cp.spawnSync(process.execPath, [script, version], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+process.exit(result.status === null ? 1 : result.status);

package/lib/preinstall.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+'use strict';
+
+const cp = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+if (process.env.CLAUDE_TERMUX_SKIP_PREINSTALL === '1') {
+  process.exit(0);
+}
+
+const markers = [
+  'CLAUDE_NATIVE_118_CANDIDATE_MARKER',
+  'CLAUDE_NATIVE_AUDITED_CANDIDATE_MARKER',
+];
+
+const prefix = process.env.PREFIX || detectNpmPrefix();
+if (!prefix) {
+  process.exit(0);
+}
+
+const target = path.join(prefix, 'bin', 'claude');
+if (!fs.existsSync(target)) {
+  process.exit(0);
+}
+
+try {
+  const stat = fs.lstatSync(target);
+  if (stat.isSymbolicLink()) {
+    process.exit(0);
+  }
+
+  const head = fs.readFileSync(target, 'utf8').slice(0, 8192);
+  if (!markers.some(marker => head.includes(marker))) {
+    console.error(`Refusing to replace unmanaged existing claude binary: ${target}`);
+    process.exit(1);
+  }
+
+  const backupDir = path.join(os.homedir(), '.claude-termux-native-package', 'preinstall-backups');
+  fs.mkdirSync(backupDir, { recursive: true });
+  const backup = path.join(backupDir, `claude.${new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, 'Z')}`);
+  fs.renameSync(target, backup);
+  console.error(`Moved existing audited Claude launcher to ${backup}`);
+} catch (error) {
+  console.error(error && error.stack ? error.stack : String(error));
+  process.exit(1);
+}
+
+function detectNpmPrefix() {
+  const result = cp.spawnSync('npm', ['prefix', '-g'], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    return '';
+  }
+  return result.stdout.trim();
+}

package/lib/prepare-native.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+'use strict';
+
+const cp = require('child_process');
+const fs = require('fs');
+const os = require('os');
+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 item = config.versions[version];
+
+if (!item) {
+  console.error(`Unsupported audited Claude Code version: ${version}`);
+  process.exit(1);
+}
+
+const cacheRoot = process.env.CLAUDE_TERMUX_PACKAGE_CACHE || path.join(os.homedir(), '.claude-termux-native-package');
+const versionDir = path.join(cacheRoot, 'versions', version);
+const nativeDest = path.join(versionDir, 'app', 'node_modules', '@anthropic-ai', 'claude-code-linux-arm64');
+const sourceBin = path.join(nativeDest, 'claude');
+
+if (fs.existsSync(sourceBin)) {
+  validateOffsets(sourceBin, item);
+  process.exit(0);
+}
+
+fs.mkdirSync(versionDir, { recursive: true });
+const packDir = fs.mkdtempSync(path.join(os.tmpdir(), `claude-code-${version}-`));
+
+try {
+  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', path.join(packDir, tgz), '-C', extractDir]);
+
+  fs.rmSync(nativeDest, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(nativeDest), { recursive: true });
+  fs.cpSync(path.join(extractDir, 'package'), nativeDest, { recursive: true });
+  validateOffsets(sourceBin, item);
+} finally {
+  fs.rmSync(packDir, { recursive: true, force: true });
+}
+
+function run(command, args) {
+  const result = cp.spawnSync(command, args, { stdio: 'inherit' });
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed`);
+  }
+}
+
+function validateOffsets(file, audited) {
+  const buf = fs.readFileSync(file);
+  const start = Number(audited.entry_js_offset);
+  const end = Number(audited.entry_end_offset);
+  const startMarker = Buffer.from('function(exports, require, module, __filename, __dirname) {// Claude Code is a Beta product');
+  const endMarker = Buffer.from('/$bunfs/root/image-processor.js');
+
+  if (!(start > 0 && end > start && end <= buf.length)) {
+    throw new Error(`invalid audited offsets for ${version}`);
+  }
+  if (!buf.subarray(start, start + startMarker.length).equals(startMarker)) {
+    throw new Error(`audited start offset validation failed for ${version}`);
+  }
+  if (!buf.subarray(end, end + endMarker.length).equals(endMarker)) {
+    throw new Error(`audited end offset validation failed for ${version}`);
+  }
+}

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

@@ -0,0 +1,181 @@
+#!/usr/bin/env sh
+set -eu
+
+SOURCE_BIN="${SOURCE_BIN:?SOURCE_BIN is required}"
+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}"
+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}"
+DISABLE_AUTOUPDATER="${DISABLE_AUTOUPDATER:-1}"
+
+need_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    echo "Missing required command: $1" >&2
+    exit 1
+  fi
+}
+
+need_cmd node
+need_cmd termux-open-url
+
+if [ ! -f "${SOURCE_BIN}" ]; then
+  echo "Missing source binary: ${SOURCE_BIN}" >&2
+  exit 1
+fi
+
+mkdir -p "${WORKDIR}"
+mkdir -p "${TERMUX_TMPDIR}"
+
+export TMPDIR="${TERMUX_TMPDIR}"
+export SSL_CERT_DIR
+export SSL_CERT_FILE
+export DISABLE_AUTOUPDATER
+export SOURCE_BIN
+export WORKDIR
+export ENTRY_JS_OFFSET
+export ENTRY_END_OFFSET
+export CURRENT_CLAUDE_VERSION
+
+node - "$@" <<'NODE'
+const fs = require('fs');
+const path = require('path');
+
+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);
+
+class RequestedExit extends Error {
+  constructor(code) {
+    super(`process.exit ${code}`);
+    this.name = 'RequestedExit';
+    this.code = code;
+  }
+}
+
+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');
+
+  const fd = fs.openSync(sourceBin, 'r');
+  const buf = Buffer.alloc(len);
+  fs.readSync(fd, buf, 0, len, entryJsOffset);
+  fs.closeSync(fd);
+
+  fs.writeFileSync(extractedFile, buf.toString('utf8').replace(/[\0\s]+$/g, ''));
+  return extractedFile;
+}
+
+function createFakeRequire(realRequire) {
+  const realChild = realRequire('child_process');
+  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)];
+    }
+    return args;
+  }
+
+  return function fakeRequire(id) {
+    if (id === 'ws') {
+      class WS {
+        on() {}
+        once() {}
+        addEventListener() {}
+        close() {}
+        send() {}
+        ping() {}
+      }
+      return { default: WS, WebSocket: WS };
+    }
+
+    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),
+      };
+    }
+
+    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 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 = [];
+
+  const fakeRequire = createFakeRequire(require);
+  function onAsyncError(error) {
+    asyncErrors.push(error);
+  }
+
+  try {
+    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' };
+    process.argv = ['node', extractedFile, ...argv];
+    process.exit = code => {
+      throw new RequestedExit(code);
+    };
+
+    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));
+    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 {}
+    if (hadGlobalBun) globalThis.Bun = originalGlobalBun;
+    else delete globalThis.Bun;
+  }
+}
+
+main().catch(error => {
+  console.error(error && error.stack ? error.stack : String(error));
+  process.exit(1);
+});
+NODE

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@bash0816/claude-code",
+  "version": "2.1.122",
+  "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",
+    "config",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}