claude-code-termux 1.0.0

package/scripts/verify-install.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Code Termux Installation Verification
+ *
+ * This script checks that all components are properly installed
+ * and configured for running Claude Code on Termux.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+};
+
+const PASS = `${colors.green}✓${colors.reset}`;
+const FAIL = `${colors.red}✗${colors.reset}`;
+const WARN = `${colors.yellow}!${colors.reset}`;
+
+let passCount = 0;
+let failCount = 0;
+let warnCount = 0;
+
+function check(name, condition, warning = false) {
+  if (condition) {
+    console.log(`${PASS} ${name}`);
+    passCount++;
+    return true;
+  } else if (warning) {
+    console.log(`${WARN} ${name}`);
+    warnCount++;
+    return false;
+  } else {
+    console.log(`${FAIL} ${name}`);
+    failCount++;
+    return false;
+  }
+}
+
+function runCommand(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch (err) {
+    return null;
+  }
+}
+
+console.log('');
+console.log('='.repeat(50));
+console.log('  Claude Code Termux - Installation Verification');
+console.log('='.repeat(50));
+console.log('');
+
+// Environment checks
+console.log(`${colors.blue}Environment:${colors.reset}`);
+
+const isTermux = process.platform === 'android' ||
+                 process.env.PREFIX?.includes('com.termux') ||
+                 process.env.HOME?.includes('com.termux');
+
+check('Termux environment detected', isTermux, true);
+check('HOME directory exists', fs.existsSync(process.env.HOME || ''));
+console.log(`  Platform: ${process.platform}`);
+console.log(`  Architecture: ${process.arch}`);
+console.log(`  HOME: ${process.env.HOME}`);
+console.log('');
+
+// Node.js checks
+console.log(`${colors.blue}Node.js:${colors.reset}`);
+
+const nodeVersion = process.version;
+const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0]);
+
+check('Node.js version >= 18', nodeMajor >= 18);
+check('Node.js version < 25', nodeMajor < 25, true);
+console.log(`  Version: ${nodeVersion}`);
+console.log('');
+
+// Ripgrep checks
+console.log(`${colors.blue}Ripgrep:${colors.reset}`);
+
+const rgPath = runCommand('which rg');
+const rgVersion = runCommand('rg --version');
+
+check('Ripgrep installed', !!rgPath);
+if (rgPath) {
+  console.log(`  Path: ${rgPath}`);
+  console.log(`  Version: ${rgVersion?.split('\n')[0] || 'unknown'}`);
+}
+console.log('');
+
+// Claude Code checks
+console.log(`${colors.blue}Claude Code:${colors.reset}`);
+
+let claudeCodePath = null;
+try {
+  claudeCodePath = require.resolve('@anthropic-ai/claude-code/package.json');
+} catch (err) {
+  // Not found
+}
+
+check('Claude Code installed', !!claudeCodePath);
+
+if (claudeCodePath) {
+  const pkgPath = path.dirname(claudeCodePath);
+  const pkg = require(claudeCodePath);
+  console.log(`  Version: ${pkg.version}`);
+  console.log(`  Path: ${pkgPath}`);
+
+  // Check vendor binaries
+  const vendorRg = path.join(pkgPath, 'vendor', 'ripgrep', 'arm64-android', 'rg');
+  const vendorRgLinux = path.join(pkgPath, 'vendor', 'ripgrep', 'arm64-linux', 'rg');
+
+  check('Vendor ripgrep (android-arm64)', fs.existsSync(vendorRg), true);
+  check('Vendor ripgrep (linux-arm64)', fs.existsSync(vendorRgLinux), true);
+}
+console.log('');
+
+// Sharp checks
+console.log(`${colors.blue}Sharp (Image Support):${colors.reset}`);
+
+let sharpWasm = false;
+let sharpNative = false;
+
+try {
+  require.resolve('@img/sharp-wasm32');
+  sharpWasm = true;
+} catch (err) {
+  // Not found
+}
+
+try {
+  require.resolve('sharp');
+  sharpNative = true;
+} catch (err) {
+  // Not found
+}
+
+check('Sharp WASM available', sharpWasm);
+check('Sharp native available', sharpNative, true);
+console.log('');
+
+// Configuration checks
+console.log(`${colors.blue}Configuration:${colors.reset}`);
+
+const homeDir = process.env.HOME || '/data/data/com.termux/files/home';
+const claudeDir = path.join(homeDir, '.claude');
+const commandsDir = path.join(claudeDir, 'commands');
+
+check('.claude directory exists', fs.existsSync(claudeDir), true);
+check('.claude/commands directory exists', fs.existsSync(commandsDir), true);
+
+const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+check('ANTHROPIC_API_KEY set', hasApiKey, true);
+
+if (!hasApiKey) {
+  console.log(`  ${colors.yellow}Tip: export ANTHROPIC_API_KEY=your-key${colors.reset}`);
+}
+console.log('');
+
+// Summary
+console.log('='.repeat(50));
+console.log('  Summary');
+console.log('='.repeat(50));
+console.log(`  ${PASS} Passed: ${passCount}`);
+console.log(`  ${WARN} Warnings: ${warnCount}`);
+console.log(`  ${FAIL} Failed: ${failCount}`);
+console.log('');
+
+if (failCount > 0) {
+  console.log(`${colors.red}Some checks failed. Please review the errors above.${colors.reset}`);
+  process.exit(1);
+} else if (warnCount > 0) {
+  console.log(`${colors.yellow}Installation OK with some warnings.${colors.reset}`);
+  process.exit(0);
+} else {
+  console.log(`${colors.green}All checks passed! Claude Code is ready to use.${colors.reset}`);
+  process.exit(0);
+}

package/src/binaries/README.md

@@ -0,0 +1,29 @@
+# Binary Files
+
+This directory contains pre-compiled binaries for platforms that don't have native support.
+
+## Ripgrep (rg)
+
+The `rg` binary is not included in the repository due to size constraints. It is downloaded automatically during installation on Termux.
+
+### Manual Download
+
+To download the binary manually:
+
+```bash
+./scripts/download-ripgrep.sh
+```
+
+Or download from: https://github.com/BurntSushi/ripgrep/releases
+
+Use the `aarch64-unknown-linux-gnu` build for Termux ARM64.
+
+### Alternative: System Ripgrep
+
+On Termux, you can also install ripgrep via the package manager:
+
+```bash
+pkg install ripgrep
+```
+
+The wrapper will automatically detect and use the system ripgrep.

package/src/patches/apply-all.js

@@ -0,0 +1,45 @@
+/**
+ * Apply All Termux Patches
+ *
+ * This module applies all necessary runtime patches for Termux/Android compatibility.
+ * It must be loaded before the main Claude Code CLI.
+ */
+
+'use strict';
+
+const path = require('path');
+
+// Patch modules to load
+const patches = [
+  './sharp-fallback',
+  './ripgrep-fallback',
+  './path-normalization',
+  './oauth-storage',
+  './hook-events',
+];
+
+console.log('[claude-code-termux] Applying runtime patches...');
+
+let appliedCount = 0;
+let failedCount = 0;
+
+for (const patchPath of patches) {
+  try {
+    const patch = require(patchPath);
+    if (typeof patch.apply === 'function') {
+      patch.apply();
+      appliedCount++;
+      console.log(`[claude-code-termux] Applied: ${path.basename(patchPath)}`);
+    }
+  } catch (err) {
+    failedCount++;
+    // Don't fail hard - some patches may not be needed
+    if (process.env.DEBUG) {
+      console.error(`[claude-code-termux] Failed to apply ${patchPath}:`, err.message);
+    }
+  }
+}
+
+console.log(`[claude-code-termux] Patches applied: ${appliedCount}, skipped: ${failedCount}`);
+
+module.exports = { appliedCount, failedCount };

package/src/patches/hook-events.js

@@ -0,0 +1,108 @@
+/**
+ * Hook Events Patch
+ *
+ * This patch attempts to fix the PostToolUse hook not firing on Termux.
+ * The issue seems to be related to event emission on the Android platform.
+ *
+ * Issue: https://github.com/anthropics/claude-code/issues/15617
+ */
+
+'use strict';
+
+const EventEmitter = require('events');
+
+// Detect Termux environment
+const isTermux = process.platform === 'android' ||
+                 process.env.PREFIX?.includes('com.termux') ||
+                 process.env.HOME?.includes('com.termux');
+
+// Store original methods
+const originalEmit = EventEmitter.prototype.emit;
+const originalOn = EventEmitter.prototype.on;
+
+// Track hook-related events
+const hookEvents = new Set([
+  'PreToolUse',
+  'PostToolUse',
+  'PreApiCall',
+  'PostApiCall',
+  'Notification',
+  'Stop',
+]);
+
+// Debug hook events
+const hookDebugEnabled = process.env.DEBUG_HOOKS === '1';
+
+/**
+ * Wrap emit to ensure hook events are properly fired
+ */
+function patchedEmit(eventName, ...args) {
+  if (hookDebugEnabled && hookEvents.has(eventName)) {
+    console.log(`[claude-code-termux] Hook event: ${eventName}`, args.length > 0 ? '(with args)' : '');
+  }
+
+  // Call original emit
+  const result = originalEmit.call(this, eventName, ...args);
+
+  // On Termux, sometimes events need to be queued for next tick
+  // to ensure all listeners have been registered
+  if (isTermux && hookEvents.has(eventName) && !result) {
+    // If no listeners handled it, try again on next tick
+    setImmediate(() => {
+      const retryResult = originalEmit.call(this, eventName, ...args);
+      if (hookDebugEnabled && retryResult) {
+        console.log(`[claude-code-termux] Hook event handled on retry: ${eventName}`);
+      }
+    });
+  }
+
+  return result;
+}
+
+/**
+ * Wrap on/addListener to track hook registrations
+ */
+function patchedOn(eventName, listener) {
+  if (hookDebugEnabled && hookEvents.has(eventName)) {
+    console.log(`[claude-code-termux] Hook listener registered: ${eventName}`);
+  }
+
+  return originalOn.call(this, eventName, listener);
+}
+
+/**
+ * Apply the hook events patch
+ */
+function apply() {
+  if (!isTermux) {
+    return;
+  }
+
+  // Patch EventEmitter prototype
+  EventEmitter.prototype.emit = patchedEmit;
+  EventEmitter.prototype.on = patchedOn;
+  EventEmitter.prototype.addListener = patchedOn;
+
+  // Increase max listeners to prevent warnings in hook-heavy scenarios
+  EventEmitter.defaultMaxListeners = 20;
+
+  if (process.env.DEBUG) {
+    console.log('[claude-code-termux] Hook events patch applied');
+    console.log('[claude-code-termux] Set DEBUG_HOOKS=1 to trace hook events');
+  }
+}
+
+/**
+ * Restore original EventEmitter methods
+ */
+function restore() {
+  EventEmitter.prototype.emit = originalEmit;
+  EventEmitter.prototype.on = originalOn;
+  EventEmitter.prototype.addListener = originalOn;
+}
+
+module.exports = {
+  apply,
+  restore,
+  hookEvents,
+};

package/src/patches/oauth-storage.js

@@ -0,0 +1,163 @@
+/**
+ * OAuth Storage Fallback Patch
+ *
+ * This patch provides a fallback token storage mechanism for Termux
+ * where the system keychain is not available.
+ *
+ * Issue: https://github.com/anthropics/claude-code/issues/6244
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Detect Termux environment
+const isTermux = process.platform === 'android' ||
+                 process.env.PREFIX?.includes('com.termux') ||
+                 process.env.HOME?.includes('com.termux');
+
+// Token storage file
+const TOKEN_FILE = path.join(
+  process.env.HOME || '/data/data/com.termux/files/home',
+  '.claude',
+  '.oauth-tokens.enc'
+);
+
+// Encryption key derived from device-specific info
+function getEncryptionKey() {
+  // Use a combination of device-specific values for the key
+  const keyMaterial = [
+    process.env.HOME || '',
+    process.env.USER || '',
+    process.env.PREFIX || '',
+    'claude-code-termux-v1',
+  ].join(':');
+
+  return crypto.createHash('sha256').update(keyMaterial).digest();
+}
+
+/**
+ * Encrypt data for storage
+ */
+function encrypt(data) {
+  const key = getEncryptionKey();
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+
+  let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+
+  const authTag = cipher.getAuthTag();
+
+  return JSON.stringify({
+    iv: iv.toString('hex'),
+    authTag: authTag.toString('hex'),
+    data: encrypted,
+  });
+}
+
+/**
+ * Decrypt stored data
+ */
+function decrypt(encryptedData) {
+  try {
+    const parsed = JSON.parse(encryptedData);
+    const key = getEncryptionKey();
+    const iv = Buffer.from(parsed.iv, 'hex');
+    const authTag = Buffer.from(parsed.authTag, 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(authTag);
+
+    let decrypted = decipher.update(parsed.data, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+
+    return JSON.parse(decrypted);
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Store OAuth tokens
+ */
+function storeTokens(tokens) {
+  const dir = path.dirname(TOKEN_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+
+  const encrypted = encrypt(tokens);
+  fs.writeFileSync(TOKEN_FILE, encrypted, { mode: 0o600 });
+}
+
+/**
+ * Retrieve OAuth tokens
+ */
+function getTokens() {
+  if (!fs.existsSync(TOKEN_FILE)) {
+    return null;
+  }
+
+  try {
+    const encrypted = fs.readFileSync(TOKEN_FILE, 'utf8');
+    return decrypt(encrypted);
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Clear stored OAuth tokens
+ */
+function clearTokens() {
+  if (fs.existsSync(TOKEN_FILE)) {
+    fs.unlinkSync(TOKEN_FILE);
+  }
+}
+
+/**
+ * Check if tokens are stored
+ */
+function hasTokens() {
+  return fs.existsSync(TOKEN_FILE);
+}
+
+/**
+ * Apply the OAuth storage patch
+ */
+function apply() {
+  if (!isTermux) {
+    return;
+  }
+
+  // Export functions globally for Claude Code to potentially use
+  global.__claudeCodeTermuxOAuth = {
+    storeTokens,
+    getTokens,
+    clearTokens,
+    hasTokens,
+  };
+
+  // Note: The actual integration with Claude Code's auth system
+  // requires patching the obfuscated cli.mjs, which is complex.
+  // For now, we recommend using API key authentication:
+  // export ANTHROPIC_API_KEY=your-key
+
+  if (process.env.DEBUG) {
+    console.log('[claude-code-termux] OAuth fallback storage initialized');
+    console.log('[claude-code-termux] Token file:', TOKEN_FILE);
+    console.log('[claude-code-termux] Has stored tokens:', hasTokens());
+  }
+}
+
+module.exports = {
+  apply,
+  storeTokens,
+  getTokens,
+  clearTokens,
+  hasTokens,
+  encrypt,
+  decrypt,
+};

package/src/patches/path-normalization.js

@@ -0,0 +1,134 @@
+/**
+ * Path Normalization Patch
+ *
+ * This patch fixes path resolution issues on Termux where:
+ * - Home directory is at /data/data/com.termux/files/home
+ * - Glob patterns may not work correctly with these paths
+ * - Custom slash commands in .claude/commands/ are not discovered
+ *
+ * Issue: https://github.com/anthropics/claude-code/issues/9435
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Detect Termux environment
+const isTermux = process.platform === 'android' ||
+                 process.env.PREFIX?.includes('com.termux') ||
+                 process.env.HOME?.includes('com.termux');
+
+// Termux-specific paths
+const TERMUX_HOME = '/data/data/com.termux/files/home';
+const TERMUX_PREFIX = '/data/data/com.termux/files/usr';
+
+/**
+ * Get the correct home directory for Termux
+ */
+function getHomeDir() {
+  if (isTermux) {
+    return process.env.HOME || TERMUX_HOME;
+  }
+  return os.homedir();
+}
+
+/**
+ * Normalize a path for Termux compatibility
+ */
+function normalizePath(inputPath) {
+  if (!inputPath || !isTermux) {
+    return inputPath;
+  }
+
+  let normalized = inputPath;
+
+  // Replace ~ with actual home directory
+  if (normalized.startsWith('~')) {
+    normalized = normalized.replace(/^~/, getHomeDir());
+  }
+
+  // Ensure path is absolute
+  if (!path.isAbsolute(normalized)) {
+    normalized = path.resolve(process.cwd(), normalized);
+  }
+
+  return normalized;
+}
+
+/**
+ * Get paths for Claude configuration directories
+ */
+function getClaudePaths() {
+  const home = getHomeDir();
+  return {
+    home,
+    claudeDir: path.join(home, '.claude'),
+    commandsDir: path.join(home, '.claude', 'commands'),
+    agentsDir: path.join(home, '.claude', 'agents'),
+    configFile: path.join(home, '.claude', 'config.json'),
+  };
+}
+
+/**
+ * Ensure all required Claude directories exist
+ */
+function ensureClaudeDirs() {
+  const paths = getClaudePaths();
+
+  const dirs = [paths.claudeDir, paths.commandsDir, paths.agentsDir];
+
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) {
+      try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o755 });
+      } catch (err) {
+        // Directory might already exist or we don't have permission
+      }
+    }
+  }
+
+  return paths;
+}
+
+/**
+ * Apply the path normalization patches
+ */
+function apply() {
+  if (!isTermux) {
+    return;
+  }
+
+  // Ensure Claude directories exist
+  const paths = ensureClaudeDirs();
+
+  // Override os.homedir to return Termux home
+  const originalHomedir = os.homedir;
+  os.homedir = function() {
+    if (isTermux) {
+      return getHomeDir();
+    }
+    return originalHomedir();
+  };
+
+  // Set environment variables that Claude Code might use
+  process.env.HOME = getHomeDir();
+  process.env.CLAUDE_CONFIG_DIR = paths.claudeDir;
+
+  // Log for debugging
+  if (process.env.DEBUG) {
+    console.log('[claude-code-termux] Path normalization applied');
+    console.log('[claude-code-termux] HOME:', process.env.HOME);
+    console.log('[claude-code-termux] Claude dir:', paths.claudeDir);
+  }
+}
+
+module.exports = {
+  apply,
+  getHomeDir,
+  normalizePath,
+  getClaudePaths,
+  ensureClaudeDirs,
+  isTermux,
+};