@bash0816/claude-code 2.1.156 → 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

@@ -188,6 +188,20 @@
       "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.156",
-  "default_native_version": "2.1.156",
-  "latest_audited_version": "2.1.156",
-  "latest_candidate_version": "2.1.156",
-  "previous_stable_version": "2.1.154",
+  "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,6 +74,38 @@ function ensureEntryFile() {
 }
 
 function createFakeRequire(realRequire) {
+  const realVm = realRequire('vm');
+
+  function injectBunIntoContext(context) {
+    if (!context || typeof context !== 'object') return context;
+    try {
+      if (!Object.prototype.hasOwnProperty.call(context, 'Bun')) {
+        Object.defineProperty(context, 'Bun', {
+          value: globalThis.Bun,
+          configurable: true,
+          writable: true,
+        });
+      }
+    } catch {}
+    return context;
+  }
+
+  if (!realVm.__bunShimPatched) {
+    const origCreateContext = realVm.createContext.bind(realVm);
+    const origRunInNewContext = realVm.runInNewContext.bind(realVm);
+    realVm.createContext = (ctx, ...rest) => origCreateContext(injectBunIntoContext(ctx), ...rest);
+    realVm.runInNewContext = (code, ctx, ...rest) => origRunInNewContext(code, injectBunIntoContext(ctx), ...rest);
+    const ScriptProto = realVm.Script && realVm.Script.prototype;
+    if (ScriptProto && !ScriptProto.__bunShimPatched) {
+      const origRunInContext = ScriptProto.runInContext;
+      const origRunInNewCtx = ScriptProto.runInNewContext;
+      ScriptProto.runInContext = function(ctx, ...rest) { return origRunInContext.call(this, injectBunIntoContext(ctx), ...rest); };
+      ScriptProto.runInNewContext = function(ctx, ...rest) { return origRunInNewCtx.call(this, injectBunIntoContext(ctx), ...rest); };
+      Object.defineProperty(ScriptProto, '__bunShimPatched', { value: true });
+    }
+    Object.defineProperty(realVm, '__bunShimPatched', { value: true });
+  }
+
   const realChild = realRequire('child_process');
   function rewriteArgs(args) {
     if (
@@ -111,6 +143,8 @@ function createFakeRequire(realRequire) {
       };
     }
 
+    if (id === 'vm') return realVm;
+
     if (id.startsWith('/$bunfs/root/')) {
       throw new Error('bunfs require blocked: ' + id);
     }
@@ -449,6 +483,177 @@ const semver = {
   },
 };
 
+function bunSpawn(argv, options) {
+  const childProcess = require('child_process');
+  options = options || {};
+  if (!Array.isArray(argv) || argv.length === 0) {
+    throw new TypeError('Bun.spawn expects a non-empty argv array');
+  }
+  const command = argv[0];
+  const args = argv.slice(1);
+  const terminal = options.terminal || null;
+
+  function resolveStdio(val, fallback) {
+    if (val === 'ignore' || val === 'inherit' || val === 'pipe') return val;
+    return fallback;
+  }
+
+  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);
+    };
+  }
+
+  nodeChild.exited = new Promise(function(resolve) {
+    nodeChild.once('exit', function(code, signal) {
+      resolve(code != null ? code : (signal ? 1 : 0));
+    });
+  });
+
+  function makeTextReader(stream) {
+    return {
+      text: function() {
+        return new Promise(function(resolve, reject) {
+          if (!stream) return resolve('');
+          const chunks = [];
+          stream.on('data', function(chunk) { chunks.push(chunk); });
+          stream.on('end', function() { resolve(Buffer.concat(chunks).toString('utf8')); });
+          stream.on('error', reject);
+        });
+      },
+    };
+  }
+  if (nodeChild.stdout) Object.assign(nodeChild.stdout, makeTextReader(nodeChild.stdout));
+  if (nodeChild.stderr) Object.assign(nodeChild.stderr, makeTextReader(nodeChild.stderr));
+  return nodeChild;
+}
+
+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;
+  }
+}
+
+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;
+    },
+    stop: function(closeConnections) {
+      server.close();
+      if (closeConnections) {
+        for (const socket of sockets) socket.destroy();
+      }
+    },
+  };
+}
+
+class BunTranspiler {
+  constructor(_options) {}
+  transformSync(code) { return typeof code === 'string' ? code : ''; }
+  scanImports(code) {
+    const imports = [];
+    const str = String(code);
+    const reStatic = /(?:^|[^.])import\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/gm;
+    const reDynamic = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    const reRequire = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let m;
+    while ((m = reStatic.exec(str)) !== null) imports.push({ path: m[1], kind: 'import-statement' });
+    while ((m = reDynamic.exec(str)) !== null) imports.push({ path: m[1], kind: 'dynamic-import' });
+    while ((m = reRequire.exec(str)) !== null) imports.push({ path: m[1], kind: 'require-call' });
+    return imports;
+  }
+}
+
 async function main() {
   const extractedFile = ensureEntryFile();
   const code = fs.readFileSync(extractedFile, 'utf8');
@@ -475,15 +680,20 @@ async function main() {
       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: [],
     };
@@ -528,7 +738,9 @@ async function main() {
   }
 }
 
-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.156",
+  "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",