@bash0816/claude-code 2.1.156 → 2.1.159-1

package/README.md

@@ -1,19 +1,17 @@
-# @bash0816/cluade-code
+# @bash0816/claude-code
 
 Termux-native Claude Code wrapper package.
 
 Termux 向け Claude Code native wrapper package です。
 
-Legacy compatibility package:
+This package is the current Termux wrapper package line.
 
-互換維持用の legacy package:
-
-- canonical package: `@bash0816/claude-code`
+この package は現行の Termux wrapper package 系です。
 
 ## Install / インストール
 
 ```sh
-npm install -g @bash0816/cluade-code@latest
+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.
@@ -29,19 +27,23 @@ 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/cluade-code@latest
+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 version:
+Specific audited versions:
 
 監査済みの固定 version:
 
+Current quick examples:
+
+現在の quick example:
+
 ```sh
-npm install -g @bash0816/cluade-code@2.1.123
+npm install -g @bash0816/claude-code@2.1.157
 ```
 
 ## Update / 更新
@@ -50,17 +52,9 @@ npm install -g @bash0816/cluade-code@2.1.123
 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.
+`claude update` installs the latest audited package version.
 
-この最終 bridge package は package version `2.1.123` で凍結し、同期済み metadata 集合から既定では監査済み native `2.1.150` を起動します。
+`claude update` は最新の監査済み package version を install します。
 
 ```sh
 npm install -g @bash0816/claude-code@<latest_audited_version>
@@ -74,10 +68,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 だけを実行できます。
-- 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 です。
+- `2.1.150-1`, `2.1.150-2`, `2.1.150-3`, `2.1.153-1`, `2.1.153-2`, `2.1.153-3`, `2.1.153-4`, `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`, `2.1.144`, `2.1.150`, `2.1.153`, `2.1.157` are included in the package metadata.
+- `2.1.150-1`、`2.1.150-2`、`2.1.150-3`、`2.1.153-1`、`2.1.153-2`、`2.1.153-3`、`2.1.153-4`、`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`、`2.1.144`、`2.1.150`、`2.1.153`、`2.1.157` を package metadata に含めています。
+- The metadata file is the source of truth for the currently audited 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,8 +14,7 @@ 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}")
-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}}}"
+CLAUDE_VERSION="${CLAUDE_TERMUX_CLAUDE_VERSION:-${PACKAGE_VERSION}}"
 UPDATE_HELPER="${PACKAGE_DIR}/lib/check-updates.js"
 
 if [ "${1:-}" = "update" ]; then
@@ -58,5 +57,6 @@ 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

@@ -175,18 +175,11 @@
       "entry_end_offset": 237958345,
       "status": "termux_verified"
     },
-    "2.1.154": {
-      "wrapper_spec": "@anthropic-ai/claude-code@2.1.154",
-      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.154",
-      "entry_js_offset": 222957396,
-      "entry_end_offset": 238482842,
-      "status": "termux_verified"
-    },
-    "2.1.156": {
-      "wrapper_spec": "@anthropic-ai/claude-code@2.1.156",
-      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.156",
-      "entry_js_offset": 222957812,
-      "entry_end_offset": 238483519,
+    "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"
     }
   }

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

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

package/lib/check-updates.js

@@ -19,19 +19,10 @@ 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 parse = v => {
-    const [main, patch] = String(v).split('-');
-    const parts = main.split('.').map(Number);
-    parts.push(patch !== undefined ? Number(patch) : 0);
-    return parts;
-  };
-  const aParts = parse(a);
-  const bParts = parse(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);
@@ -111,64 +102,10 @@ async function resolveManifest(forceRefresh) {
   }
 }
 
-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) {
+function updateNoticeCache(cache, latestVersion) {
   const nextCache = {
     ...cache,
     last_notice: {
-      package_name: packageName,
       current_version: currentVersion,
       latest_audited_version: latestVersion,
       notified_at: Date.now(),
@@ -177,10 +114,9 @@ function updateNoticeCache(cache, packageName, latestVersion) {
   writeCache(nextCache);
 }
 
-function shouldNotify(cache, packageName, latestVersion) {
+function shouldNotify(cache, 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;
@@ -204,40 +140,26 @@ function installTarget(packageName, targetVersion) {
 }
 
 async function runNotify() {
-  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;
-  }
+  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(target.cache, packageName, latest);
+  updateNoticeCache(cache, latest);
   return 0;
 }
 
 async function runUpdate() {
-  const target = await resolveTarget(true);
-  if (!target.migration && compareVersions(currentVersion, target.targetVersion) >= 0) {
+  const { manifest } = await resolveManifest(true);
+  const packageName = manifest.package_name || localManifest.package_name;
+  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;
   }
-  if (target.migration) {
-    console.error(`Migrating from legacy package ${pkg.name} to canonical package ${target.packageName}@${target.targetVersion}`);
-  }
-  return installTarget(target.packageName, target.targetVersion);
+  return installTarget(packageName, target);
 }
 
 async function main() {

package/lib/native-update-guard.js

@@ -0,0 +1,257 @@
+#!/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,
+};