@bash0816/claude-code 2.1.137 → 2.1.139

package/README.md

@@ -52,6 +52,8 @@ npm install -g @bash0816/claude-code@2.1.126
 npm install -g @bash0816/claude-code@2.1.128
 npm install -g @bash0816/claude-code@2.1.136
 npm install -g @bash0816/claude-code@2.1.137
+npm install -g @bash0816/claude-code@2.1.138
+npm install -g @bash0816/claude-code@2.1.139
 ```
 
 ## Update / 更新
@@ -76,8 +78,8 @@ 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 だけを実行できます。
-- `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` are included in the package metadata.
-- `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` を package metadata に含めています。
+- `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` are included in the package metadata.
+- `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` を 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`.

package/bin/claude

@@ -57,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

@@ -62,6 +62,20 @@
       "entry_js_offset": 214359796,
       "entry_end_offset": 228641008,
       "status": "termux_verified"
+    },
+    "2.1.138": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.138",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.138",
+      "entry_js_offset": 214359828,
+      "entry_end_offset": 228641090,
+      "status": "termux_verified"
+    },
+    "2.1.139": {
+      "wrapper_spec": "@anthropic-ai/claude-code@2.1.139",
+      "native_spec": "@anthropic-ai/claude-code-linux-arm64@2.1.139",
+      "entry_js_offset": 214907060,
+      "entry_end_offset": 229261135,
+      "status": "termux_verified"
     }
   }
 }

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

@@ -1,8 +1,8 @@
 {
   "manifest_version": 1,
   "package_name": "@bash0816/claude-code",
-  "latest_audited_version": "2.1.137",
-  "latest_candidate_version": "2.1.137",
-  "previous_stable_version": "2.1.136",
+  "latest_audited_version": "2.1.139",
+  "latest_candidate_version": "2.1.139",
+  "previous_stable_version": "2.1.138",
   "manifest_url": "https://raw.githubusercontent.com/bash0816/ClaudeCode-Termux/main/config/claude-termux-release-manifest.json"
 }

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,
+};

package/lib/native-update-guard.test.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const EventEmitter = require('events');
+
+const {
+  BLOCK_MESSAGE,
+  createGuardedChildProcess,
+  shouldBlockCommand,
+  shouldBlockExecString,
+} = require('./native-update-guard.js');
+
+test('blocks npm install of official package', () => {
+  assert.equal(
+    shouldBlockCommand('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']),
+    true,
+  );
+});
+
+test('blocks npm update of official package via absolute npm path', () => {
+  assert.equal(
+    shouldBlockCommand('/usr/bin/npm', ['update', '-g', '@anthropic-ai/claude-code']),
+    true,
+  );
+});
+
+test('does not block canonical package install', () => {
+  assert.equal(
+    shouldBlockCommand('npm', ['install', '-g', '@bash0816/claude-code@2.1.137']),
+    false,
+  );
+});
+
+test('blocks exec string that installs official package', () => {
+  assert.equal(
+    shouldBlockExecString('npm install -g @anthropic-ai/claude-code@latest'),
+    true,
+  );
+});
+
+test('does not block unrelated exec string', () => {
+  assert.equal(
+    shouldBlockExecString('npm install -g @bash0816/claude-code@2.1.137'),
+    false,
+  );
+});
+
+test('blocks env npm install of official package', () => {
+  assert.equal(
+    shouldBlockCommand('env', ['FOO=bar', 'npm', 'install', '-g', '@anthropic-ai/claude-code@latest']),
+    true,
+  );
+});
+
+test('blocks npx official package invocation', () => {
+  assert.equal(shouldBlockCommand('npx', ['@anthropic-ai/claude-code']), true);
+});
+
+test('blocks npx package option official package invocation', () => {
+  assert.equal(shouldBlockCommand('npx', ['-p', '@anthropic-ai/claude-code', 'claude']), true);
+  assert.equal(shouldBlockCommand('npx', ['--package=@anthropic-ai/claude-code', 'claude']), true);
+});
+
+test('blocks pnpm add of official package', () => {
+  assert.equal(
+    shouldBlockCommand('pnpm', ['add', '-g', '@anthropic-ai/claude-code']),
+    true,
+  );
+});
+
+test('blocks yarn global add of official package', () => {
+  assert.equal(
+    shouldBlockCommand('yarn', ['global', 'add', '@anthropic-ai/claude-code']),
+    true,
+  );
+});
+
+test('blocks corepack pnpm add of official package', () => {
+  assert.equal(
+    shouldBlockCommand('corepack', ['pnpm', 'add', '-g', '@anthropic-ai/claude-code']),
+    true,
+  );
+});
+
+test('blocks corepack yarn global add of official package', () => {
+  assert.equal(
+    shouldBlockCommand('corepack', ['yarn', 'global', 'add', '@anthropic-ai/claude-code']),
+    true,
+  );
+});
+
+test('does not block corepack pnpm add of canonical package', () => {
+  assert.equal(
+    shouldBlockCommand('corepack', ['pnpm', 'add', '-g', '@bash0816/claude-code@2.1.137']),
+    false,
+  );
+});
+
+test('blocks exec string through env npm', () => {
+  assert.equal(
+    shouldBlockExecString('env FOO=bar npm install -g @anthropic-ai/claude-code@latest'),
+    true,
+  );
+});
+
+test('blocks exec string through corepack yarn', () => {
+  assert.equal(
+    shouldBlockExecString('corepack yarn global add @anthropic-ai/claude-code'),
+    true,
+  );
+});
+
+test('blocks exec string through sh -c npm install', () => {
+  assert.equal(
+    shouldBlockExecString('sh -c "npm install -g @anthropic-ai/claude-code"'),
+    true,
+  );
+});
+
+test('blocks exec string through bash -lc pnpm add', () => {
+  assert.equal(
+    shouldBlockExecString('bash -lc "pnpm add -g @anthropic-ai/claude-code"'),
+    true,
+  );
+});
+
+test('does not block canonical exec string through bash -lc', () => {
+  assert.equal(
+    shouldBlockExecString('bash -lc "npm install -g @bash0816/claude-code@2.1.137"'),
+    false,
+  );
+});
+
+test('does not block unrelated shell exec string', () => {
+  assert.equal(shouldBlockExecString('sh -c "echo ok"'), false);
+});
+
+function createRealChildStub() {
+  const calls = [];
+  return {
+    calls,
+    spawn(...args) {
+      calls.push(['spawn', args]);
+      return { kind: 'spawn', args };
+    },
+    execFile(...args) {
+      calls.push(['execFile', args]);
+      return { kind: 'execFile', args };
+    },
+    exec(...args) {
+      calls.push(['exec', args]);
+      return { kind: 'exec', args };
+    },
+    spawnSync(...args) {
+      calls.push(['spawnSync', args]);
+      return { kind: 'spawnSync', args, status: 0 };
+    },
+    execFileSync(...args) {
+      calls.push(['execFileSync', args]);
+      return Buffer.from('ok');
+    },
+    execSync(...args) {
+      calls.push(['execSync', args]);
+      return Buffer.from('ok');
+    },
+  };
+}
+
+test('guarded spawn blocks official npm update without delegating', async () => {
+  const writes = [];
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
+
+  const child = guarded.spawn('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']);
+  assert.equal(child instanceof EventEmitter, true);
+
+  const result = await new Promise(resolve => {
+    child.once('close', (code, signal) => resolve({ code, signal }));
+  });
+
+  assert.deepEqual(result, { code: 1, signal: null });
+  assert.deepEqual(realChild.calls, []);
+  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
+});
+
+test('guarded spawn delegates canonical install', () => {
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, () => {});
+  const result = guarded.spawn('npm', ['install', '-g', '@bash0816/claude-code@2.1.137']);
+
+  assert.equal(result.kind, 'spawn');
+  assert.equal(realChild.calls.length, 1);
+});
+
+test('guarded execFile blocks official npm update callback path', async () => {
+  const writes = [];
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
+
+  const callbackResult = await new Promise(resolve => {
+    guarded.execFile(
+      'npm',
+      ['update', '-g', '@anthropic-ai/claude-code'],
+      (error, stdout, stderr) => resolve({ error, stdout, stderr }),
+    );
+  });
+
+  assert.equal(callbackResult.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
+  assert.equal(callbackResult.stdout, '');
+  assert.equal(callbackResult.stderr, `${BLOCK_MESSAGE}\n`);
+  assert.deepEqual(realChild.calls, []);
+  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
+});
+
+test('guarded exec blocks official npm update shell string', async () => {
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, () => {});
+
+  const callbackResult = await new Promise(resolve => {
+    guarded.exec(
+      'npm install -g @anthropic-ai/claude-code@latest',
+      (error, stdout, stderr) => resolve({ error, stdout, stderr }),
+    );
+  });
+
+  assert.equal(callbackResult.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
+  assert.equal(callbackResult.stdout, '');
+  assert.equal(callbackResult.stderr, `${BLOCK_MESSAGE}\n`);
+  assert.deepEqual(realChild.calls, []);
+});
+
+test('guarded spawnSync blocks official npm update with status 1', () => {
+  const writes = [];
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
+  const result = guarded.spawnSync('npm', ['update', '-g', '@anthropic-ai/claude-code']);
+
+  assert.equal(result.status, 1);
+  assert.equal(Buffer.isBuffer(result.stderr), true);
+  assert.equal(String(result.stderr), `${BLOCK_MESSAGE}\n`);
+  assert.equal(result.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
+  assert.deepEqual(realChild.calls, []);
+  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
+});
+
+test('guarded execFileSync throws on official npm update', () => {
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, () => {});
+
+  assert.throws(
+    () => guarded.execFileSync('npm', ['install', '-g', '@anthropic-ai/claude-code@latest']),
+    error => error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED',
+  );
+  assert.deepEqual(realChild.calls, []);
+});
+
+test('guarded execSync throws on official npm update shell string', () => {
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, () => {});
+
+  assert.throws(
+    () => guarded.execSync('npm update -g @anthropic-ai/claude-code'),
+    error => error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED',
+  );
+  assert.deepEqual(realChild.calls, []);
+});
+
+test('guarded spawn blocks official npm update through sh -c', async () => {
+  const writes = [];
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, value => writes.push(value));
+
+  const child = guarded.spawn('/bin/sh', ['-c', 'npm install -g @anthropic-ai/claude-code']);
+  const result = await new Promise(resolve => {
+    child.once('close', (code, signal) => resolve({ code, signal }));
+  });
+
+  assert.deepEqual(result, { code: 1, signal: null });
+  assert.deepEqual(realChild.calls, []);
+  assert.equal(writes[0], `${BLOCK_MESSAGE}\n`);
+});
+
+test('guarded execFile blocks official update through bash -lc', async () => {
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, () => {});
+
+  const callbackResult = await new Promise(resolve => {
+    guarded.execFile(
+      '/usr/bin/bash',
+      ['-lc', 'pnpm add -g @anthropic-ai/claude-code'],
+      (error, stdout, stderr) => resolve({ error, stdout, stderr }),
+    );
+  });
+
+  assert.equal(callbackResult.error.code, 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED');
+  assert.equal(callbackResult.stdout, '');
+  assert.equal(callbackResult.stderr, `${BLOCK_MESSAGE}\n`);
+  assert.deepEqual(realChild.calls, []);
+});
+
+test('guarded spawn delegates canonical shell install', () => {
+  const realChild = createRealChildStub();
+  const guarded = createGuardedChildProcess(realChild, () => {});
+  const result = guarded.spawn('/bin/sh', ['-c', 'npm install -g @bash0816/claude-code@2.1.137']);
+
+  assert.equal(result.kind, 'spawn');
+  assert.equal(realChild.calls.length, 1);
+});

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

@@ -6,6 +6,7 @@ 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}"
+CLAUDE_TERMUX_PACKAGE_DIR="${CLAUDE_TERMUX_PACKAGE_DIR:?CLAUDE_TERMUX_PACKAGE_DIR 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}"
@@ -42,6 +43,10 @@ export CURRENT_CLAUDE_VERSION
 node - "$@" <<'NODE'
 const fs = require('fs');
 const path = require('path');
+const {
+  BLOCK_MESSAGE,
+  createGuardedChildProcess,
+} = require(path.join(process.env.CLAUDE_TERMUX_PACKAGE_DIR, 'lib', 'native-update-guard.js'));
 
 const sourceBin = process.env.SOURCE_BIN;
 const workdir = process.env.WORKDIR;
@@ -86,6 +91,7 @@ function stringWidth(value) {
 
 function createFakeRequire(realRequire) {
   const realChild = realRequire('child_process');
+
   function rewriteArgs(args) {
     if (
       Array.isArray(args) &&
@@ -98,6 +104,18 @@ function createFakeRequire(realRequire) {
     return args;
   }
 
+  const guardedChild = createGuardedChildProcess(
+    {
+      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),
+    },
+    value => process.stderr.write(value),
+  );
+
   return function fakeRequire(id) {
     if (id === 'ws') {
       class WS {
@@ -112,14 +130,11 @@ function createFakeRequire(realRequire) {
     }
 
     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),
-      };
+      return guardedChild;
+    }
+
+    if (id === 'node:child_process') {
+      return guardedChild;
     }
 
     if (id.startsWith('/$bunfs/root/')) {
@@ -186,6 +201,10 @@ async function main() {
 }
 
 main().catch(error => {
+  if (error && error.code === 'CLAUDE_TERMUX_OFFICIAL_UPDATE_BLOCKED') {
+    console.error(BLOCK_MESSAGE);
+    process.exit(error.status || 1);
+  }
   console.error(error && error.stack ? error.stack : String(error));
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash0816/claude-code",
-  "version": "2.1.137",
+  "version": "2.1.139",
   "description": "Termux-native Claude Code wrapper with audited native replay",
   "license": "MIT",
   "bin": {