@bash0816/claude-code 2.1.159-9 → 2.1.161

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/postinstall.js

@@ -10,9 +10,8 @@ if (process.env.CLAUDE_TERMUX_SKIP_POSTINSTALL === '1') {
 
 const packageDir = path.resolve(__dirname, '..');
 const pkg = require(path.join(packageDir, 'package.json'));
-const manifest = require(path.join(packageDir, 'config', 'claude-termux-release-manifest.json'));
 const script = path.join(__dirname, 'prepare-native.js');
-const version = process.env.CLAUDE_TERMUX_CLAUDE_VERSION || manifest.default_native_version || manifest.latest_audited_version || pkg.version;
+const version = process.env.CLAUDE_TERMUX_CLAUDE_VERSION || pkg.version;
 
 const result = cp.spawnSync(process.execPath, [script, version], {
   stdio: 'inherit',

package/lib/preinstall.js

@@ -1,12 +1,6 @@
 #!/usr/bin/env node
 'use strict';
 
-const [_nodeMajor] = process.versions.node.split('.').map(Number);
-if (_nodeMajor < 20) {
-  process.stderr.write('@bash0816/claude-code requires Node.js v20 or later. Found: v' + process.versions.node + '\n');
-  process.exit(1);
-}
-
 const cp = require('child_process');
 const fs = require('fs');
 const os = require('os');