@bash0816/claude-code 2.1.240 → 2.1.245

package/lib/bunfs-vm-guard.test.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+test('bunfs-vm-guard exports all vm module methods', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  assert.equal(typeof vmGuard.createContext, 'function');
+  assert.equal(typeof vmGuard.isContext, 'function');
+  assert.equal(typeof vmGuard.runInContext, 'function');
+  assert.equal(typeof vmGuard.runInNewContext, 'function');
+  assert.equal(typeof vmGuard.runInThisContext, 'function');
+  assert.equal(typeof vmGuard.createScript, 'function');
+  assert.equal(typeof vmGuard.compileFunction, 'function');
+  assert.equal(typeof vmGuard.measureMemory, 'function');
+  assert.equal(typeof vmGuard.Script, 'function');
+  // SourceTextModule and SyntheticModule only exist with --experimental-vm-modules flag
+  assert.ok('SourceTextModule' in vmGuard);
+  assert.ok('SyntheticModule' in vmGuard);
+  assert.ok(vmGuard.constants);
+});
+
+test('bunfs-vm-guard provides default export with vm module API', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+  const defaultExport = vmGuard.default;
+
+  assert.ok(defaultExport);
+  assert.equal(typeof defaultExport, 'object');
+  assert.equal(typeof defaultExport.createContext, 'function');
+  assert.equal(typeof defaultExport.isContext, 'function');
+  assert.equal(typeof defaultExport.runInContext, 'function');
+  assert.equal(typeof defaultExport.runInNewContext, 'function');
+  assert.equal(typeof defaultExport.runInThisContext, 'function');
+  assert.equal(typeof defaultExport.createScript, 'function');
+  assert.equal(typeof defaultExport.compileFunction, 'function');
+  assert.equal(typeof defaultExport.measureMemory, 'function');
+  assert.equal(typeof defaultExport.Script, 'function');
+  // SourceTextModule and SyntheticModule may not exist in default export without --experimental-vm-modules
+  // They are exported as named exports if they exist
+  assert.ok(defaultExport.constants);
+});
+
+test('bunfs-vm-guard injects Bun into context in createContext', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const context = vmGuard.createContext({});
+    // Check that Bun property exists in context
+    assert.ok(Object.prototype.hasOwnProperty.call(context, 'Bun'));
+
+    // Verify Bun is defined when we run code in context
+    const result = vmGuard.runInContext('typeof Bun', context);
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard injects Bun into context in runInNewContext', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const code = 'typeof Bun';
+    const result = vmGuard.runInNewContext(code, {});
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard injects __claudeYaml into context', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  const context = vmGuard.createContext({});
+  // Check that __claudeYaml property exists
+  assert.ok(Object.prototype.hasOwnProperty.call(context, '__claudeYaml'));
+});
+
+test('bunfs-vm-guard injects __claudeBun and __claudeBunShim into context', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  const context = vmGuard.createContext({});
+  // Check that shim properties exist
+  assert.ok(Object.prototype.hasOwnProperty.call(context, '__claudeBun'));
+  assert.ok(Object.prototype.hasOwnProperty.call(context, '__claudeBunShim'));
+});
+
+test('bunfs-vm-guard Script class works with context injection', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const code = 'typeof Bun';
+    const script = new vmGuard.Script(code);
+    const context = vmGuard.createContext({});
+    const result = script.runInContext(context);
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard handles context with existing Bun property', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    // Create context with pre-existing Bun property
+    const context = vmGuard.createContext({ Bun: { custom: true } });
+    // The guard should have replaced/overwritten it with globalThis.Bun
+    const result = vmGuard.runInContext('typeof Bun', context);
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});
+
+test('bunfs-vm-guard does not break normal vm functionality', async () => {
+  const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+  // Test that normal code execution still works
+  const code = '2 + 2';
+  const result = vmGuard.runInNewContext(code);
+  assert.equal(result, 4);
+});
+
+test('bunfs-vm-guard Script.runInNewContext works with injections', async () => {
+  globalThis.Bun = { __dummy: true };
+  try {
+    const vmGuard = await import('./bunfs-vm-guard.mjs');
+
+    const code = 'typeof Bun';
+    const script = new vmGuard.Script(code);
+    const result = script.runInNewContext({});
+    assert.equal(result, 'object');
+  } finally {
+    delete globalThis.Bun;
+  }
+});

package/lib/bunfs-ws-stub.mjs

@@ -0,0 +1,11 @@
+class WS {
+  on() {}
+  once() {}
+  addEventListener() {}
+  close() {}
+  send() {}
+  ping() {}
+}
+
+export default WS;
+export { WS as WebSocket };

package/lib/bunfs-yaml-shim.mjs

@@ -0,0 +1,91 @@
+function parseScalar(value) {
+  const text = String(value ?? '').trim();
+  if (text === '') return '';
+  if (text === 'true') return true;
+  if (text === 'false') return false;
+  if (text === 'null' || text === '~') return null;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(text)) return Number(text);
+  if (
+    (text.startsWith('"') && text.endsWith('"')) ||
+    (text.startsWith("'") && text.endsWith("'"))
+  ) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function parseInlineArray(value) {
+  const inner = String(value ?? '').trim().slice(1, -1).trim();
+  if (inner === '') return [];
+  const items = [];
+  let current = '';
+  let quote = null;
+
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i];
+    if (quote) {
+      if (ch === quote && inner[i - 1] !== '\\') quote = null;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ',') {
+      items.push(parseScalar(current));
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current !== '') items.push(parseScalar(current));
+  return items;
+}
+
+export function yamlParse(text) {
+  const source = String(text ?? '');
+  const result = {};
+  for (const rawLine of source.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const idx = line.indexOf(':');
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    const rawValue = line.slice(idx + 1).trim();
+    if (!key) continue;
+    result[key] = rawValue.startsWith('[') && rawValue.endsWith(']')
+      ? parseInlineArray(rawValue)
+      : parseScalar(rawValue);
+  }
+  return result;
+}
+
+export function yamlStringify(value) {
+  if (!value || typeof value !== 'object') return String(value ?? '');
+  const lines = [];
+  for (const [key, raw] of Object.entries(value)) {
+    if (Array.isArray(raw)) {
+      lines.push(`${key}: [${raw.map(item => JSON.stringify(String(item))).join(', ')}]`);
+    } else if (raw === null) {
+      lines.push(`${key}: null`);
+    } else if (typeof raw === 'string') {
+      lines.push(`${key}: ${JSON.stringify(raw)}`);
+    } else {
+      lines.push(`${key}: ${String(raw)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+export function createYamlShim() {
+  const yaml = {
+    parse: yamlParse,
+    stringify: yamlStringify,
+  };
+  yaml.YAML = yaml;
+  yaml.default = yaml;
+  return yaml;
+}

package/lib/prepare-native.js

@@ -128,6 +128,14 @@ function verifyTarball(file, audited) {
 }
 
 function validateOffsets(file, audited) {
+  if (audited.entry_format === 'esm-chunked') {
+    validateEsmChunkedOffsets(file, audited);
+    return;
+  }
+  validateLegacyCjsOffsets(file, audited);
+}
+
+function validateLegacyCjsOffsets(file, audited) {
   const buf = fs.readFileSync(file);
   const start = Number(audited.entry_js_offset);
   const end = Number(audited.entry_end_offset);
@@ -144,3 +152,25 @@ function validateOffsets(file, audited) {
     throw new Error(`audited end offset validation failed for ${version}`);
   }
 }
+
+function validateEsmChunkedOffsets(file, audited) {
+  // 371MB超のバイナリ全体をreadFileSyncしない(実機でOOM確認済み)。
+  // discoverModuleGraphは範囲readSyncのみでトレイラー・モジュールテーブルを検証する。
+  const { discoverModuleGraph, readEntryContentPrefix } = require(path.join(packageDir, 'lib', 'bunfs-extract.js'));
+  const graph = discoverModuleGraph(file);
+  try {
+    if (!(graph.numModules > 0)) {
+      throw new Error(`esm-chunked module graph is empty for ${version}`);
+    }
+    if (graph.entryName !== '/$bunfs/root/cli') {
+      throw new Error(`esm-chunked entry module name mismatch for ${version}: ${graph.entryName}`);
+    }
+    const prefix = readEntryContentPrefix(graph.fd, graph.entryModule, 256).toString('utf8');
+    const codeStart = prefix.replace(/^(\s*\/\/[^\n]*\n)+/, '').replace(/^\(/, '');
+    if (codeStart.startsWith('function(exports, require, module, __filename, __dirname) {')) {
+      throw new Error(`entry module for ${version} is legacy-cjs wrapped, but audited entry_format is esm-chunked`);
+    }
+  } finally {
+    fs.closeSync(graph.fd);
+  }
+}

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

@@ -3,8 +3,14 @@ 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}"
+ENTRY_FORMAT="${ENTRY_FORMAT:-legacy-cjs}"
+if [ "${ENTRY_FORMAT}" = "esm-chunked" ]; then
+  ENTRY_JS_OFFSET="${ENTRY_JS_OFFSET:-0}"
+  ENTRY_END_OFFSET="${ENTRY_END_OFFSET:-0}"
+else
+  ENTRY_JS_OFFSET="${ENTRY_JS_OFFSET:?ENTRY_JS_OFFSET is required}"
+  ENTRY_END_OFFSET="${ENTRY_END_OFFSET:?ENTRY_END_OFFSET is required}"
+fi
 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}"
@@ -45,6 +51,7 @@ export SSL_CERT_FILE
 export DISABLE_AUTOUPDATER
 export SOURCE_BIN
 export WORKDIR
+export ENTRY_FORMAT
 export ENTRY_JS_OFFSET
 export ENTRY_END_OFFSET
 export CURRENT_CLAUDE_VERSION
@@ -656,7 +663,60 @@ function rewriteNativeChunkSource(source) {
   return patched;
 }
 
-async function main() {
+async function esmChunkedMain() {
+  const { prepareProcessOwnedDir } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bunfs-extract.js'));
+  const { register } = require('node:module');
+  const { pathToFileURL } = require('node:url');
+
+  const { ownedDir, entryRelPath } = prepareProcessOwnedDir(sourceBin, workdir);
+  const libDir = path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib');
+
+  globalThis.__claudeYaml = createYamlShim();
+  globalThis.Bun = {
+    version: '1.1.8',
+    stringWidth,
+    wrapAnsi,
+    stripANSI,
+    hash: stableHash,
+    which: (cmd) => {
+      try {
+        return require('child_process').execFileSync('which', [String(cmd)], { encoding: 'utf8' }).trim() || null;
+      } catch { return null; }
+    },
+    gc: () => {},
+    YAML: globalThis.__claudeYaml,
+  };
+  Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
+  globalThis.__claudeBunShim = globalThis.Bun;
+  globalThis.__claudeBun = globalThis.Bun;
+
+  register(pathToFileURL(path.join(libDir, 'bunfs-esm-loader.mjs')).href, {
+    parentURL: pathToFileURL(__filename).href,
+    data: {
+      processOwnedDir: ownedDir,
+      sourceBin,
+      childProcessGuardPath: path.join(libDir, 'bunfs-child-process-guard.mjs'),
+      vmGuardPath: path.join(libDir, 'bunfs-vm-guard.mjs'),
+      wsStubPath: path.join(libDir, 'bunfs-ws-stub.mjs'),
+    },
+  });
+
+  const entryUrl = pathToFileURL(path.join(ownedDir, entryRelPath)).href;
+
+  // 2.1.245実チャンクのエントリは、内部のmain相当処理をトップレベルでawaitせず
+  // fire-and-forgetで起動する(Bunランタイム前提の実装)。そのためawait import()は
+  // 内部の非同期処理が完了する前に解決してしまい、legacy-cjs経路のような
+  // process.exitパッチ+ここでの強制exit呼び出しを行うと、まだ実行中の内部処理を
+  // 強制終了させ出力が失われる(実機で確認済み)。process.exit/killは一切パッチせず、
+  // 実際のCLIコードが自ら呼ぶprocess.exit()に任せてNodeの自然なイベントループ終了を
+  // 待つ(この関数はawait import()完了後、何もせずreturnするだけでよい)。
+  // 同じ理由で、ここでglobalThis.Bun/__claudeYamlを削除するcleanupも行わない
+  // (fire-and-forgetの内部処理がimport()解決後も継続してBunを参照するため、
+  // 早期に消すと実機で"Bun is not defined"を引き起こす。プロセス終了まで残す)。
+  await import(entryUrl);
+}
+
+async function legacyCjsMain() {
   let extractedFile;
   extractedFile = ensureEntryFile();
   const code = fs.readFileSync(extractedFile, 'utf8');
@@ -1000,6 +1060,10 @@ async function main() {
   }
 }
 
+function main() {
+  return process.env.ENTRY_FORMAT === 'esm-chunked' ? esmChunkedMain() : legacyCjsMain();
+}
+
 main().catch(error => {
   if (error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED') {
     console.error(BLOCK_MESSAGE);
@@ -1613,7 +1677,60 @@ function rewriteNativeChunkSource(source) {
   return patched;
 }
 
-async function main() {
+async function esmChunkedMain() {
+  const { prepareProcessOwnedDir } = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'bunfs-extract.js'));
+  const { register } = require('node:module');
+  const { pathToFileURL } = require('node:url');
+
+  const { ownedDir, entryRelPath } = prepareProcessOwnedDir(sourceBin, workdir);
+  const libDir = path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib');
+
+  globalThis.__claudeYaml = createYamlShim();
+  globalThis.Bun = {
+    version: '1.1.8',
+    stringWidth,
+    wrapAnsi,
+    stripANSI,
+    hash: stableHash,
+    which: (cmd) => {
+      try {
+        return require('child_process').execFileSync('which', [String(cmd)], { encoding: 'utf8' }).trim() || null;
+      } catch { return null; }
+    },
+    gc: () => {},
+    YAML: globalThis.__claudeYaml,
+  };
+  Object.defineProperty(process.versions, 'bun', { value: '1.1.8', configurable: true });
+  globalThis.__claudeBunShim = globalThis.Bun;
+  globalThis.__claudeBun = globalThis.Bun;
+
+  register(pathToFileURL(path.join(libDir, 'bunfs-esm-loader.mjs')).href, {
+    parentURL: pathToFileURL(__filename).href,
+    data: {
+      processOwnedDir: ownedDir,
+      sourceBin,
+      childProcessGuardPath: path.join(libDir, 'bunfs-child-process-guard.mjs'),
+      vmGuardPath: path.join(libDir, 'bunfs-vm-guard.mjs'),
+      wsStubPath: path.join(libDir, 'bunfs-ws-stub.mjs'),
+    },
+  });
+
+  const entryUrl = pathToFileURL(path.join(ownedDir, entryRelPath)).href;
+
+  // 2.1.245実チャンクのエントリは、内部のmain相当処理をトップレベルでawaitせず
+  // fire-and-forgetで起動する(Bunランタイム前提の実装)。そのためawait import()は
+  // 内部の非同期処理が完了する前に解決してしまい、legacy-cjs経路のような
+  // process.exitパッチ+ここでの強制exit呼び出しを行うと、まだ実行中の内部処理を
+  // 強制終了させ出力が失われる(実機で確認済み)。process.exit/killは一切パッチせず、
+  // 実際のCLIコードが自ら呼ぶprocess.exit()に任せてNodeの自然なイベントループ終了を
+  // 待つ(この関数はawait import()完了後、何もせずreturnするだけでよい)。
+  // 同じ理由で、ここでglobalThis.Bun/__claudeYamlを削除するcleanupも行わない
+  // (fire-and-forgetの内部処理がimport()解決後も継続してBunを参照するため、
+  // 早期に消すと実機で"Bun is not defined"を引き起こす。プロセス終了まで残す)。
+  await import(entryUrl);
+}
+
+async function legacyCjsMain() {
   let extractedFile;
   extractedFile = ensureEntryFile();
   const code = fs.readFileSync(extractedFile, 'utf8');
@@ -1961,8 +2078,19 @@ async function main() {
   }
 }
 
+function main() {
+  return process.env.ENTRY_FORMAT === 'esm-chunked' ? esmChunkedMain() : legacyCjsMain();
+}
+
 main()
   .then(() => {
+    // esm-chunked経路は内部のfire-and-forget非同期処理が実際のprocess.exit()を
+    // 自ら呼ぶまでNodeのイベントループを生かしておく必要があるため、TUIモードと
+    // 同様にここでは強制exitしない(実機で確認済み: 強制exitすると--helpの出力等が
+    // 完了前に打ち切られる)。
+    if (process.env.ENTRY_FORMAT === 'esm-chunked') {
+      return;
+    }
     if (process.env.CLAUDE_TERMUX_TUI === '1' && process.exitCode === undefined) {
       return;
     }

package/lib/termux-run-claude-native.test.js

@@ -81,7 +81,7 @@ function loadHelperApi() {
   const rewriteSource = extractFunction(
     helperBlock,
     'function rewriteNativeChunkSource(source) {',
-    '\n\nasync function main() {',
+    '\n\nasync function esmChunkedMain() {',
   );
 
   const context = vm.createContext({ module: { exports: {} }, exports: {}, fs, path, process });
@@ -113,12 +113,12 @@ test('helper and bootstrap rewrite helpers stay identical', () => {
   const helperRewrite = extractFunction(
     helperBlock,
     'function rewriteNativeChunkSource(source) {',
-    '\n\nasync function main() {',
+    '\n\nasync function esmChunkedMain() {',
   );
   const bootstrapRewrite = extractFunction(
     bootstrapBlock,
     'function rewriteNativeChunkSource(source) {',
-    '\n\nasync function main() {',
+    '\n\nasync function esmChunkedMain() {',
   );
   const helperWrapAnsi = extractFunction(
     helperBlock,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.240",
+  "version": "2.1.245",
   "description": "Unofficial Termux-native Claude Code wrapper with audited native replay",
   "license": "GPL-3.0-only",
   "bin": {
@@ -15,7 +15,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20.6.0"
   },
   "keywords": [
     "claude-code",