claude-code-termux 1.0.6 → 1.0.9

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

@@ -0,0 +1,113 @@
+name: Auto-update and 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
+
+permissions:
+  contents: write      # For pushing version bump commits
+  id-token: write      # Required for npm OIDC trusted publishing
+
+jobs:
+  check-and-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'  # Node 24+ required for OIDC (npm >=11.5)
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Check for upstream updates
+        id: check
+        if: ${{ !inputs.force_publish }}
+        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
+          else
+            echo "Already up to date"
+            echo "update_needed=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Update dependency and bump version (auto)
+        if: ${{ !inputs.force_publish && steps.check.outputs.update_needed == '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
+
+      - name: Bump version (manual)
+        if: ${{ inputs.force_publish }}
+        run: |
+          npm version ${{ inputs.version_bump }} --no-git-tag-version
+          NEW_VERSION=$(node -p "require('./package.json').version")
+          echo "New version: $NEW_VERSION"
+
+      - name: Commit and push changes
+        if: ${{ inputs.force_publish || steps.check.outputs.update_needed == '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 }}"
+          fi
+          git push
+
+      - name: Install dependencies
+        if: ${{ inputs.force_publish || steps.check.outputs.update_needed == 'true' }}
+        run: npm install
+
+      - name: Publish to npm (OIDC)
+        if: ${{ inputs.force_publish || steps.check.outputs.update_needed == 'true' }}
+        run: npm publish --access public
+
+      - 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
+          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
+          fi

package/bin/claude-termux.js

@@ -78,9 +78,20 @@ if (!claudeCodePath) {
   process.exit(1);
 }
 
-// Import and run Claude Code
-// Use dynamic import since cli.js is an ES module
-import(claudeCodePath).catch(err => {
+// 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');
+
+checkAndUpdate().then(updated => {
+  if (updated) {
+    // Process will exit and restart with new version
+    return;
+  }
+
+  // Import and run Claude Code
+  // 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);
 
   if (err.message.includes('sharp')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-termux",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "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",
@@ -28,7 +28,7 @@
     "test": "node scripts/verify-install.js"
   },
   "dependencies": {
-    "@anthropic-ai/claude-code": "^2.1.7"
+    "@anthropic-ai/claude-code": "^2.1.27"
   },
   "engines": {
     "node": ">=18.0.0 <25.0.0"

package/src/auto-update.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+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
+
+/**
+ * Check if auto-update is disabled via flag or environment variable
+ */
+function isAutoUpdateDisabled() {
+  if (process.env.CLAUDE_NO_AUTO_UPDATE === '1') {
+    return true;
+  }
+  if (process.argv.includes('--no-auto-update')) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Get the installed version of claude-code-termux
+ */
+function getInstalledVersion() {
+  try {
+    const packageJsonPath = path.join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return packageJson.version;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Fetch the latest version from npm registry
+ */
+function fetchLatestVersion() {
+  return new Promise((resolve, reject) => {
+    const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      timeout: FETCH_TIMEOUT_MS,
+      headers: {
+        'Accept': 'application/json',
+        'User-Agent': 'claude-code-termux-auto-update'
+      }
+    }, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          resolve(json.version);
+        } catch (err) {
+          reject(new Error('Failed to parse npm registry response'));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timed out'));
+    });
+  });
+}
+
+/**
+ * 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
+ */
+function isNewerVersion(installedVersion, latestVersion) {
+  const installed = installedVersion.split('.').map(Number);
+  const latest = latestVersion.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if ((latest[i] || 0) > (installed[i] || 0)) return true;
+    if ((latest[i] || 0) < (installed[i] || 0)) return false;
+  }
+  return false;
+}
+
+/**
+ * Run npm install to install the latest version
+ */
+function runUpdate(latestVersion) {
+  return new Promise((resolve, reject) => {
+    console.log(`[claude-code-termux] Updating to ${latestVersion}...`);
+
+    try {
+      // Use npm install with --force to bypass platform checks for sharp-wasm32
+      execSync(`npm install -g ${PACKAGE_NAME}@${latestVersion} --force`, {
+        stdio: 'inherit',
+        timeout: 120000 // 2 minute timeout for update
+      });
+      resolve(true);
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+/**
+ * Re-execute the current process with the same arguments
+ */
+function relaunchProcess() {
+  console.log('[claude-code-termux] Update complete, restarting...\n');
+
+  // Filter out any auto-update related args to prevent infinite loops
+  const args = process.argv.slice(2).filter(arg => arg !== '--no-auto-update');
+
+  // Spawn a new process
+  const child = spawn(process.argv[0], [process.argv[1], '--no-auto-update', ...args], {
+    stdio: 'inherit',
+    detached: false
+  });
+
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+}
+
+/**
+ * Main auto-update check function
+ * Returns true if an update was performed and process should restart
+ */
+async function checkAndUpdate() {
+  // Check if disabled
+  if (isAutoUpdateDisabled()) {
+    return false;
+  }
+
+  // Check cache
+  if (shouldSkipCheck()) {
+    return false;
+  }
+
+  try {
+    // Get installed version
+    const installedVersion = getInstalledVersion();
+    if (!installedVersion) {
+      return false;
+    }
+
+    // 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;
+    }
+
+    // Perform update
+    await runUpdate(latestVersion);
+
+    // Relaunch with new version
+    relaunchProcess();
+    return true;
+
+  } catch (err) {
+    // Fail silently on any errors - don't block Claude from starting
+    // Uncomment for debugging: console.error('[claude-code-termux] Auto-update check failed:', err.message);
+    return false;
+  }
+}
+
+module.exports = {
+  checkAndUpdate,
+  isAutoUpdateDisabled,
+  getInstalledVersion,
+  fetchLatestVersion,
+  isNewerVersion
+};