openclaw-droid 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mithun Gowda B
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# ClawDroid 🤖
+
+> **Run OpenClaw AI Gateway on Android via Termux**
+> One-command setup. Optimized for mobile. Bionic Bypass included.
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Platform](https://img.shields.io/badge/platform-Android%20%7C%20Termux-green.svg)
+![Version](https://img.shields.io/badge/version-1.0.0-orange.svg)
+
+**ClawDroid** makes running [OpenClaw](https://github.com/openclaw/openclaw) on Android effortless. It handles the environment setup (proot-distro, Ubuntu, Node.js) and fixes Android-specific issues automatically.
+
+## 🚀 Why ClawDroid?
+
+Running standard Node.js AI tools on Android is painful because of:
+*   **Bionic libc**: Android's C library differs from Linux (glibc), breaking `os.networkInterfaces()` and DNS lookups.
+*   **Permissions**: Termux has restricted access to system resources.
+*   **Environment**: Many tools expect a full Linux userland (Ubuntu/Debian).
+
+**ClawDroid solves this by:**
+1.  Creating a lightweight **Ubuntu** container inside Termux.
+2.  Injecting a **Bionic Bypass** script to fix networking.
+3.  Providing a simple CLI (`clawdroid`) to manage the gateway.
+
+## 📦 Installation
+
+### Prerequisites
+*   **Android 10+**
+*   **Termux** (Install from [F-Droid](https://f-droid.org/packages/com.termux/), NOT Play Store)
+*   ~2GB free storage
+
+### One-Command Setup
+Open Termux and run:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/NOSYTLABS/clawdroid/main/install.sh | bash
+```
+
+Or via npm:
+
+```bash
+npm install -g clawdroid
+clawdroid setup
+```
+
+## 🎮 Usage
+
+### 1. Initialize
+First, configure your API keys:
+
+```bash
+clawdroid onboarding
+```
+> **IMPORTANT:** Select **Loopback (127.0.0.1)** for Binding.
+
+### 2. Start Gateway
+Launch the OpenClaw gateway:
+
+```bash
+clawdroid start
+```
+The dashboard will be available at: **http://127.0.0.1:18789**
+
+### 3. Other Commands
+
+| Command | Description |
+| :--- | :--- |
+| `clawdroid status` | Check installation health |
+| `clawdroid update` | Update OpenClaw to the latest version |
+| `clawdroid shell` | Open the Ubuntu shell |
+| `clawdroid repair` | Re-install dependencies if broken |
+| `clawdroid <cmd>` | Run any OpenClaw command (e.g., `clawdroid doctor`) |
+
+## 🧩 Architecture
+
+```mermaid
+graph TD
+    A[User] -->|clawdroid start| B(Termux)
+    B -->|proot-distro| C{Ubuntu Container}
+    C -->|Bionic Bypass| D[OpenClaw Gateway]
+    D -->|HTTP| E[Web Dashboard]
+    D -->|API| F[LLM Providers]
+```
+
+## ⚠️ Troubleshooting
+
+**"Setup not complete" error**
+*   Run `clawdroid setup` again.
+*   If it persists, run `clawdroid repair`.
+
+**Process killed in background**
+*   Go to Android Settings → Apps → Termux → Battery → **Unrestricted**.
+
+## 📜 License
+
+MIT License.

package/bin/openclaw

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { main } from '../lib/index.js';
+
+main(process.argv.slice(2)).catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/install.sh

@@ -0,0 +1,67 @@
+#!/bin/bash
+#
+# OpenClaw Droid Installer
+# One-liner: curl -fsSL https://raw.githubusercontent.com/NosytLabs/openclaw-droid/main/install.sh | bash
+#
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+echo -e "${BLUE}"
+echo "-------------------------------------------"
+echo "      OpenClaw Droid Installer v1.0.0"
+echo "-------------------------------------------"
+echo -e "${NC}"
+
+# Check if running in Termux
+if [ ! -d "/data/data/com.termux" ] && [ -z "$TERMUX_VERSION" ]; then
+    echo -e "${YELLOW}Warning:${NC} Not running in Termux - some features may not work"
+fi
+
+# Update and install packages
+echo -e "\n${BLUE}[1/3]${NC} Installing required packages..."
+
+# Update Termux repositories
+echo -e "  ${BLUE}•${NC} Updating Termux repositories..."
+pkg update -y || true
+pkg upgrade -y || true
+
+echo -e "  ${BLUE}•${NC} Installing dependencies..."
+pkg install -y nodejs-lts git proot-distro android-tools termux-api
+
+echo -e "  ${GREEN}✓${NC} Node.js $(node --version)"
+echo -e "  ${GREEN}✓${NC} npm $(npm --version)"
+echo -e "  ${GREEN}✓${NC} git installed"
+echo -e "  ${GREEN}✓${NC} proot-distro installed"
+echo -e "  ${GREEN}✓${NC} adb $(adb version | head -n 1)"
+echo -e "  ${GREEN}✓${NC} termux-api installed"
+
+# Install openclaw-droid from npm
+echo -e "\n${BLUE}[2/3]${NC} Installing OpenClaw Droid..."
+npm install -g openclaw-droid
+
+echo -e "\n${BLUE}[3/3]${NC} Verifying Android tools..."
+adb start-server >/dev/null 2>&1 || true
+adb devices || true
+
+echo -e "\n${GREEN}═══════════════════════════════════════════${NC}"
+echo -e "${GREEN}Installation complete!${NC}"
+echo -e "${GREEN}═══════════════════════════════════════════${NC}"
+echo ""
+echo -e "${YELLOW}Next steps:${NC}"
+echo "  1. Run setup:      openclaw setup"
+echo "  2. Run onboarding: openclaw onboarding"
+echo "     → Select 'Loopback (127.0.0.1)' when asked!"
+echo "  3. Start gateway:  openclaw start"
+echo ""
+echo -e "Dashboard: ${BLUE}http://127.0.0.1:18789${NC}"
+echo ""
+echo -e "${YELLOW}Tip:${NC} Disable battery optimization for Termux in Android settings"
+echo -e "${YELLOW}Tip:${NC} Install Termux:API app from F-Droid for camera, wakelock, and sensors"
+echo ""

package/lib/bionic-bypass.js

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+
+const BYPASS_SCRIPT = `
+const os = require('os');
+const originalNetworkInterfaces = os.networkInterfaces;
+
+os.networkInterfaces = function() {
+  try {
+    const interfaces = originalNetworkInterfaces.call(os);
+    if (interfaces && Object.keys(interfaces).length > 0) {
+      return interfaces;
+    }
+  } catch (e) {}
+
+  return {
+    lo: [
+      {
+        address: '127.0.0.1',
+        netmask: '255.0.0.0',
+        family: 'IPv4',
+        mac: '00:00:00:00:00:00',
+        internal: true,
+        cidr: '127.0.0.1/8'
+      }
+    ]
+  };
+};
+`;
+
+export function getBypassScriptPath() {
+  const homeDir = process.env.HOME || '/data/data/com.termux/files/home';
+  return path.join(homeDir, '.clawdroid', 'bionic-bypass.js');
+}
+
+export function installBypass() {
+  const scriptPath = getBypassScriptPath();
+  const scriptDir = path.dirname(scriptPath);
+
+  if (!fs.existsSync(scriptDir)) {
+    fs.mkdirSync(scriptDir, { recursive: true });
+  }
+
+  fs.writeFileSync(scriptPath, BYPASS_SCRIPT, 'utf8');
+  fs.chmodSync(scriptPath, '644');
+
+  return scriptPath;
+}
+
+export function getNodeOptions() {
+  const scriptPath = getBypassScriptPath();
+  return `--require "${scriptPath}"`;
+}
+
+export function isAndroid() {
+  return process.platform === 'android' ||
+         fs.existsSync('/data/data/com.termux') ||
+         process.env.TERMUX_VERSION !== undefined;
+}
+
+export function checkBypassInstalled() {
+  const scriptPath = getBypassScriptPath();
+  return fs.existsSync(scriptPath);
+}

package/lib/index.js

@@ -0,0 +1,304 @@
+import {
+  configureTermux,
+  getInstallStatus,
+  installProot,
+  installUbuntu,
+  setupProotUbuntu,
+  setupBionicBypassInProot,
+  runInProot,
+  runInProotWithCallback
+} from './installer.js';
+import { isAndroid } from './bionic-bypass.js';
+import { spawn } from 'child_process';
+
+const VERSION = '1.0.0';
+
+function printBanner() {
+  console.log(`
+  
+     OPENCLAW-DROID v${VERSION}
+  
+`);
+}
+
+function printHelp() {
+  console.log(`
+Usage: openclaw [command] [args...]
+
+If run without arguments, it starts the OpenClaw gateway.
+
+Commands:
+  start       Start OpenClaw gateway (Default)
+  setup       Full installation (proot + Ubuntu + OpenClaw)
+  update      Update OpenClaw to the latest version
+  repair      Re-install OpenClaw and dependencies
+  status      Check installation status
+  shell       Open Ubuntu shell with OpenClaw ready
+  help        Show this help message
+  openclaw onboarding     
+  openclaw gateway -v      
+  openclaw doctor          
+
+Examples:
+  openclaw                   # Start gateway
+  openclaw setup             # First-time setup
+  openclaw update            # Update OpenClaw
+  openclaw repair            # Fix installation
+  openclaw shell             # Enter Ubuntu shell
+`);
+}
+
+async function runSetup() {
+  console.log('Starting OpenClaw Droid setup for Termux...\n');
+
+  if (!isAndroid()) {
+    console.log('Warning: This package is designed for Android/Termux.');
+    console.log('Some features may not work on other platforms.\n');
+  }
+
+  let status = getInstallStatus();
+
+  console.log('[1/5] Checking proot-distro...');
+  if (!status.proot) {
+    installProot();
+  } else {
+    console.log('  ✓ proot-distro installed');
+  }
+  console.log('');
+
+  console.log('[2/5] Checking Ubuntu in proot...');
+  status = getInstallStatus();
+  if (!status.ubuntu) {
+    installUbuntu();
+  } else {
+    console.log('  ✓ Ubuntu installed');
+  }
+  console.log('');
+
+  console.log('[3/5] Setting up Node.js and OpenClaw in Ubuntu...');
+  status = getInstallStatus();
+  if (!status.openClawInProot) {
+    setupProotUbuntu();
+  } else {
+    console.log('  ✓ OpenClaw already installed in proot');
+  }
+  console.log('');
+
+  console.log('[4/5] Setting up Bionic Bypass in proot...');
+  setupBionicBypassInProot();
+  console.log('');
+
+  console.log('[5/5] Configuring Termux...');
+  configureTermux();
+  console.log('');
+
+  console.log('═══════════════════════════════════════════');
+  console.log('Setup complete!');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. Run onboarding: openclaw onboarding');
+  console.log('     → Select "Loopback (127.0.0.1)" when asked!');
+  console.log('  2. Start gateway:  openclaw start');
+  console.log('');
+  console.log('Dashboard: http://127.0.0.1:18789');
+  console.log('═══════════════════════════════════════════');
+}
+
+function showStatus() {
+  process.stdout.write('Checking installation status...');
+  const status = getInstallStatus();
+  process.stdout.write('\r' + ' '.repeat(35) + '\r');
+
+  console.log('Installation Status:\n');
+  console.log('Termux:');
+  console.log(`  proot-distro:     ${status.proot ? '✓ installed' : '✗ missing'}`);
+  console.log(`  Ubuntu (proot):   ${status.ubuntu ? '✓ installed' : '✗ not installed'}`);
+  console.log('');
+
+  if (status.ubuntu) {
+    console.log('Inside Ubuntu:');
+    console.log(`  OpenClaw:         ${status.openClawInProot ? '✓ installed' : '✗ not installed'}`);
+    console.log(`  Bionic Bypass:    ${status.bionicBypassInProot ? '✓ configured' : '✗ not configured'}`);
+    console.log('');
+  }
+
+  if (status.proot && status.ubuntu && status.openClawInProot) {
+    console.log('Status: ✓ Ready to run!');
+    console.log('');
+  } else {
+    console.log('Status: ✗ Setup incomplete');
+    console.log('Run: clawdroid setup');
+  }
+}
+
+function updateOpenClaw() {
+  const status = getInstallStatus();
+
+  if (!status.proot || !status.ubuntu) {
+    console.error('proot/Ubuntu not installed. Run: openclaw setup');
+    process.exit(1);
+  }
+
+  console.log('Updating OpenClaw to the latest version...');
+  
+  const proc = runInProotWithCallback('npm install -g openclaw@latest', () => {
+    console.log('npm output:');
+  });
+
+  proc.on('close', (code) => {
+    if (code === 0) {
+      console.log('\n✓ OpenClaw updated successfully!');
+    console.log('Run "openclaw start" to launch the gateway.');
+    } else {
+      console.error(`\n✗ Update failed with code ${code}`);
+    }
+  });
+}
+
+function startGateway() {
+  const status = getInstallStatus();
+
+  if (!status.proot || !status.ubuntu) {
+    console.error('proot/Ubuntu not installed. Run: clawdroid setup');
+    process.exit(1);
+  }
+
+  if (!status.openClawInProot) {
+    console.error('OpenClaw not installed in proot. Run: clawdroid setup');
+    process.exit(1);
+  }
+
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  let started = false;
+  const DASHBOARD_URL = 'http://127.0.0.1:18789';
+
+  const spinner = setInterval(() => {
+    if (!started) {
+      process.stdout.write(`\r${frames[i++ % frames.length]} Starting OpenClaw gateway...`);
+    }
+  }, 80);
+
+  const checkDashboard = setInterval(async () => {
+    if (started) return;
+    try {
+      const response = await fetch(DASHBOARD_URL, { method: 'HEAD', signal: AbortSignal.timeout(1000) });
+      if (response.ok || response.status < 500) {
+        started = true;
+        clearInterval(spinner);
+        clearInterval(checkDashboard);
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+        console.log('✓ OpenClaw gateway started!\n');
+        console.log(`Dashboard: ${DASHBOARD_URL}`);
+        console.log('Press Ctrl+C to stop\n');
+        console.log('─'.repeat(45) + '\n');
+      }
+    } catch {}
+  }, 500);
+
+  const gateway = runInProot('openclaw gateway --verbose');
+
+  gateway.on('error', (err) => {
+    clearInterval(spinner);
+    clearInterval(checkDashboard);
+    console.error('\nFailed to start gateway:', err.message);
+  });
+
+  gateway.on('close', (code) => {
+    clearInterval(spinner);
+    clearInterval(checkDashboard);
+    if (!started) {
+      console.log('\nGateway exited before starting. Run: clawdroid onboarding');
+    }
+  });
+}
+
+function runOpenclawCommand(args) {
+  const status = getInstallStatus();
+
+  if (!status.proot || !status.ubuntu || !status.openClawInProot) {
+    console.error('Setup not complete. Run: clawdroid setup');
+    process.exit(1);
+  }
+
+  const command = args.join(' ');
+  console.log(`Running: openclaw ${command}\n`);
+
+  if (args[0] === 'onboarding') {
+    console.log('TIP: Select "Loopback (127.0.0.1)" when asked for binding!\n');
+  }
+
+  const proc = runInProot(`openclaw ${command}`);
+
+  proc.on('error', (err) => {
+    console.error('Failed to run command:', err.message);
+  });
+}
+
+function openShell() {
+  const status = getInstallStatus();
+
+  if (!status.proot || !status.ubuntu) {
+    console.error('proot/Ubuntu not installed. Run: clawdroid setup');
+    process.exit(1);
+  }
+
+  console.log('Entering Ubuntu shell...');
+  console.log('Type "exit" to return to Termux\n');
+
+  const shell = spawn('proot-distro', ['login', 'ubuntu'], {
+    stdio: 'inherit'
+  });
+
+  shell.on('error', (err) => {
+    console.error('Failed to open shell:', err.message);
+  });
+}
+
+export async function main(args) {
+  const command = args[0] || 'start';
+
+  printBanner();
+
+  switch (command) {
+    case 'setup':
+    case 'install':
+      await runSetup();
+      break;
+
+    case 'status':
+      showStatus();
+      break;
+
+    case 'update':
+      updateOpenClaw();
+      break;
+
+    case 'repair':
+      console.log('Repairing installation...');
+      await setupProotUbuntu();
+      setupBionicBypassInProot();
+      console.log('Repair complete!');
+      break;
+
+    case 'start':
+    case 'run':
+      startGateway();
+      break;
+
+    case 'shell':
+    case 'ubuntu':
+      openShell();
+      break;
+
+    case 'help':
+    case '--help':
+    case '-h':
+      printHelp();
+      break;
+
+    default:
+      runOpenclawCommand(args);
+      break;
+  }
+}

package/lib/installer.js

@@ -0,0 +1,282 @@
+import { execSync, spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { installBypass, getBypassScriptPath, getNodeOptions } from './bionic-bypass.js';
+
+const HOME = process.env.HOME || '/data/data/com.termux/files/home';
+const BASHRC = path.join(HOME, '.bashrc');
+const ZSHRC = path.join(HOME, '.zshrc');
+const PROOT_ROOTFS = '/data/data/com.termux/files/usr/var/lib/proot-distro/installed-rootfs';
+const PROOT_UBUNTU_ROOT = path.join(PROOT_ROOTFS, 'ubuntu', 'root');
+
+export function checkDependencies() {
+  const deps = {
+    node: false,
+    npm: false,
+    git: false,
+    proot: false
+  };
+
+  try {
+    execSync('node --version', { stdio: 'pipe' });
+    deps.node = true;
+  } catch {}
+
+  try {
+    execSync('npm --version', { stdio: 'pipe' });
+    deps.npm = true;
+  } catch {}
+
+  try {
+    execSync('git --version', { stdio: 'pipe' });
+    deps.git = true;
+  } catch {}
+
+  try {
+    execSync('which proot-distro', { stdio: 'pipe' });
+    deps.proot = true;
+  } catch {}
+
+  return deps;
+}
+
+export function installTermuxDeps() {
+  console.log('Installing Termux dependencies...');
+  const packages = ['nodejs-lts', 'git', 'openssh'];
+  try {
+    execSync('pkg update -y', { stdio: 'inherit' });
+    execSync(`pkg install -y ${packages.join(' ')}`, { stdio: 'inherit' });
+    return true;
+  } catch (err) {
+    console.error('Failed to install Termux packages:', err.message);
+    return false;
+  }
+}
+
+export function setupBionicBypass() {
+  console.log('Setting up Bionic Bypass...');
+  const scriptPath = installBypass();
+  const nodeOptions = getNodeOptions();
+  const exportLine = `export NODE_OPTIONS="${nodeOptions}"`;
+
+  for (const rcFile of [BASHRC, ZSHRC]) {
+    if (fs.existsSync(rcFile)) {
+      const content = fs.readFileSync(rcFile, 'utf8');
+      if (!content.includes('bionic-bypass')) {
+        fs.appendFileSync(rcFile, `\n# ClawDroid Bionic Bypass\n${exportLine}\n`);
+      }
+    }
+  }
+
+  process.env.NODE_OPTIONS = nodeOptions;
+  return scriptPath;
+}
+
+export function installOpenClaw() {
+  console.log('Installing OpenClaw...');
+  try {
+    execSync('npm install -g openclaw', { stdio: 'inherit' });
+    return true;
+  } catch (err) {
+    console.error('Failed to install OpenClaw:', err.message);
+    return false;
+  }
+}
+
+export function configureTermux() {
+  console.log('Configuring Termux for background operation...');
+  const configDir = path.join(HOME, '.clawdroid');
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  const wakeLockScript = path.join(configDir, 'wakelock.sh');
+  const wakeLockContent = `#!/bin/bash
+termux-wake-lock
+trap "termux-wake-unlock" EXIT
+exec "$@"
+`;
+
+  fs.writeFileSync(wakeLockScript, wakeLockContent, 'utf8');
+  fs.chmodSync(wakeLockScript, '755');
+  
+  return true;
+}
+
+export function getInstallStatus() {
+  const PROOT_ROOTFS = '/data/data/com.termux/files/usr/var/lib/proot-distro/installed-rootfs';
+
+  let hasProot = false;
+  try {
+    execSync('command -v proot-distro', { stdio: 'pipe' });
+    hasProot = true;
+  } catch {}
+
+  let hasUbuntu = false;
+  try {
+    hasUbuntu = fs.existsSync(path.join(PROOT_ROOTFS, 'ubuntu'));
+  } catch {}
+
+  let hasOpenClawInProot = false;
+  if (hasUbuntu) {
+    try {
+      const checkCmd = 'test -f /usr/local/bin/openclaw || test -f /usr/bin/openclaw || command -v openclaw';
+      execSync(`proot-distro login ubuntu -- bash -c "${checkCmd}"`, { stdio: 'pipe', timeout: 15000 });
+      hasOpenClawInProot = true;
+    } catch {}
+  }
+
+  let hasBionicBypassInProot = false;
+  try {
+    const prootBypassPath = path.join(PROOT_ROOTFS, 'ubuntu', 'root', '.clawdroid', 'bionic-bypass.js');
+    hasBionicBypassInProot = fs.existsSync(prootBypassPath);
+  } catch {}
+
+  return {
+    proot: hasProot,
+    ubuntu: hasUbuntu,
+    openClawInProot: hasOpenClawInProot,
+    bionicBypassInProot: hasBionicBypassInProot,
+    bionicBypass: fs.existsSync(getBypassScriptPath()),
+    nodeOptions: process.env.NODE_OPTIONS?.includes('bionic-bypass') || false,
+    openClaw: (() => {
+      try {
+        execSync('command -v openclaw', { stdio: 'pipe' });
+        return true;
+      } catch { return false; }
+    })()
+  };
+}
+
+export function installProot() {
+  console.log('Installing proot-distro...');
+  try {
+    execSync('pkg install -y proot-distro', { stdio: 'inherit' });
+    return true;
+  } catch (err) {
+    console.error('Failed to install proot-distro:', err.message);
+    return false;
+  }
+}
+
+export function installUbuntu() {
+  console.log('Installing Ubuntu in proot...');
+  try {
+    execSync('proot-distro install ubuntu', { stdio: 'inherit' });
+    return true;
+  } catch (err) {
+    console.error('Failed to install Ubuntu:', err.message);
+    return false;
+  }
+}
+
+export function setupProotUbuntu() {
+  console.log('Setting up Node.js and OpenClaw in Ubuntu...');
+  const setupScript = `
+    set -e
+    apt update
+    apt install -y curl wget git build-essential python3
+    curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+    apt install -y nodejs
+    npm install -g openclaw
+  `;
+
+  try {
+    execSync(`proot-distro login ubuntu -- bash -c '${setupScript}'`, { stdio: 'inherit' });
+    return true;
+  } catch (err) {
+    console.error('Failed to setup Ubuntu:', err.message);
+    return false;
+  }
+}
+
+export function setupBionicBypassInProot() {
+  console.log('Setting up Bionic Bypass in proot Ubuntu...');
+
+  const bypassScript = `
+const os = require('os');
+const originalNetworkInterfaces = os.networkInterfaces;
+os.networkInterfaces = function() {
+  try {
+    const interfaces = originalNetworkInterfaces.call(os);
+    if (interfaces && Object.keys(interfaces).length > 0) {
+      return interfaces;
+    }
+  } catch (e) {}
+  return {
+    lo: [{
+      address: '127.0.0.1',
+      netmask: '255.0.0.0',
+      family: 'IPv4',
+      mac: '00:00:00:00:00:00',
+      internal: true,
+      cidr: '127.0.0.1/8'
+    }]
+  };
+};
+`;
+
+  const prootBypassPath = path.join(PROOT_UBUNTU_ROOT, '.clawdroid', 'bionic-bypass.js');
+  const prootBypassDir = path.dirname(prootBypassPath);
+
+  try {
+    if (!fs.existsSync(prootBypassDir)) {
+      fs.mkdirSync(prootBypassDir, { recursive: true });
+    }
+    fs.writeFileSync(prootBypassPath, bypassScript, 'utf8');
+
+    const prootBashrc = path.join(PROOT_UBUNTU_ROOT, '.bashrc');
+    const exportLine = 'export NODE_OPTIONS="--require /root/.clawdroid/bionic-bypass.js"';
+
+    let bashrcContent = '';
+    if (fs.existsSync(prootBashrc)) {
+      bashrcContent = fs.readFileSync(prootBashrc, 'utf8');
+    }
+
+    if (!bashrcContent.includes('bionic-bypass')) {
+      fs.appendFileSync(prootBashrc, `\n# ClawDroid Bionic Bypass\n${exportLine}\n`);
+    }
+
+    return true;
+  } catch (err) {
+    console.error('Failed to setup Bionic Bypass in proot:', err.message);
+    return false;
+  }
+}
+
+export function runInProot(command) {
+  const nodeOptions = '--require /root/.clawdroid/bionic-bypass.js';
+  return spawn('proot-distro', ['login', 'ubuntu', '--', 'bash', '-c', `export NODE_OPTIONS="${nodeOptions}" && ${command}`], {
+    stdio: 'inherit'
+  });
+}
+
+export function runInProotWithCallback(command, onFirstOutput) {
+  const nodeOptions = '--require /root/.clawdroid/bionic-bypass.js';
+  let firstOutput = true;
+
+  const proc = spawn('proot-distro', ['login', 'ubuntu', '--', 'bash', '-c', `export NODE_OPTIONS="${nodeOptions}" && ${command}`], {
+    stdio: ['inherit', 'pipe', 'pipe']
+  });
+
+  proc.stdout.on('data', (data) => {
+    if (firstOutput) {
+      firstOutput = false;
+      onFirstOutput();
+    }
+    process.stdout.write(data);
+  });
+
+  proc.stderr.on('data', (data) => {
+    if (firstOutput) {
+      firstOutput = false;
+      onFirstOutput();
+    }
+    const str = data.toString();
+    if (!str.includes('proot warning') && !str.includes("can't sanitize")) {
+      process.stderr.write(data);
+    }
+  });
+
+  return proc;
+}

package/lib/postinstall.js

@@ -0,0 +1,36 @@
+/**
+ * Post-install script - runs after npm install
+ */
+
+import { isAndroid, installBypass, getNodeOptions } from './bionic-bypass.js';
+
+function main() {
+  console.log('\n📱 ClawDroid post-install\n');
+
+  if (!isAndroid()) {
+    console.log('Not running on Android/Termux - skipping Bionic Bypass setup.');
+    console.log('You can still use this package on other systems.\n');
+    return;
+  }
+
+  // Install the bypass script
+  try {
+    const scriptPath = installBypass();
+    console.log(`✓ Bionic Bypass installed at: ${scriptPath}`);
+  } catch (err) {
+    console.error('✗ Failed to install Bionic Bypass:', err.message);
+    return;
+  }
+
+  // Show instructions
+  const nodeOptions = getNodeOptions();
+
+  console.log('\n' + '═'.repeat(50));
+  console.log('IMPORTANT: Add this to your shell config (~/.bashrc):');
+  console.log('═'.repeat(50));
+  console.log(`\nexport NODE_OPTIONS="${nodeOptions}"\n`);
+  console.log('Or run: clawdroid setup');
+  console.log('═'.repeat(50) + '\n');
+}
+
+main();

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "openclaw-droid",
+  "version": "1.0.0",
+  "description": "OpenClaw Droid - Optimized OpenClaw AI Gateway for Android Termux",
+  "main": "lib/index.js",
+  "type": "module",
+  "bin": {
+    "openclaw": "bin/openclaw"
+  },
+  "scripts": {
+    "postinstall": "node lib/postinstall.js"
+  },
+  "keywords": [
+    "openclaw",
+    "termux",
+    "android",
+    "ai",
+    "gateway",
+    "gemini",
+    "claude",
+    "openclaw-termux",
+    "openclaw-droid",
+    "clawdroid",
+    "ai-gateway",
+    "android-ai",
+    "termux-ai",
+    "openclaw-droid"
+  ],
+  "author": "NOSYTLABS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NosytLabs/openclaw-droid.git"
+  },
+  "homepage": "https://github.com/NosytLabs/openclaw-droid#readme",
+  "bugs": {
+    "url": "https://github.com/NosytLabs/openclaw-droid/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "android",
+    "linux",
+    "win32"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.12",
+    "ora": "^7.0.1"
+  }
+}