claude-code-termux 1.0.18 → 1.0.19

package/.github/workflows/auto-update.yml

@@ -1,113 +1,160 @@
-name: Auto-update and publish
+name: Sync & Publish
 
 on:
   schedule:
-    - cron: '0 6 * * *'  # 6 AM UTC daily
-  workflow_dispatch:
-    inputs:
-      force_publish:
-        description: 'Force publish (skip upstream check)'
-        required: false
-        default: false
-        type: boolean
-      version_bump:
-        description: 'Version bump type (only for force publish)'
-        required: false
-        default: 'patch'
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
+    - cron: '0 6 * * *'       # Daily at 6 AM UTC
+  workflow_dispatch:            # Manual trigger — no inputs needed
 
 permissions:
-  contents: write      # For pushing version bump commits
-  id-token: write      # Required for npm OIDC trusted publishing
+  contents: write
+  id-token: write
 
 jobs:
-  check-and-publish:
+  sync-and-publish:
     runs-on: ubuntu-latest
     steps:
+
+      # ── Setup ──────────────────────────────────────────────
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          fetch-tags: true
 
       - uses: actions/setup-node@v4
         with:
-          node-version: '24'  # Node 24+ required for OIDC (npm >=11.5)
-          registry-url: 'https://registry.npmjs.org'
+          node-version: 24
+          registry-url: https://registry.npmjs.org
 
-      - name: Check for upstream updates
-        id: check
-        if: ${{ !inputs.force_publish }}
+      # ── Detect changes ────────────────────────────────────
+      - name: Check for upstream and source changes
+        id: detect
         run: |
-          # Get current dependency version (strip ^ prefix)
-          CURRENT=$(node -p "require('./package.json').dependencies['@anthropic-ai/claude-code'].replace('^', '')")
-          echo "Current version: $CURRENT"
-
-          # Get latest version from npm
-          LATEST=$(npm view @anthropic-ai/claude-code version)
-          echo "Latest version: $LATEST"
-
-          if [ "$CURRENT" != "$LATEST" ]; then
-            echo "Update needed: $CURRENT -> $LATEST"
-            echo "update_needed=true" >> $GITHUB_OUTPUT
-            echo "new_version=$LATEST" >> $GITHUB_OUTPUT
+          set -e
+
+          # --- Upstream check ---
+          CURRENT_DEP=$(node -p "require('./package.json').dependencies['@anthropic-ai/claude-code'].replace('^','')")
+          LATEST_DEP=$(npm view @anthropic-ai/claude-code version)
+          echo "current_dep=$CURRENT_DEP" >> "$GITHUB_OUTPUT"
+          echo "latest_dep=$LATEST_DEP" >> "$GITHUB_OUTPUT"
+
+          UPSTREAM_CHANGED=false
+          if [ "$CURRENT_DEP" != "$LATEST_DEP" ]; then
+            UPSTREAM_CHANGED=true
+            echo "⬆️  Upstream: $CURRENT_DEP → $LATEST_DEP"
+          else
+            echo "✓  Upstream up to date ($CURRENT_DEP)"
+          fi
+          echo "upstream_changed=$UPSTREAM_CHANGED" >> "$GITHUB_OUTPUT"
+
+          # --- Source change check ---
+          REPO_VERSION=$(node -p "require('./package.json').version")
+          NPM_VERSION=$(npm view claude-code-termux version 2>/dev/null || echo "0.0.0")
+          echo "repo_version=$REPO_VERSION" >> "$GITHUB_OUTPUT"
+          echo "npm_version=$NPM_VERSION" >> "$GITHUB_OUTPUT"
+
+          SOURCE_CHANGED=false
+          if [ "$REPO_VERSION" != "$NPM_VERSION" ]; then
+            SOURCE_CHANGED=true
+            echo "📦 Source: repo v$REPO_VERSION != npm v$NPM_VERSION"
+          else
+            TAG="v$NPM_VERSION"
+            if git rev-parse "$TAG" >/dev/null 2>&1; then
+              COMMITS_SINCE=$(git log "$TAG"..HEAD --oneline -- . ':!package-lock.json' | wc -l | tr -d ' ')
+              if [ "$COMMITS_SINCE" -gt 0 ]; then
+                SOURCE_CHANGED=true
+                echo "📦 Source: $COMMITS_SINCE commit(s) since $TAG"
+              else
+                echo "✓  Source unchanged since $TAG"
+              fi
+            else
+              echo "✓  No tag $TAG found — using version comparison only"
+            fi
+          fi
+          echo "source_changed=$SOURCE_CHANGED" >> "$GITHUB_OUTPUT"
+
+          # --- Overall decision ---
+          if [ "$UPSTREAM_CHANGED" = "true" ] || [ "$SOURCE_CHANGED" = "true" ]; then
+            echo "needs_publish=true" >> "$GITHUB_OUTPUT"
           else
-            echo "Already up to date"
-            echo "update_needed=false" >> $GITHUB_OUTPUT
+            echo "needs_publish=false" >> "$GITHUB_OUTPUT"
+            echo "✅ Everything is up to date. Nothing to publish."
           fi
 
-      - name: Update dependency and bump version (auto)
-        if: ${{ !inputs.force_publish && steps.check.outputs.update_needed == 'true' }}
+      # ── Update upstream dependency ────────────────────────
+      - name: Update upstream dependency
+        if: steps.detect.outputs.upstream_changed == 'true'
         run: |
-          npm pkg set "dependencies.@anthropic-ai/claude-code=^${{ steps.check.outputs.new_version }}"
-          npm version patch --no-git-tag-version
-          echo "Updated package.json:"
-          cat package.json | head -35
+          npm pkg set "dependencies.@anthropic-ai/claude-code=^${{ steps.detect.outputs.latest_dep }}"
 
-      - name: Bump version (manual)
-        if: ${{ inputs.force_publish }}
+      # ── Bump version if needed ────────────────────────────
+      - name: Bump version
+        if: steps.detect.outputs.needs_publish == 'true'
+        id: version
         run: |
-          npm version ${{ inputs.version_bump }} --no-git-tag-version
+          REPO_VERSION=${{ steps.detect.outputs.repo_version }}
+          NPM_VERSION=${{ steps.detect.outputs.npm_version }}
+
+          if [ "$REPO_VERSION" = "$NPM_VERSION" ]; then
+            npm version patch --no-git-tag-version
+            echo "bumped=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "bumped=false" >> "$GITHUB_OUTPUT"
+          fi
+
           NEW_VERSION=$(node -p "require('./package.json').version")
-          echo "New version: $NEW_VERSION"
+          echo "new_version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
+          echo "📌 Will publish v$NEW_VERSION"
 
-      - name: Commit and push changes
-        if: ${{ inputs.force_publish || steps.check.outputs.update_needed == 'true' }}
+      # ── Commit, tag, push ─────────────────────────────────
+      - name: Commit and push
+        if: steps.detect.outputs.needs_publish == 'true'
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
-          VERSION=$(node -p "require('./package.json').version")
-          git add -A
-          if [ "${{ inputs.force_publish }}" == "true" ]; then
-            git commit -m "Release v${VERSION}"
-            git tag "v${VERSION}"
-            git push --tags
-          else
-            git commit -m "Bump @anthropic-ai/claude-code to ${{ steps.check.outputs.new_version }}"
+
+          VERSION=${{ steps.version.outputs.new_version }}
+          UPSTREAM=${{ steps.detect.outputs.upstream_changed }}
+          SOURCE=${{ steps.detect.outputs.source_changed }}
+
+          MSG="Release v${VERSION}"
+          DETAILS=""
+          if [ "$UPSTREAM" = "true" ]; then
+            DETAILS="${DETAILS}\n- Bump @anthropic-ai/claude-code to ${{ steps.detect.outputs.latest_dep }}"
+          fi
+          if [ "$SOURCE" = "true" ]; then
+            DETAILS="${DETAILS}\n- Include source changes"
           fi
-          git push
 
+          git add -A
+          git commit -m "$(printf "${MSG}\n${DETAILS}")" || echo "Nothing to commit"
+          git tag "v${VERSION}"
+          git push --follow-tags
+
+      # ── Publish ───────────────────────────────────────────
       - name: Install dependencies
-        if: ${{ inputs.force_publish || steps.check.outputs.update_needed == 'true' }}
+        if: steps.detect.outputs.needs_publish == 'true'
         run: npm install
 
-      - name: Publish to npm (OIDC)
-        if: ${{ inputs.force_publish || steps.check.outputs.update_needed == 'true' }}
+      - name: Publish to npm
+        if: steps.detect.outputs.needs_publish == 'true'
         run: npm publish --access public
 
+      # ── Summary ───────────────────────────────────────────
       - name: Summary
         run: |
-          VERSION=$(node -p "require('./package.json').version")
-          if [ "${{ inputs.force_publish }}" == "true" ]; then
-            echo "## Published v${VERSION}" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "Manual release published." >> $GITHUB_STEP_SUMMARY
-          elif [ "${{ steps.check.outputs.update_needed }}" == "true" ]; then
-            echo "## Update Published" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "Updated @anthropic-ai/claude-code to version ${{ steps.check.outputs.new_version }}" >> $GITHUB_STEP_SUMMARY
+          NEEDS=${{ steps.detect.outputs.needs_publish }}
+          if [ "$NEEDS" = "true" ]; then
+            VERSION=${{ steps.version.outputs.new_version }}
+            echo "### ✅ Published v${VERSION}" >> "$GITHUB_STEP_SUMMARY"
+            echo "" >> "$GITHUB_STEP_SUMMARY"
+            if [ "${{ steps.detect.outputs.upstream_changed }}" = "true" ]; then
+              echo "- Upstream: \`@anthropic-ai/claude-code\` → ${{ steps.detect.outputs.latest_dep }}" >> "$GITHUB_STEP_SUMMARY"
+            fi
+            if [ "${{ steps.detect.outputs.source_changed }}" = "true" ]; then
+              echo "- Source changes included" >> "$GITHUB_STEP_SUMMARY"
+            fi
           else
-            echo "## No Update Needed" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            echo "Already using the latest version of @anthropic-ai/claude-code" >> $GITHUB_STEP_SUMMARY
+            echo "### ✅ No Update Needed" >> "$GITHUB_STEP_SUMMARY"
+            echo "Upstream: \`${{ steps.detect.outputs.current_dep }}\` (latest)" >> "$GITHUB_STEP_SUMMARY"
+            echo "Package: \`v${{ steps.detect.outputs.repo_version }}\` (published)" >> "$GITHUB_STEP_SUMMARY"
           fi

package/bin/claude-termux.js

@@ -15,21 +15,21 @@
 
 const path = require('path');
 const fs = require('fs');
+const ui = require('../src/ui');
 
-// Detect if running on Termux/Android
-const isTermux = process.platform === 'android' ||
-                 process.env.PREFIX?.includes('com.termux') ||
-                 process.env.HOME?.includes('com.termux');
+// Read version from package.json
+const pkg = require('../package.json');
 
-// Apply runtime patches for Termux
-if (isTermux) {
-  console.log('[claude-code-termux] Detected Termux environment, applying patches...');
+// Show the banner (always — both Termux and desktop)
+ui.printBanner(pkg.version);
 
+// Apply runtime boosts for Termux
+let boostResult = null;
+if (ui.isTermux) {
   try {
-    // Apply all patches
-    require('../src/patches/apply-all');
+    boostResult = require('../src/patches/apply-all');
   } catch (err) {
-    console.error('[claude-code-termux] Warning: Some patches could not be applied:', err.message);
+    ui.logError(`Boost loading failed: ${err.message}`);
   }
 }
 
@@ -66,18 +66,22 @@ try {
 }
 
 if (!claudeCodePath) {
-  console.error('[claude-code-termux] Error: Could not find @anthropic-ai/claude-code');
+  ui.logError('Could not find @anthropic-ai/claude-code');
   console.error('');
-  console.error('The Claude Code package was not found. Install it with:');
-  console.error('  npm install -g @anthropic-ai/claude-code');
+  console.error('  Install it with:');
+  ui.logDim('npm install -g @anthropic-ai/claude-code');
   console.error('');
-  console.error('Searched paths:');
+  console.error('  Searched paths:');
   possiblePaths.forEach(p => {
-    if (p) console.error(`  - ${p}`);
+    if (p) ui.logDim(p);
   });
   process.exit(1);
 }
 
+// Show ready status
+const hasWarnings = boostResult && boostResult.failedCount > 0;
+ui.logReady(hasWarnings);
+
 // Auto-update check (runs before loading Claude Code)
 // This checks for updates and may restart the process if an update is found
 const { checkAndUpdate } = require('../src/auto-update');
@@ -92,17 +96,19 @@ checkAndUpdate().then(updated => {
   // Use dynamic import since cli.js is an ES module
   return import(claudeCodePath);
 }).catch(err => {
-  console.error('[claude-code-termux] Error loading Claude Code:', err.message);
+  ui.logError(`Error loading Claude Code: ${err.message}`);
 
   if (err.message.includes('sharp')) {
-    console.error('\nSharp module error detected. Try running:');
-    console.error('  npm install @img/sharp-wasm32 --force');
-    console.error('  npm install sharp --force');
+    console.error('');
+    ui.logWarn('Sharp module error detected. Try running:');
+    ui.logDim('npm install @img/sharp-wasm32 --force');
+    ui.logDim('npm install sharp --force');
   }
 
   if (err.message.includes('ENOENT') && err.message.includes('ripgrep')) {
-    console.error('\nRipgrep binary not found. Try running:');
-    console.error('  pkg install ripgrep');
+    console.error('');
+    ui.logWarn('Ripgrep binary not found. Try running:');
+    ui.logDim('pkg install ripgrep');
   }
 
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-termux",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "Claude Code CLI with Termux/Android compatibility fixes - a wrapper that patches issues with Sharp, ripgrep, and path resolution on ARM64 Android",
   "author": "Jimoh Ovbiagele <findingjimoh@gmail.com>",
   "license": "MIT",

package/postinstall.js

@@ -15,6 +15,10 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const ui = require('./src/ui');
+
+// Read version
+const pkg = require('./package.json');
 
 // Detect Termux environment
 const isTermux = process.platform === 'android' ||
@@ -23,9 +27,8 @@ const isTermux = process.platform === 'android' ||
 
 const isARM64 = process.arch === 'arm64';
 
-console.log('[claude-code-termux] Post-install script running...');
-console.log(`[claude-code-termux] Platform: ${process.platform}, Arch: ${process.arch}`);
-console.log(`[claude-code-termux] Termux detected: ${isTermux}`);
+ui.printBanner(pkg.version);
+ui.logArrow('Running post-install setup...');
 
 /**
  * Find the Claude Code installation directory
@@ -50,12 +53,9 @@ function findClaudeCodePath() {
  */
 function setupRipgrep(claudeCodePath) {
   if (!isTermux || !isARM64) {
-    console.log('[claude-code-termux] Skipping ripgrep setup (not Termux ARM64)');
     return;
   }
 
-  console.log('[claude-code-termux] Setting up ripgrep for ARM64 Android...');
-
   const vendorDir = path.join(claudeCodePath, 'vendor', 'ripgrep', 'arm64-android');
 
   // Create directory if it doesn't exist
@@ -68,10 +68,8 @@ function setupRipgrep(claudeCodePath) {
   // Check if we have a bundled binary
   const bundledBinary = path.join(__dirname, 'src', 'binaries', 'rg');
   if (fs.existsSync(bundledBinary)) {
-    console.log('[claude-code-termux] Using bundled ripgrep binary');
     fs.copyFileSync(bundledBinary, targetBinary);
     fs.chmodSync(targetBinary, 0o755);
-    console.log('[claude-code-termux] Ripgrep binary installed successfully');
     return;
   }
 
@@ -79,13 +77,11 @@ function setupRipgrep(claudeCodePath) {
   try {
     const systemRg = execSync('which rg', { encoding: 'utf8' }).trim();
     if (systemRg && fs.existsSync(systemRg)) {
-      console.log(`[claude-code-termux] Found system ripgrep at ${systemRg}`);
       // Create symlink to system ripgrep
       if (fs.existsSync(targetBinary)) {
         fs.unlinkSync(targetBinary);
       }
       fs.symlinkSync(systemRg, targetBinary);
-      console.log('[claude-code-termux] Linked to system ripgrep');
       return;
     }
   } catch (err) {
@@ -93,7 +89,6 @@ function setupRipgrep(claudeCodePath) {
   }
 
   // Try to download ripgrep
-  console.log('[claude-code-termux] Attempting to download ripgrep...');
   try {
     // Use curl to download (available in Termux)
     const rgUrl = 'https://github.com/BurntSushi/ripgrep/releases/download/14.1.1/ripgrep-14.1.1-aarch64-unknown-linux-gnu.tar.gz';
@@ -114,15 +109,14 @@ function setupRipgrep(claudeCodePath) {
       if (fs.existsSync(extractedBinary)) {
         fs.copyFileSync(extractedBinary, targetBinary);
         fs.chmodSync(targetBinary, 0o755);
-        console.log('[claude-code-termux] Ripgrep downloaded and installed successfully');
       }
     }
 
     // Cleanup
     fs.rmSync(tmpDir, { recursive: true, force: true });
   } catch (err) {
-    console.error('[claude-code-termux] Failed to download ripgrep:', err.message);
-    console.log('[claude-code-termux] Please install ripgrep manually: pkg install ripgrep');
+    ui.logError(`Failed to download ripgrep: ${err.message}`);
+    ui.logDim('Install ripgrep manually: pkg install ripgrep');
   }
 }
 
@@ -147,11 +141,10 @@ function copyLinuxBinariesAsAndroidFallback(claudeCodePath) {
     const androidPath = path.join(vendorDir, tool, 'arm64-android');
 
     if (fs.existsSync(linuxPath) && !fs.existsSync(androidPath)) {
-      console.log(`[claude-code-termux] Copying ${tool} linux-arm64 as android-arm64 fallback`);
       try {
         fs.cpSync(linuxPath, androidPath, { recursive: true });
       } catch (err) {
-        console.error(`[claude-code-termux] Failed to copy ${tool}:`, err.message);
+        ui.logError(`Failed to copy ${tool}: ${err.message}`);
       }
     }
   }
@@ -166,7 +159,6 @@ function setupOAuthStorage() {
 
   if (!fs.existsSync(claudeDir)) {
     fs.mkdirSync(claudeDir, { recursive: true, mode: 0o700 });
-    console.log('[claude-code-termux] Created .claude directory');
   }
 }
 
@@ -179,14 +171,11 @@ function installSharpWasm() {
     return;
   }
 
-  console.log('[claude-code-termux] Installing Sharp WASM for image support...');
-
   const nodeModulesDir = path.join(__dirname, 'node_modules', '@img');
   const sharpWasmDir = path.join(nodeModulesDir, 'sharp-wasm32');
 
   // Check if already installed
   if (fs.existsSync(path.join(sharpWasmDir, 'package.json'))) {
-    console.log('[claude-code-termux] Sharp WASM already installed');
     return;
   }
 
@@ -200,7 +189,6 @@ function installSharpWasm() {
     const tarballUrl = 'https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.34.5.tgz';
     const tmpTar = path.join(__dirname, 'sharp-wasm32.tgz');
 
-    console.log('[claude-code-termux] Downloading Sharp WASM from npm registry...');
     execSync(`curl -sL "${tarballUrl}" -o "${tmpTar}"`, { stdio: 'inherit' });
 
     // Extract to node_modules/@img/sharp-wasm32
@@ -218,12 +206,10 @@ function installSharpWasm() {
 
     // Cleanup
     fs.unlinkSync(tmpTar);
-
-    console.log('[claude-code-termux] Sharp WASM installed successfully');
   } catch (err) {
-    console.error('[claude-code-termux] Failed to install Sharp WASM:', err.message);
-    console.log('[claude-code-termux] Image reading may not work. You can try manually:');
-    console.log('  curl -sL https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.34.5.tgz | tar -xz -C node_modules/@img/ && mv node_modules/@img/package node_modules/@img/sharp-wasm32');
+    ui.logError(`Failed to install Sharp WASM: ${err.message}`);
+    ui.logDim('Image reading may not work. You can try manually:');
+    ui.logDim('curl -sL https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.34.5.tgz | tar -xz -C node_modules/@img/ && mv node_modules/@img/package node_modules/@img/sharp-wasm32');
   }
 }
 
@@ -234,12 +220,10 @@ function main() {
   const claudeCodePath = findClaudeCodePath();
 
   if (!claudeCodePath) {
-    console.log('[claude-code-termux] Claude Code not found yet (will be installed next)');
+    ui.logDim('Claude Code not found yet (will be installed next)');
     return;
   }
 
-  console.log(`[claude-code-termux] Found Claude Code at: ${claudeCodePath}`);
-
   // Run setup tasks
   if (isTermux) {
     setupRipgrep(claudeCodePath);
@@ -248,13 +232,15 @@ function main() {
     installSharpWasm();
   }
 
-  console.log('[claude-code-termux] Post-install complete!');
+  ui.logStep('Setup complete!');
 
   if (isTermux) {
-    console.log('\n[claude-code-termux] Termux setup tips:');
-    console.log('  - If you encounter ripgrep errors, run: pkg install ripgrep');
-    console.log('  - Use API key auth: export ANTHROPIC_API_KEY=your-key');
-    console.log('\nRun "claude" to start Claude Code!');
+    console.log('');
+    ui.logDim('Termux tips:');
+    ui.logDim('  If you encounter ripgrep errors, run: pkg install ripgrep');
+    ui.logDim('  Use API key auth: export ANTHROPIC_API_KEY=your-key');
+    console.log('');
+    ui.logStep('Run "claude" to start Claude Code!');
   }
 }
 

package/scripts/verify-install.js

@@ -12,19 +12,13 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const { c, symbols, printBanner } = require('../src/ui');
 
-// ANSI colors
-const colors = {
-  reset: '\x1b[0m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-};
+const pkg = require('../package.json');
 
-const PASS = `${colors.green}✓${colors.reset}`;
-const FAIL = `${colors.red}✗${colors.reset}`;
-const WARN = `${colors.yellow}!${colors.reset}`;
+const PASS = `${c.green}${symbols.check}${c.reset}`;
+const FAIL = `${c.brightRed}${symbols.cross}${c.reset}`;
+const WARN = `${c.yellow}${symbols.warn}${c.reset}`;
 
 let passCount = 0;
 let failCount = 0;
@@ -32,15 +26,15 @@ let warnCount = 0;
 
 function check(name, condition, warning = false) {
   if (condition) {
-    console.log(`${PASS} ${name}`);
+    console.log(`  ${PASS} ${name}`);
     passCount++;
     return true;
   } else if (warning) {
-    console.log(`${WARN} ${name}`);
+    console.log(`  ${WARN} ${name}`);
     warnCount++;
     return false;
   } else {
-    console.log(`${FAIL} ${name}`);
+    console.log(`  ${FAIL} ${name}`);
     failCount++;
     return false;
   }
@@ -54,14 +48,12 @@ function runCommand(cmd) {
   }
 }
 
-console.log('');
-console.log('='.repeat(50));
-console.log('  Claude Code Termux - Installation Verification');
-console.log('='.repeat(50));
+printBanner(pkg.version);
+console.log(`  ${c.bold}${c.cyan}Installation Verification${c.reset}`);
 console.log('');
 
 // Environment checks
-console.log(`${colors.blue}Environment:${colors.reset}`);
+console.log(`  ${c.bold}${c.cyan}Environment:${c.reset}`);
 
 const isTermux = process.platform === 'android' ||
                  process.env.PREFIX?.includes('com.termux') ||
@@ -69,37 +61,37 @@ const isTermux = process.platform === 'android' ||
 
 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(`    ${c.dim}Platform: ${process.platform}${c.reset}`);
+console.log(`    ${c.dim}Architecture: ${process.arch}${c.reset}`);
+console.log(`    ${c.dim}HOME: ${process.env.HOME}${c.reset}`);
 console.log('');
 
 // Node.js checks
-console.log(`${colors.blue}Node.js:${colors.reset}`);
+console.log(`  ${c.bold}${c.cyan}Node.js:${c.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(`    ${c.dim}Version: ${nodeVersion}${c.reset}`);
 console.log('');
 
 // Ripgrep checks
-console.log(`${colors.blue}Ripgrep:${colors.reset}`);
+console.log(`  ${c.bold}${c.cyan}Ripgrep:${c.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(`    ${c.dim}Path: ${rgPath}${c.reset}`);
+  console.log(`    ${c.dim}Version: ${rgVersion?.split('\n')[0] || 'unknown'}${c.reset}`);
 }
 console.log('');
 
 // Claude Code checks
-console.log(`${colors.blue}Claude Code:${colors.reset}`);
+console.log(`  ${c.bold}${c.cyan}Claude Code:${c.reset}`);
 
 let claudeCodePath = null;
 try {
@@ -112,9 +104,9 @@ 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}`);
+  const ccPkg = require(claudeCodePath);
+  console.log(`    ${c.dim}Version: ${ccPkg.version}${c.reset}`);
+  console.log(`    ${c.dim}Path: ${pkgPath}${c.reset}`);
 
   // Check vendor binaries
   const vendorRg = path.join(pkgPath, 'vendor', 'ripgrep', 'arm64-android', 'rg');
@@ -126,7 +118,7 @@ if (claudeCodePath) {
 console.log('');
 
 // Sharp checks
-console.log(`${colors.blue}Sharp (Image Support):${colors.reset}`);
+console.log(`  ${c.bold}${c.cyan}Sharp (Image Support):${c.reset}`);
 
 let sharpWasm = false;
 let sharpNative = false;
@@ -150,7 +142,7 @@ check('Sharp native available', sharpNative, true);
 console.log('');
 
 // Configuration checks
-console.log(`${colors.blue}Configuration:${colors.reset}`);
+console.log(`  ${c.bold}${c.cyan}Configuration:${c.reset}`);
 
 const homeDir = process.env.HOME || '/data/data/com.termux/files/home';
 const claudeDir = path.join(homeDir, '.claude');
@@ -163,26 +155,26 @@ 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(`    ${c.dim}Tip: export ANTHROPIC_API_KEY=your-key${c.reset}`);
 }
 console.log('');
 
 // Summary
-console.log('='.repeat(50));
-console.log('  Summary');
-console.log('='.repeat(50));
+console.log(`  ${c.cyan}${symbols.boxH.repeat(40)}${c.reset}`);
+console.log(`  ${c.bold}Summary${c.reset}`);
+console.log(`  ${c.cyan}${symbols.boxH.repeat(40)}${c.reset}`);
 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}`);
+  console.log(`  ${c.brightRed}Some checks failed. Please review the errors above.${c.reset}`);
   process.exit(1);
 } else if (warnCount > 0) {
-  console.log(`${colors.yellow}Installation OK with some warnings.${colors.reset}`);
+  console.log(`  ${c.yellow}Installation OK with some warnings.${c.reset}`);
   process.exit(0);
 } else {
-  console.log(`${colors.green}All checks passed! Claude Code is ready to use.${colors.reset}`);
+  console.log(`  ${c.green}All checks passed! Claude Code is ready to use.${c.reset}`);
   process.exit(0);
 }

package/src/auto-update.js

@@ -4,10 +4,9 @@ const { execSync, spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const https = require('https');
+const { logArrow, logStep } = require('./ui');
 
 const PACKAGE_NAME = 'claude-code-termux';
-const CACHE_FILE = path.join(process.env.HOME || '', '.claude', '.auto-update-cache');
-const CACHE_DURATION_MS = 24 * 60 * 60 * 1000; // 24 hours
 const FETCH_TIMEOUT_MS = 10000; // 10 seconds
 
 /**
@@ -68,41 +67,6 @@ function fetchLatestVersion() {
   });
 }
 
-/**
- * Check if we should skip the update check based on cache
- */
-function shouldSkipCheck() {
-  try {
-    if (!fs.existsSync(CACHE_FILE)) {
-      return false;
-    }
-    const cacheContent = fs.readFileSync(CACHE_FILE, 'utf8');
-    const cache = JSON.parse(cacheContent);
-    const lastCheck = new Date(cache.lastCheck).getTime();
-    const now = Date.now();
-    return (now - lastCheck) < CACHE_DURATION_MS;
-  } catch (err) {
-    return false;
-  }
-}
-
-/**
- * Update the cache file with current timestamp
- */
-function updateCache() {
-  try {
-    const cacheDir = path.dirname(CACHE_FILE);
-    if (!fs.existsSync(cacheDir)) {
-      fs.mkdirSync(cacheDir, { recursive: true });
-    }
-    fs.writeFileSync(CACHE_FILE, JSON.stringify({
-      lastCheck: new Date().toISOString()
-    }));
-  } catch (err) {
-    // Silently ignore cache write errors
-  }
-}
-
 /**
  * Compare semantic versions
  * Returns true if latestVersion > installedVersion
@@ -123,7 +87,7 @@ function isNewerVersion(installedVersion, latestVersion) {
  */
 function runUpdate(latestVersion) {
   return new Promise((resolve, reject) => {
-    console.log(`[claude-code-termux] Updating to ${latestVersion}...`);
+    logArrow(`Updating to v${latestVersion}...`);
 
     try {
       // Use npm install with --force to bypass platform checks for sharp-wasm32
@@ -142,7 +106,7 @@ function runUpdate(latestVersion) {
  * Re-execute the current process with the same arguments
  */
 function relaunchProcess() {
-  console.log('[claude-code-termux] Update complete, restarting...\n');
+  logStep('Update complete, restarting...');
 
   // Filter out any auto-update related args to prevent infinite loops
   const args = process.argv.slice(2).filter(arg => arg !== '--no-auto-update');
@@ -168,11 +132,6 @@ async function checkAndUpdate() {
     return false;
   }
 
-  // Check cache
-  if (shouldSkipCheck()) {
-    return false;
-  }
-
   try {
     // Get installed version
     const installedVersion = getInstalledVersion();
@@ -183,9 +142,6 @@ async function checkAndUpdate() {
     // Fetch latest version from npm
     const latestVersion = await fetchLatestVersion();
 
-    // Update cache regardless of whether update is needed
-    updateCache();
-
     // Check if update is needed
     if (!isNewerVersion(installedVersion, latestVersion)) {
       return false;

package/src/patches/apply-all.js

@@ -1,17 +1,21 @@
 /**
- * Apply All Termux Patches
+ * Apply All Termux Boosts
  *
- * This module applies all necessary runtime patches for Termux/Android compatibility.
+ * This module applies all necessary runtime boosts for Termux/Android compatibility.
  * It must be loaded before the main Claude Code CLI.
+ *
+ * Shows an animated progress bar during loading. Only surfaces failures.
  */
 
 'use strict';
 
 const path = require('path');
+const { boostName, renderProgressBar, finishProgressBar, sleep, logWarn } = require('../ui');
 
-// Patch modules to load
-const patches = [
+// Boost modules to load
+const boosts = [
   './suppress-migration-ui',  // Must be first - sets env vars before CLI loads
+  './tmpdir-config',          // Must be early - /tmp is inaccessible on Termux
   './sharp-fallback',
   './ripgrep-fallback',
   './path-normalization',
@@ -19,28 +23,45 @@ const patches = [
   './hook-events',
 ];
 
-console.log('[claude-code-termux] Applying runtime patches...');
-
+const total = boosts.length;
 let appliedCount = 0;
 let failedCount = 0;
+const failures = [];
 
-for (const patchPath of patches) {
+// Show initial empty progress bar
+renderProgressBar(0, total);
+sleep(60);
+
+for (let i = 0; i < boosts.length; i++) {
+  const boostPath = boosts[i];
   try {
-    const patch = require(patchPath);
-    if (typeof patch.apply === 'function') {
-      patch.apply();
+    const boost = require(boostPath);
+    if (typeof boost.apply === 'function') {
+      boost.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);
-    }
+    failures.push({
+      name: boostName(boostPath),
+      error: err.message,
+    });
   }
+
+  // Update progress bar
+  renderProgressBar(i + 1, total);
+  sleep(60);
 }
 
-console.log(`[claude-code-termux] Patches applied: ${appliedCount}, skipped: ${failedCount}`);
+// Move past the progress bar line
+finishProgressBar();
+
+// Surface failures only
+for (const f of failures) {
+  logWarn(`${f.name} failed`);
+  if (process.env.DEBUG) {
+    logWarn(`  ${f.error}`);
+  }
+}
 
-module.exports = { appliedCount, failedCount };
+module.exports = { appliedCount, failedCount, failures };

package/src/patches/ripgrep-fallback.js

@@ -55,10 +55,12 @@ function apply() {
   // Find system ripgrep
   systemRipgrepPath = findSystemRipgrep();
 
-  if (systemRipgrepPath) {
-    console.log(`[claude-code-termux] Found system ripgrep: ${systemRipgrepPath}`);
-  } else {
-    console.warn('[claude-code-termux] System ripgrep not found. Install with: pkg install ripgrep');
+  if (process.env.DEBUG) {
+    if (systemRipgrepPath) {
+      console.log(`[claude-code-termux] Found system ripgrep: ${systemRipgrepPath}`);
+    } else {
+      console.warn('[claude-code-termux] System ripgrep not found. Install with: pkg install ripgrep');
+    }
   }
 
   // Monkey-patch spawn to intercept ripgrep calls
@@ -70,7 +72,7 @@ function apply() {
     if (typeof command === 'string' && command.includes('ripgrep') && command.includes('arm64-android')) {
       // Replace with system ripgrep if available
       if (systemRipgrepPath) {
-        console.log('[claude-code-termux] Redirecting ripgrep call to system binary');
+        if (process.env.DEBUG) console.log('[claude-code-termux] Redirecting ripgrep call to system binary');
         return originalSpawn(systemRipgrepPath, args, options);
       }
     }
@@ -78,7 +80,7 @@ function apply() {
     // Also intercept direct 'rg' calls with invalid paths
     if (typeof command === 'string' && command.endsWith('/rg') && !fs.existsSync(command)) {
       if (systemRipgrepPath) {
-        console.log('[claude-code-termux] Redirecting invalid rg path to system binary');
+        if (process.env.DEBUG) console.log('[claude-code-termux] Redirecting invalid rg path to system binary');
         return originalSpawn(systemRipgrepPath, args, options);
       }
     }

package/src/patches/tmpdir-config.js

@@ -0,0 +1,47 @@
+/**
+ * TMPDIR Configuration Patch
+ *
+ * Termux doesn't expose /tmp (permission denied). Claude Code's sandbox
+ * and MCP servers create temp directories under /tmp, which fails on Termux.
+ * This patch sets TMPDIR to the Termux-accessible temp directory so that
+ * os.tmpdir() and all child processes use the correct path.
+ */
+
+'use strict';
+
+const fs = require('fs');
+
+const isTermux = process.platform === 'android' ||
+                 process.env.PREFIX?.includes('com.termux') ||
+                 process.env.HOME?.includes('com.termux');
+
+const TERMUX_TMP = '/data/data/com.termux/files/usr/tmp';
+
+function apply() {
+  if (!isTermux) {
+    return;
+  }
+
+  // Don't override if the user has already set TMPDIR
+  if (process.env.TMPDIR) {
+    if (process.env.DEBUG) {
+      console.log('[claude-code-termux] TMPDIR already set:', process.env.TMPDIR);
+    }
+    return;
+  }
+
+  // Ensure the directory exists
+  if (!fs.existsSync(TERMUX_TMP)) {
+    fs.mkdirSync(TERMUX_TMP, { recursive: true });
+  }
+
+  process.env.TMPDIR = TERMUX_TMP;
+  process.env.TMP = TERMUX_TMP;
+  process.env.TEMP = TERMUX_TMP;
+
+  if (process.env.DEBUG) {
+    console.log('[claude-code-termux] TMPDIR set to:', TERMUX_TMP);
+  }
+}
+
+module.exports = { apply };

package/src/ui.js

@@ -0,0 +1,201 @@
+/**
+ * Claude Code Termux - UI Output Utilities
+ *
+ * Shared module for all user-facing terminal output.
+ * Provides colors, symbols, banner, progress bar, and logging helpers.
+ */
+
+'use strict';
+
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Color support detection
+// ---------------------------------------------------------------------------
+
+function supportsColor() {
+  if (process.env.NO_COLOR !== undefined) return false;
+  if (process.env.FORCE_COLOR !== undefined) return true;
+  if (!process.stderr.isTTY) return false;
+  const term = process.env.TERM || '';
+  if (term === 'dumb') return false;
+  return true;
+}
+
+const useColor = supportsColor();
+
+function esc(code) {
+  return useColor ? `\x1b[${code}m` : '';
+}
+
+// ---------------------------------------------------------------------------
+// Color palette
+// ---------------------------------------------------------------------------
+
+const c = {
+  reset:      esc('0'),
+  bold:       esc('1'),
+  dim:        esc('2'),
+  red:        esc('31'),
+  green:      esc('32'),
+  yellow:     esc('33'),
+  blue:       esc('34'),
+  magenta:    esc('35'),
+  cyan:       esc('36'),
+  white:      esc('37'),
+  brightRed:  esc('91'),
+  brightCyan: esc('96'),
+};
+
+// ---------------------------------------------------------------------------
+// Symbols
+// ---------------------------------------------------------------------------
+
+const symbols = {
+  check:  '\u2714',   // ✔
+  cross:  '\u2716',   // ✖
+  arrow:  '\u2192',   // →
+  bolt:   '\u26A1',   // ⚡
+  rocket: '\uD83D\uDE80', // 🚀
+  warn:   '!',
+  boxTL:  '\u256D',   // ╭
+  boxTR:  '\u256E',   // ╮
+  boxBL:  '\u2570',   // ╰
+  boxBR:  '\u256F',   // ╯
+  boxH:   '\u2500',   // ─
+  boxV:   '\u2502',   // │
+  blockFull:  '\u2588', // █
+  blockEmpty: '\u2591', // ░
+};
+
+// ---------------------------------------------------------------------------
+// Termux detection (shared helper)
+// ---------------------------------------------------------------------------
+
+const isTermux = process.platform === 'android' ||
+                 (process.env.PREFIX || '').includes('com.termux') ||
+                 (process.env.HOME || '').includes('com.termux');
+
+// ---------------------------------------------------------------------------
+// Banner
+// ---------------------------------------------------------------------------
+
+function printBanner(version) {
+  const tag = isTermux ? 'Termux Edition' : 'Desktop';
+  const inner = `  Claude Code  ${c.dim}\u00B7${c.reset}${c.brightCyan}  ${tag}  ${c.dim}v${version}${c.reset}`;
+  const rawInner = `  Claude Code  \u00B7  ${tag}  v${version}`;
+  const width = rawInner.length + 2;
+
+  const top = `  ${c.cyan}${symbols.boxTL}${symbols.boxH.repeat(width)}${symbols.boxTR}${c.reset}`;
+  const mid = `  ${c.cyan}${symbols.boxV}${c.reset}${inner}  ${c.cyan}${symbols.boxV}${c.reset}`;
+  const bot = `  ${c.cyan}${symbols.boxBL}${symbols.boxH.repeat(width)}${symbols.boxBR}${c.reset}`;
+
+  console.log('');
+  console.log(top);
+  console.log(mid);
+  console.log(bot);
+}
+
+// ---------------------------------------------------------------------------
+// Boost (patch) name map
+// ---------------------------------------------------------------------------
+
+const BOOST_NAMES = {
+  'suppress-migration-ui': 'Suppress migration prompts',
+  'tmpdir-config':         'Temp directory (Termux)',
+  'sharp-fallback':        'Image support (Sharp WASM)',
+  'ripgrep-fallback':      'Code search (ripgrep)',
+  'path-normalization':    'Termux path resolution',
+  'oauth-storage':         'Token storage fallback',
+  'hook-events':           'Event hook compatibility',
+};
+
+function boostName(patchPath) {
+  const base = path.basename(patchPath);
+  return BOOST_NAMES[base] || base;
+}
+
+// ---------------------------------------------------------------------------
+// Progress bar
+// ---------------------------------------------------------------------------
+
+const BAR_WIDTH = 10;
+
+function renderProgressBar(current, total) {
+  const filled = Math.round((current / total) * BAR_WIDTH);
+  const empty = BAR_WIDTH - filled;
+  const bar = symbols.blockFull.repeat(filled) + symbols.blockEmpty.repeat(empty);
+  const line = `  ${c.cyan}${symbols.bolt}${c.reset} Powering up... ${c.cyan}[${bar}]${c.reset} ${current}/${total} boosts`;
+  process.stdout.write(`\r${line}`);
+}
+
+function finishProgressBar() {
+  process.stdout.write('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Synchronous sleep (for animation timing)
+// ---------------------------------------------------------------------------
+
+function sleep(ms) {
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    // busy-wait — keeps total under 500ms for 6 boosts
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Logging helpers
+// ---------------------------------------------------------------------------
+
+function logStep(message) {
+  console.log(`  ${c.green}${symbols.check}${c.reset} ${message}`);
+}
+
+function logArrow(message) {
+  console.log(`  ${c.cyan}${symbols.arrow}${c.reset} ${message}`);
+}
+
+function logWarn(message) {
+  console.log(`  ${c.yellow}${symbols.warn}${c.reset} ${message}`);
+}
+
+function logError(message) {
+  console.error(`  ${c.brightRed}${symbols.cross}${c.reset} ${message}`);
+}
+
+function logDim(message) {
+  console.log(`  ${c.dim}${message}${c.reset}`);
+}
+
+function logReady(hasWarnings) {
+  if (hasWarnings) {
+    console.log(`  ${symbols.rocket} ${c.yellow}Ready with warnings${c.reset}`);
+  } else {
+    console.log(`  ${symbols.rocket} ${c.green}Ready to go!${c.reset}`);
+  }
+  console.log('');
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  c,
+  symbols,
+  useColor,
+  isTermux,
+  printBanner,
+  BOOST_NAMES,
+  boostName,
+  renderProgressBar,
+  finishProgressBar,
+  sleep,
+  logStep,
+  logArrow,
+  logWarn,
+  logError,
+  logDim,
+  logReady,
+};