clawdroid 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,261 @@
+# ClawDroid
+
+[![npm version](https://img.shields.io/npm/v/clawdroid?color=blue&label=npm)](https://www.npmjs.com/package/clawdroid)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/Node.js-18%2B-green?logo=node.js)](https://nodejs.org/)
+[![Android](https://img.shields.io/badge/Android-10%2B-brightgreen?logo=android)](https://www.android.com/)
+[![Termux](https://img.shields.io/badge/Termux-F--Droid-orange)](https://f-droid.org/packages/com.termux/)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/NOSYTLABS/clawdroid/pulls)
+
+> Run optimized OpenClaw AI Gateway on Android using Termux with automatic proot Ubuntu setup and Bionic Bypass fix.
+
+<p align="center">
+  <img src="https://img.shields.io/badge/Platform-Android%20%7C%20Termux-blue" alt="Platform">
+  <img src="https://img.shields.io/badge/Status-Active-success" alt="Status">
+</p>
+
+---
+
+## Features
+
+- **One-Command Setup** - Automatically installs proot-distro, Ubuntu, Node.js 22, and OpenClaw
+- **Bionic Bypass** - Fixes `os.networkInterfaces()` crash on Android's Bionic libc
+- **Smart Loading** - Shows spinner until gateway is actually ready
+- **Pass-through Commands** - Run any OpenClaw command directly via `clawdroid`
+- **Optimized for Android** - Pre-configured for mobile performance
+
+---
+
+## Quick Install
+
+### One-liner (recommended)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/NOSYTLABS/clawdroid/main/install.sh | bash
+```
+
+### Or via npm
+
+```bash
+npm install -g clawdroid
+clawdroid setup
+```
+
+---
+
+## Requirements
+
+| Requirement | Details |
+|-------------|---------|
+| **Android** | 10 or higher |
+| **Termux** | From [F-Droid](https://f-droid.org/packages/com.termux/) (NOT Play Store) |
+| **Storage** | ~2GB for Ubuntu + OpenClaw |
+
+---
+
+## Usage
+
+```bash
+# First-time setup (installs proot + Ubuntu + Node.js + OpenClaw)
+clawdroid setup
+
+# Check installation status
+clawdroid status
+
+# Update OpenClaw to latest version
+clawdroid update
+
+# Start OpenClaw gateway
+clawdroid start
+
+# Run onboarding to configure API keys
+clawdroid onboarding
+
+# Enter Ubuntu shell
+clawdroid shell
+
+# Any OpenClaw command works directly
+clawdroid doctor
+clawdroid gateway --verbose
+```
+
+> **Pro Tip:** Use `clawdroid gateway status` to check detailed health or `clawdroid logs --follow` to watch the gateway in real-time.
+
+---
+
+## How It Works
+
+```
+┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
+│     Termux      │     │  proot-distro   │     │     Ubuntu      │
+│    clawdroid    │ ──► │                 │ ──► │    OpenClaw     │
+│                 │     │  Bionic Bypass  │     │    Gateway      │
+└─────────────────┘     └─────────────────┘     └─────────────────┘
+```
+
+1. **clawdroid** runs in Termux
+2. Commands are passed through **proot-distro** with Bionic Bypass
+3. **OpenClaw** runs inside Ubuntu environment
+
+---
+
+## Configuration
+
+### Onboarding
+
+When running `clawdroid onboarding`:
+
+- **Binding**: Select `Loopback (127.0.0.1)` for non-rooted devices
+- **API Keys**: Add your Gemini/OpenAI/Claude keys
+
+### Battery Optimization
+
+> **Important:** Disable battery optimization for Termux
+
+Settings → Apps → Termux → Battery → **Unrestricted**
+
+---
+
+## Dashboard
+
+Access the web dashboard at: **http://127.0.0.1:18789**
+
+| Command | Description |
+|---------|-------------|
+| `/status` | Check gateway status |
+| `/think high` | Enable high-quality thinking |
+| `/reset` | Reset session |
+
+---
+
+## Troubleshooting
+
+### Gateway won't start
+
+```bash
+# Check status
+clawdroid status
+
+# Re-run setup if needed
+clawdroid setup
+
+# Make sure onboarding is complete
+clawdroid onboarding
+```
+
+### "os.networkInterfaces" error
+
+Bionic Bypass not configured. Run:
+
+```bash
+clawdroid setup
+```
+
+### Process killed in background
+
+Disable battery optimization for Termux in Android settings.
+
+### Permission denied
+
+```bash
+termux-setup-storage
+```
+
+---
+
+## Manual Setup
+
+<details>
+<summary>Click to expand manual installation steps</summary>
+
+### 1. Install proot-distro and Ubuntu
+
+```bash
+pkg update && pkg install -y proot-distro
+proot-distro install ubuntu
+```
+
+### 2. Setup Node.js in Ubuntu
+
+```bash
+proot-distro login ubuntu
+apt update && apt install -y curl
+curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+apt install -y nodejs
+npm install -g openclaw
+```
+
+### 3. Create Bionic Bypass
+
+```bash
+mkdir -p ~/.openclawd
+cat > ~/.openclawd/bionic-bypass.js << 'EOF'
+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'
+    }]
+  };
+};
+EOF
+```
+
+### 4. Add to bashrc
+
+```bash
+echo 'export NODE_OPTIONS="--require ~/.openclawd/bionic-bypass.js"' >> ~/.bashrc
+source ~/.bashrc
+```
+
+### 5. Run OpenClaw
+
+```bash
+openclaw onboarding  # Select "Loopback (127.0.0.1)"
+openclaw gateway --verbose
+```
+
+</details>
+
+---
+
+## Credits
+
+- Developed by **NOSYTLABS**
+- Powered by [OpenClaw](https://github.com/anthropics/openclaw)
+
+---
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+---
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+---
+
+<p align="center">
+  Made with ❤️ by NOSYTLABS
+</p>

package/bin/clawdroid

@@ -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,72 @@
+#!/bin/bash
+#
+# ClawDroid Installer
+# One-liner: curl -fsSL https://raw.githubusercontent.com/NOSYTLABS/clawdroid/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}"
+cat << "EOF"
+   ."".   ."".
+   |  |   |  |   CLAWDROID
+   \  \._./  /    Installer
+    '-./ \.-'
+      /   \
+     /_____\
+EOF
+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..."
+
+# Optimize Termux repo access and update
+echo -e "  ${BLUE}•${NC} Updating Termux repositories..."
+pkg update -y -o Dpkg::Options::="--force-confnew" || true
+pkg upgrade -y -o Dpkg::Options::="--force-confnew" || 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 clawdroid from npm
+echo -e "\n${BLUE}[2/3]${NC} Installing clawdroid..."
+npm install -g clawdroid
+
+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:      clawdroid setup"
+echo "  2. Run onboarding: clawdroid onboarding"
+echo "     → Select 'Loopback (127.0.0.1)' when asked!"
+echo "  3. Start gateway:  clawdroid 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,75 @@
+/**
+ * Bionic Bypass - Fixes os.networkInterfaces() on Android
+ *
+ * Android's Bionic libc blocks certain network interface queries.
+ * This module provides a workaround by returning a mock interface.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const BYPASS_SCRIPT = `
+// ClawDroid Bionic Bypass - Auto-generated
+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) {
+    // Bionic blocked the call, use fallback
+  }
+
+  // Return mock loopback interface
+  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,334 @@
+/**
+ * ClawDroid - Main entry point
+ */
+
+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(`
+  
+     CLAWDROID
+  
+   
+`);
+}
+
+function printHelp() {
+  console.log(`
+Usage: clawdroid [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
+
+  Any other command is passed directly to openclaw in proot:
+    clawdroid onboarding      → openclaw onboarding
+    clawdroid gateway -v      → openclaw gateway -v
+    clawdroid doctor          → openclaw doctor
+    clawdroid <anything>      → openclaw <anything>
+
+Examples:
+  clawdroid                   # Start gateway
+  clawdroid setup             # First-time setup
+  clawdroid update            # Update OpenClaw
+  clawdroid repair            # Fix installation
+  clawdroid shell             # Enter Ubuntu shell
+`);
+}
+
+async function runSetup() {
+  console.log('Starting ClawDroid setup for Termux...\n');
+  console.log('This will install: proot-distro → Ubuntu → Node.js 22 → OpenClaw\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();
+
+  // Step 1: Install proot-distro
+  console.log('[1/5] Checking proot-distro...');
+  if (!status.proot) {
+    console.log('  Installing proot-distro...');
+    installProot();
+  } else {
+    console.log('  ✓ proot-distro installed');
+  }
+  console.log('');
+
+  // Step 2: Install Ubuntu
+  console.log('[2/5] Checking Ubuntu in proot...');
+  status = getInstallStatus();
+  if (!status.ubuntu) {
+    console.log('  Installing Ubuntu (this takes a while)...');
+    installUbuntu();
+  } else {
+    console.log('  ✓ Ubuntu installed');
+  }
+  console.log('');
+
+  // Step 3: Setup Node.js and OpenClaw in Ubuntu
+  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('');
+
+  // Step 4: Setup Bionic Bypass in proot
+  console.log('[4/5] Setting up Bionic Bypass in proot...');
+  setupBionicBypassInProot();
+  console.log('');
+
+  // Step 5: Configure Termux wake-lock
+  console.log('[5/5] Configuring Termux...');
+  configureTermux();
+  console.log('');
+
+  // Done
+  console.log('═══════════════════════════════════════════');
+  console.log('Setup complete!');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. Run onboarding: clawdroid onboarding');
+  console.log('     → Select "Loopback (127.0.0.1)" when asked!');
+  console.log('  2. Start gateway:  clawdroid start');
+  console.log('');
+  console.log('Dashboard: http://127.0.0.1:18789');
+  console.log('═══════════════════════════════════════════');
+}
+
+function showStatus() {
+  // Quick loading while checking proot
+  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('');
+    console.log('Commands:');
+    console.log('  clawdroid start       # Start gateway');
+    console.log('  clawdroid onboarding  # Configure API keys');
+    console.log('  clawdroid shell       # Enter Ubuntu shell');
+  } 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: clawdroid setup');
+    process.exit(1);
+  }
+
+  console.log('Updating OpenClaw to the latest version...');
+  
+  // Use runInProotWithCallback to show real-time output
+  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 "clawdroid 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);
+  }
+
+  // Loading animation until dashboard responds
+  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);
+
+  // Poll dashboard until it responds
+  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 { /* ignore polling errors */ }
+  }, 500);
+
+  // Start gateway in background (suppress output until ready)
+  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');
+    }
+    console.log(`Gateway exited with code ${code}`);
+  });
+}
+
+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`);
+
+  // Special hint for onboarding
+  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 (with Bionic Bypass)...');
+  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'; // Default to 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:
+      // Pass any other command to openclaw in proot
+      runOpenclawCommand(args);
+      break;
+  }
+}

package/lib/installer.js

@@ -0,0 +1,325 @@
+/**
+ * ClawDroid Installer - Handles environment setup for Termux
+ */
+
+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 { /* not installed */ }
+
+  try {
+    execSync('npm --version', { stdio: 'pipe' });
+    deps.npm = true;
+  } catch { /* not installed */ }
+
+  try {
+    execSync('git --version', { stdio: 'pipe' });
+    deps.git = true;
+  } catch { /* not installed */ }
+
+  try {
+    execSync('which proot-distro', { stdio: 'pipe' });
+    deps.proot = true;
+  } catch { /* not installed */ }
+
+  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}"`;
+
+  // Add to shell configs
+  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`);
+        console.log(`Updated ${path.basename(rcFile)}`);
+      }
+    }
+  }
+
+  // Also set for current session
+  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);
+    console.log('You may need to install it manually: npm install -g openclaw');
+    return false;
+  }
+}
+
+export function configureTermux() {
+  console.log('Configuring Termux for background operation...');
+
+  // Create wake-lock script
+  const wakeLockScript = path.join(HOME, '.clawdroid', 'wakelock.sh');
+  const wakeLockContent = `#!/bin/bash
+# Keep Termux awake while OpenClaw runs
+termux-wake-lock
+trap "termux-wake-unlock" EXIT
+exec "$@"
+`;
+
+  fs.writeFileSync(wakeLockScript, wakeLockContent, 'utf8');
+  fs.chmodSync(wakeLockScript, '755');
+
+  console.log('Wake-lock script created');
+  console.log('');
+  console.log('IMPORTANT: Disable battery optimization for Termux in Android settings!');
+
+  return true;
+}
+
+export function getInstallStatus() {
+  const PROOT_ROOTFS = '/data/data/com.termux/files/usr/var/lib/proot-distro/installed-rootfs';
+
+  // Check proot-distro
+  let hasProot = false;
+  try {
+    execSync('command -v proot-distro', { stdio: 'pipe' });
+    hasProot = true;
+  } catch { /* not installed */ }
+
+  // Check if ubuntu is installed by checking rootfs directory
+  let hasUbuntu = false;
+  try {
+    hasUbuntu = fs.existsSync(path.join(PROOT_ROOTFS, 'ubuntu'));
+  } catch { /* check failed */ }
+
+  // Check if openclaw exists in proot ubuntu
+  let hasOpenClawInProot = false;
+  if (hasUbuntu) {
+    try {
+      execSync('proot-distro login ubuntu -- bash -c "command -v openclaw"', { stdio: 'pipe', timeout: 15000 });
+      hasOpenClawInProot = true;
+    } catch { /* not installed */ }
+  }
+
+  // Check bionic bypass in proot
+  let hasBionicBypassInProot = false;
+  try {
+    const prootBypassPath = path.join(PROOT_ROOTFS, 'ubuntu', 'root', '.clawdroid', 'bionic-bypass.js');
+    hasBionicBypassInProot = fs.existsSync(prootBypassPath);
+  } catch { /* check failed */ }
+
+  return {
+    proot: hasProot,
+    ubuntu: hasUbuntu,
+    openClawInProot: hasOpenClawInProot,
+    bionicBypassInProot: hasBionicBypassInProot,
+    // Legacy (for termux-native mode)
+    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 (this may take a while)...');
+  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...');
+
+  // Optimized setup script with better memory management and error handling
+  const setupScript = `
+    set -e
+    
+    # Optimize apt
+    echo 'Acquire::ForceIPv4 "true";' > /etc/apt/apt.conf.d/99force-ipv4
+    
+    echo "Updating package lists..."
+    apt update && apt upgrade -y
+    
+    echo "Installing core dependencies..."
+    apt install -y curl wget git build-essential python3
+    
+    echo "Setting up Node.js 22..."
+    curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+    apt install -y nodejs
+    
+    # Verify Node.js
+    node -v
+    npm -v
+    
+    echo "Installing OpenClaw..."
+    npm install -g openclaw --loglevel=error
+    
+    # Cleanup to save space
+    apt autoremove -y
+    apt clean
+  `;
+
+  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');
+
+    // Add to bashrc in proot
+    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`);
+    }
+
+    console.log('Bionic Bypass configured in proot Ubuntu');
+    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();
+    }
+    // Filter out harmless proot warnings
+    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,44 @@
+{
+  "name": "clawdroid",
+  "version": "1.0.0",
+  "description": "ClawDroid - Optimized OpenClaw AI Gateway for Android Termux",
+  "main": "lib/index.js",
+  "type": "module",
+  "bin": {
+    "clawdroid": "bin/clawdroid"
+  },
+  "scripts": {
+    "postinstall": "node lib/postinstall.js"
+  },
+  "keywords": [
+    "openclaw",
+    "termux",
+    "android",
+    "ai",
+    "gateway",
+    "gemini",
+    "claude"
+  ],
+  "author": "NOSYTLABS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NOSYTLABS/clawdroid.git"
+  },
+  "homepage": "https://github.com/NOSYTLABS/clawdroid#readme",
+  "bugs": {
+    "url": "https://github.com/NOSYTLABS/clawdroid/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "android",
+    "linux"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "inquirer": "^9.2.12",
+    "ora": "^7.0.1"
+  }
+}