@bash0816/claude-code 2.1.241 → 2.1.248

package/README.md

@@ -37,7 +37,7 @@ npm が `claude` bin link を管理する状態になれば、通常の `npm ins
 Latest audited version / 最新監査済み版:
 
 ```sh
-npm install -g @bash0816/claude-code@2.1.240
+npm install -g @bash0816/claude-code@2.1.245
 ```
 
 ## Update / 更新

package/bin/claude

@@ -16,6 +16,16 @@ NODE="${MAGI_NODE:-node}"
 if [ -n "${MAGI_NODE:-}" ]; then
   export PATH="$(dirname -- "$NODE"):$PATH"
 fi
+
+if ! "$NODE" -e '
+const [major, minor] = process.versions.node.split(".").map(Number);
+const ok = major > 23 || (major === 23 && minor >= 5) || (major === 22 && minor >= 15);
+process.exit(ok ? 0 : 1);
+'; then
+  echo "Error: claude-code requires Node.js >=22.15.0 <23.0.0 or >=23.5.0 (module.registerHooks() API). Detected: $("$NODE" --version)" >&2
+  exit 1
+fi
+
 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}}"
@@ -42,11 +52,18 @@ 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)
+ENTRY_FORMAT=$(json_field entry_format || echo "legacy-cjs")
 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 [ "${ENTRY_FORMAT}" = "esm-chunked" ]; then
+  ENTRY_JS_OFFSET=""
+  ENTRY_END_OFFSET=""
+else
+  ENTRY_JS_OFFSET=$(json_field entry_js_offset)
+  ENTRY_END_OFFSET=$(json_field entry_end_offset)
+fi
+
 if [ ! -f "${SOURCE_BIN}" ]; then
   "$NODE" "${PACKAGE_DIR}/lib/prepare-native.js" "${CLAUDE_VERSION}"
 fi
@@ -58,6 +75,7 @@ fi
 
 SOURCE_BIN="${SOURCE_BIN}" \
 WORKDIR="${CACHE_DIR}/launcher-workdir" \
+ENTRY_FORMAT="${ENTRY_FORMAT}" \
 ENTRY_JS_OFFSET="${ENTRY_JS_OFFSET}" \
 ENTRY_END_OFFSET="${ENTRY_END_OFFSET}" \
 CURRENT_CLAUDE_VERSION="${CLAUDE_VERSION}" \

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

@@ -770,6 +770,36 @@
       "tarball_integrity": "sha512-tHsJhjwcoFyKTCQfYCclKjLtbnbbGKvcrzxUhMb6NDlPw9RrawmjSWUAdla7PtEVPaJsGkjGo4O2MQTlYIT+PA==",
       "tarball_sha256": "41de896e672667bc5b5060419d5a1ff5cfe15b77659d1418b10df5095e38419a",
       "status": "termux_verified"
+    },
+    "2.1.245": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.245",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.245",
+      "entry_format": "esm-chunked",
+      "tarball_integrity": "sha512-Qbn5HnZbYeW4GdifVkDGfcVKqj3/f3U9sfVd3LEaUZh08CcS8D/ptJ76zuBfQUGHJHfToAdNVfak86uJ84b1Dg==",
+      "tarball_sha256": "668662e7b5d91a93cff6c75736e60f3d5d3bed4cbe077ae4feefc63ad1253f4d",
+      "cycle_hoists": [],
+      "status": "termux_verified"
+    },
+    "2.1.248": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.248",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.248",
+      "entry_format": "esm-chunked",
+      "tarball_integrity": "sha512-2qwjgGuzlVfkJC7UWUjl86hiv5Ok5vtVxAZ/5fpdhzQKuBLlxrJJu3z5tVI+VrO/x/hcqx5kJuy9/O9K4eT+Kg==",
+      "tarball_sha256": "bd2e2b6ebace34039b073b0f586d521ec09c895fa2a39de8d1c86423ae5884ca",
+      "status": "offset_discovered",
+      "num_modules": 1946,
+      "byte_count": 136124175,
+      "cycle_hoists": [
+        { "file": "chunk-vmw9kxhv.js", "targetModule": "chunk-y0jj307t.js", "expectedOccurrences": 1, "assertProperties": [] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-ppd18hq1.js", "expectedOccurrences": 1, "assertProperties": ["MonitorTool"] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-830s9480.js", "expectedOccurrences": 1, "assertProperties": ["EndConversationTool"] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-m4hx5z9g.js", "expectedOccurrences": 1, "assertProperties": ["ArtifactTool"] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-eg121wbt.js", "expectedOccurrences": 1, "assertProperties": ["WorkflowTool"] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-prrm838s.js", "expectedOccurrences": 1, "assertProperties": [] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-exvwsc2a.js", "expectedOccurrences": 2, "assertProperties": [] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-s61yn21a.js", "expectedOccurrences": 1, "assertProperties": ["default"] },
+        { "file": "chunk-9n7t2tbt.js", "targetModule": "chunk-040m9a9s.js", "expectedOccurrences": 3, "assertProperties": ["getWorkflowCommands", "invalidateWorkflowCache", "warmWorkflows"] }
+      ]
     }
   }
 }

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

@@ -1,9 +1,9 @@
 {
   "manifest_version": 1,
   "package_name": "@bash0816/claude-code",
-  "latest_audited_version": "2.1.241",
-  "latest_candidate_version": "2.1.241",
-  "previous_stable_version": "2.1.240",
+  "latest_audited_version": "2.1.245",
+  "latest_candidate_version": "2.1.248",
+  "previous_stable_version": "2.1.241",
   "stable_pinned_version": "2.1.220-2",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

package/lib/bunfs-child-process-guard.mjs

@@ -0,0 +1,18 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const realChildProcess = require('node:child_process');
+const { createGuardedChildProcess } = require('./native-update-guard.js');
+const guarded = createGuardedChildProcess(realChildProcess, (v) => process.stderr.write(v));
+
+export const spawn = guarded.spawn;
+export const execFile = guarded.execFile;
+export const exec = guarded.exec;
+export const spawnSync = guarded.spawnSync;
+export const execFileSync = guarded.execFileSync;
+export const execSync = guarded.execSync;
+export const ChildProcess = realChildProcess.ChildProcess;
+export const fork = realChildProcess.fork;
+export const _forkChild = realChildProcess._forkChild;
+
+export default Object.assign({}, realChildProcess, guarded);

package/lib/bunfs-child-process-guard.test.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+test('bunfs-child-process-guard exports named exports for guarded methods', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  assert.equal(typeof guard.spawn, 'function');
+  assert.equal(typeof guard.execFile, 'function');
+  assert.equal(typeof guard.exec, 'function');
+  assert.equal(typeof guard.spawnSync, 'function');
+  assert.equal(typeof guard.execFileSync, 'function');
+  assert.equal(typeof guard.execSync, 'function');
+});
+
+test('bunfs-child-process-guard exports ChildProcess, fork, _forkChild', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // ChildProcess is a class
+  assert.equal(typeof guard.ChildProcess, 'function');
+  // fork and _forkChild are functions
+  assert.equal(typeof guard.fork, 'function');
+  assert.equal(typeof guard._forkChild, 'function');
+});
+
+test('bunfs-child-process-guard provides default export with all methods', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+  const defaultExport = guard.default;
+
+  assert.ok(defaultExport);
+  assert.equal(typeof defaultExport, 'object');
+  assert.equal(typeof defaultExport.spawn, 'function');
+  assert.equal(typeof defaultExport.execFile, 'function');
+  assert.equal(typeof defaultExport.exec, 'function');
+  assert.equal(typeof defaultExport.spawnSync, 'function');
+  assert.equal(typeof defaultExport.execFileSync, 'function');
+  assert.equal(typeof defaultExport.execSync, 'function');
+  assert.equal(typeof defaultExport.ChildProcess, 'function');
+  assert.equal(typeof defaultExport.fork, 'function');
+  assert.equal(typeof defaultExport._forkChild, 'function');
+});
+
+test('bunfs-child-process-guard blocks official package update via execFileSync', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // Try to execute npm install of official package
+  try {
+    guard.execFileSync('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']);
+    // If it doesn't throw, that's an error (should be blocked)
+    assert.fail('Expected execFileSync to block official package update');
+  } catch (err) {
+    // Should throw with CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED code
+    assert.ok(
+      err.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED' ||
+      err.message.includes('disabled on Termux'),
+      `Expected block error, got: ${err.message}`,
+    );
+  }
+});
+
+test('bunfs-child-process-guard blocks official package update via execSync', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // Try to execute npm install via exec
+  try {
+    guard.execSync('npm install -g @anthropic-ai/claude-code@latest');
+    // If it doesn't throw, that's an error (should be blocked)
+    assert.fail('Expected execSync to block official package update');
+  } catch (err) {
+    // Should throw with CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED code
+    assert.ok(
+      err.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED' ||
+      err.message.includes('disabled on Termux'),
+      `Expected block error, got: ${err.message}`,
+    );
+  }
+});
+
+test('bunfs-child-process-guard allows harmless commands', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // echo is a harmless command and should not be blocked
+  const result = guard.execFileSync('echo', ['hello']);
+  // Verify the command actually executed and produced output
+  assert.equal(result.toString().trim(), 'hello');
+});
+
+test('bunfs-child-process-guard spawn blocks official package install', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // spawn should return a blocked child process (EventEmitter-like)
+  const child = guard.spawn('npm', ['install', '-g', '@anthropic-ai/claude-code']);
+
+  // Blocked spawn should have specific properties
+  assert.equal(child.stdout, null);
+  assert.equal(child.stderr, null);
+  assert.equal(child.stdin, null);
+  assert.equal(child.pid, 0);
+  assert.equal(child.killed, false);
+
+  // Verify it's event-like (has on method or can be used as event emitter)
+  assert.equal(typeof child.kill, 'function');
+});
+
+test('bunfs-child-process-guard does not block other package installs', async () => {
+  const guard = await import('./bunfs-child-process-guard.mjs');
+
+  // Installing a different package should not be blocked
+  const result = guard.execFileSync('echo', ['@bash0816/claude-code']);
+  // Verify the command actually executed and produced correct output
+  assert.equal(result.toString().trim(), '@bash0816/claude-code');
+});

package/lib/bunfs-esm-loader.mjs

@@ -0,0 +1,167 @@
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+let PROCESS_OWNED_DIR = null;
+let SOURCE_BIN = null;
+let CHILD_PROCESS_GUARD_PATH = null;
+let VM_GUARD_PATH = null;
+let WS_STUB_PATH = null;
+
+let CYCLE_HOISTS = [];
+
+export function initialize(data) {
+  PROCESS_OWNED_DIR = data.processOwnedDir;
+  SOURCE_BIN = data.sourceBin;
+  CHILD_PROCESS_GUARD_PATH = data.childProcessGuardPath;
+  VM_GUARD_PATH = data.vmGuardPath;
+  WS_STUB_PATH = data.wsStubPath;
+  CYCLE_HOISTS = Array.isArray(data.cycleHoists) ? data.cycleHoists : [];
+}
+
+function tryHoistCycleBreakingImports(filePath, source) {
+  const rel = path.relative(PROCESS_OWNED_DIR, filePath);
+  const records = CYCLE_HOISTS.filter((r) => r.file === rel);
+  if (records.length === 0) return null;
+
+  let hoistedImportLines = '';
+  let newSource = source;
+  let varIndex = 0;
+  const targetToVar = new Map();
+
+  for (const record of records) {
+    const literal = `import.meta.require("/$bunfs/root/${record.targetModule}")`;
+    const occurrences = newSource.split(literal).length - 1;
+    if (occurrences !== record.expectedOccurrences) continue;
+
+    const real = path.resolve(PROCESS_OWNED_DIR, record.targetModule);
+    if (path.relative(PROCESS_OWNED_DIR, real).startsWith('..')) continue;
+    if (!existsSync(real)) continue;
+
+    let varName = targetToVar.get(record.targetModule);
+    if (!varName) {
+      varName = `__bunfsHoisted_${varIndex++}`;
+      targetToVar.set(record.targetModule, varName);
+      hoistedImportLines += `import * as ${varName} from ${JSON.stringify(pathToFileURL(real).href)};\n`;
+      if (record.assertProperties && record.assertProperties.length > 0) {
+        hoistedImportLines += `__bunfsAssertHoistedProps(${varName}, ${JSON.stringify(record.targetModule)}, ${JSON.stringify(record.assertProperties)});\n`;
+      }
+    }
+    newSource = newSource.replaceAll(literal, varName);
+  }
+
+  if (!targetToVar.size) return null;
+  return { hoistedImportLine: hoistedImportLines, source: newSource };
+}
+
+function buildImportMetaRequirePolyfillPrelude(anchorUrl) {
+  return (
+    `import __bunfsGuardedChildProcess from ${JSON.stringify(pathToFileURL(CHILD_PROCESS_GUARD_PATH).href)};\n` +
+    `import __bunfsGuardedVm from ${JSON.stringify(pathToFileURL(VM_GUARD_PATH).href)};\n` +
+    `import { createRequire as __bunfsCreateRequire } from "node:module";\n` +
+    `import __bunfsMetaRequirePath from "node:path";\n` +
+    `import { existsSync as __bunfsMetaRequireExistsSync } from "node:fs";\n` +
+    `import { readFileSync as __bunfsMetaRequireReadFileSync } from "node:fs";\n` +
+    `function __bunfsAssertHoistedProps(ns, targetModule, propNames) {\n` +
+    `  for (const p of propNames) {\n` +
+    `    let v;\n` +
+    `    try {\n` +
+    `      v = ns[p];\n` +
+    `    } catch (e) {\n` +
+    `      if (e instanceof ReferenceError) {\n` +
+    `        throw new Error("bunfs cycle-hoist: accessing \\"" + p + "\\" on " + targetModule + " threw ReferenceError (TDZ) - evaluation-order regression");\n` +
+    `      }\n` +
+    `      throw e;\n` +
+    `    }\n` +
+    `    if (v === undefined) {\n` +
+    `      throw new Error("bunfs cycle-hoist: \\"" + p + "\\" is undefined after hoisting from " + targetModule + " (evaluation-order regression?)");\n` +
+    `    }\n` +
+    `  }\n` +
+    `}\n` +
+    `const __bunfsRealRequire = __bunfsCreateRequire(${JSON.stringify(anchorUrl)});\n` +
+    `const __bunfsOwnedDir = ${JSON.stringify(PROCESS_OWNED_DIR)};\n` +
+    `const __bunfsMetaRequire = (id) => {\n` +
+    `  if (id === "child_process" || id === "node:child_process") return __bunfsGuardedChildProcess;\n` +
+    `  if (id === "vm" || id === "node:vm") return __bunfsGuardedVm;\n` +
+    `  if (typeof id === "string" && id.startsWith("/$bunfs/root/")) {\n` +
+    `    const rel = id.slice("/$bunfs/root/".length);\n` +
+    `    if (rel.includes("..") || __bunfsMetaRequirePath.isAbsolute(rel)) {\n` +
+    `      throw new Error("bunfs meta-require: rejected specifier " + id);\n` +
+    `    }\n` +
+    `    const real = __bunfsMetaRequirePath.resolve(__bunfsOwnedDir, rel);\n` +
+    `    if (__bunfsMetaRequirePath.relative(__bunfsOwnedDir, real).startsWith("..")) {\n` +
+    `      throw new Error("bunfs meta-require: path escapes process-owned dir: " + id);\n` +
+    `    }\n` +
+    `    if (!__bunfsMetaRequireExistsSync(real)) {\n` +
+    `      throw new Error("bunfs meta-require: missing extracted module " + id + " -> " + real);\n` +
+    `    }\n` +
+    `    const ext = __bunfsMetaRequirePath.extname(real);\n` +
+    `    if (ext === ".md" || ext === ".txt") {\n` +
+    `      return __bunfsMetaRequireReadFileSync(real, "utf8");\n` +
+    `    }\n` +
+    `    return __bunfsRealRequire(real);\n` +
+    `  }\n` +
+    `  return __bunfsRealRequire(id);\n` +
+    `};\n`
+  );
+}
+
+export function resolve(specifier, context, nextResolve) {
+  const parentURL = context && context.parentURL;
+  const ownedPrefix = pathToFileURL(PROCESS_OWNED_DIR + path.sep).href;
+  const fromChunk = typeof parentURL === 'string' && parentURL.startsWith(ownedPrefix);
+
+  if (fromChunk) {
+    if (specifier === 'child_process' || specifier === 'node:child_process') {
+      return { url: pathToFileURL(CHILD_PROCESS_GUARD_PATH).href, shortCircuit: true, format: 'module' };
+    }
+    if (specifier === 'vm' || specifier === 'node:vm') {
+      return { url: pathToFileURL(VM_GUARD_PATH).href, shortCircuit: true, format: 'module' };
+    }
+    if (specifier === 'ws') {
+      return { url: pathToFileURL(WS_STUB_PATH).href, shortCircuit: true, format: 'module' };
+    }
+  }
+  if (specifier.startsWith('/$bunfs/root/')) {
+    const rel = specifier.slice('/$bunfs/root/'.length);
+    if (rel.includes('..') || path.isAbsolute(rel)) {
+      throw new Error(`bunfs resolve: rejected specifier ${specifier}`);
+    }
+    const real = path.resolve(PROCESS_OWNED_DIR, rel);
+    if (path.relative(PROCESS_OWNED_DIR, real).startsWith('..')) {
+      throw new Error(`bunfs resolve: path escapes process-owned dir: ${specifier}`);
+    }
+    if (!existsSync(real)) {
+      throw new Error(`bunfs resolve: missing extracted module ${specifier} -> ${real}`);
+    }
+    return { url: pathToFileURL(real).href, shortCircuit: true, format: 'module' };
+  }
+  return nextResolve(specifier, context);
+}
+
+export function load(url, context, nextLoad) {
+  const ownedPrefix = pathToFileURL(PROCESS_OWNED_DIR + path.sep).href;
+  if (!url.startsWith(ownedPrefix)) {
+    return nextLoad(url, context);
+  }
+  const filePath = fileURLToPath(url);
+  let source = readFileSync(filePath, 'utf8');
+
+  let hoistedImportLine = '';
+  const hoistResult = tryHoistCycleBreakingImports(filePath, source);
+  if (hoistResult) {
+    hoistedImportLine = hoistResult.hoistedImportLine;
+    source = hoistResult.source;
+  }
+
+  if (source.includes('import.meta.require')) {
+    const anchorUrl = pathToFileURL(SOURCE_BIN).href;
+    source = hoistedImportLine +
+      buildImportMetaRequirePolyfillPrelude(anchorUrl) +
+      source.replaceAll('import.meta.require', '__bunfsMetaRequire');
+  } else if (hoistedImportLine) {
+    source = hoistedImportLine + source;
+  }
+  return { format: 'module', source, shortCircuit: true };
+}