mithun50
diff --git a/‎CHANGELOG.md‎
Lines changed: 21 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 21 additions & 0 deletions
diff --git a/‎README.md‎
Lines changed: 13 additions & 2 deletions b/‎README.md‎
Lines changed: 13 additions & 2 deletions
diff --git a/‎flutter_app/android/app/src/main/AndroidManifest.xml‎
Lines changed: 5 additions & 0 deletions b/‎flutter_app/android/app/src/main/AndroidManifest.xml‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/BootstrapManager.kt‎
Lines changed: 10 additions & 4 deletions b/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/BootstrapManager.kt‎
Lines changed: 10 additions & 4 deletions
diff --git a/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/GatewayService.kt‎
Lines changed: 4 additions & 2 deletions b/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/GatewayService.kt‎
Lines changed: 4 additions & 2 deletions
diff --git a/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/MainActivity.kt‎
Lines changed: 44 additions & 0 deletions b/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/MainActivity.kt‎
Lines changed: 44 additions & 0 deletions
diff --git a/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/SshForegroundService.kt‎
Lines changed: 213 additions & 0 deletions b/‎flutter_app/android/app/src/main/kotlin/com/nxg/openclawproot/SshForegroundService.kt‎
Lines changed: 213 additions & 0 deletions
@@ -1,5 +1,26 @@
 # Changelog
 
+## v1.8.0 — AI Providers, SSH Access, Ctrl Keys & Configure Menu
+
+### New Features
+
+- **AI Providers** — New "AI Providers" screen to configure API keys and select models for 7 providers: Anthropic, OpenAI, Google Gemini, OpenRouter, NVIDIA NIM, DeepSeek, and xAI. Writes configuration directly to `~/.openclaw/openclaw.json`
+- **SSH Remote Access** — New "SSH Access" screen to start/stop an SSH server (sshd) inside proot, set the root password, and view connection info with copyable `ssh` commands. Runs as an Android foreground service for persistence
+- **Configure Menu** — New "Configure" dashboard card opens `openclaw configure` in a built-in terminal for managing gateway settings
+- **Clickable URLs** — Terminal and onboarding screens detect URLs at tap position (joining adjacent lines, stripping box-drawing characters) and offer Open/Copy/Cancel dialog
+
+### Bug Fixes
+
+- **Ctrl Key with Soft Keyboard (#37)** — Ctrl and Alt modifier state from the toolbar now applies to soft keyboard input across all terminal screens (terminal, configure, onboarding, package install). Previously only worked with toolbar buttons
+- **Ctrl+Arrow/Home/End/PgUp/PgDn (#38)** — Toolbar Ctrl modifier now sends correct escape sequences for arrow keys and navigation keys (e.g. `Ctrl+Left` sends `ESC[1;5D`)
+- **resolv.conf ENOENT after Update (#40)** — DNS resolution failed after app update because `resolv.conf` was missing. Now ensured on every app launch (splash screen), before every proot operation (`getProotShellConfig`), and in the gateway service init — covering reinstall, update, and normal launch
+
+### Dashboard
+
+- Added "AI Providers" and "SSH Access" quick action cards
+
+---
+
 ## v1.7.3 — DNS Fix, Snapshot & Version Sync
 
 ### Bug Fixes
 
@@ -56,12 +56,15 @@ OpenClaw brings the [OpenClaw](https://github.com/anthropics/openclaw) AI gatewa
 - **One-Tap Setup** — Downloads Ubuntu rootfs, Node.js 22, and OpenClaw automatically
 - **Built-in Terminal** — Full terminal emulator with extra keys toolbar, copy/paste, clickable URLs
 - **Gateway Controls** — Start/stop gateway with status indicator and health checks
+- **AI Providers** — Configure API keys and select models for 7 providers (Anthropic, OpenAI, Google Gemini, OpenRouter, NVIDIA NIM, DeepSeek, xAI)
+- **SSH Remote Access** — Start/stop SSH server, set root password, view connection info with copyable commands
+- **Configure Menu** — Run `openclaw configure` in a built-in terminal to manage gateway settings
 - **Node Device Capabilities** — 7 capabilities (15 commands) exposed to AI via WebSocket node protocol
 - **Token URL Display** — Captures auth token from onboarding, shows it with a copy button
 - **Web Dashboard** — Embedded WebView loads the dashboard with authentication token
 - **View Logs** — Real-time gateway log viewer with search/filter
 - **Onboarding** — Configure API keys and binding directly in-app
-- **Optional Packages** — Install Go (Golang) and Homebrew as optional dev tools from the setup wizard or dashboard
+- **Optional Packages** — Install Go (Golang), Homebrew, and OpenSSH as optional dev tools
 - **Settings** — Auto-start, battery optimization, system info, package status, re-run setup
 - **Foreground Service** — Keeps the gateway alive in the background with uptime tracking
 - **Setup Notifications** — Progress bar notifications during environment setup
@@ -74,6 +77,7 @@ After the initial setup completes, you can optionally install development tools
 |---------|---------------|------|
 | **Go (Golang)** | `apt install golang` | ~150 MB |
 | **Homebrew** | Official installer (with root workaround) | ~500 MB |
+| **OpenSSH** | `apt install openssh-server` | ~10 MB |
 
 These are accessible from:
 - **Setup Wizard** — Package cards appear after setup completes
@@ -222,7 +226,8 @@ flutter_app/lib/
 │   ├── node_state.dart        # Node connection status
 │   ├── node_frame.dart        # WebSocket frame model (req/res/event)
 │   ├── setup_state.dart       # Setup wizard progress
-│   └── optional_package.dart  # Optional package metadata (Go, Homebrew)
+│   ├── optional_package.dart  # Optional package metadata (Go, Homebrew)
+│   └── ai_provider.dart       # AI provider data model (7 providers)
 ├── providers/
 │   ├── gateway_provider.dart  # Gateway state management
 │   ├── node_provider.dart     # Node capabilities + permission management
@@ -233,7 +238,11 @@ flutter_app/lib/
 │   ├── onboarding_screen.dart      # API key configuration terminal
 │   ├── dashboard_screen.dart       # Main dashboard with quick actions
 │   ├── terminal_screen.dart        # Full terminal emulator
+│   ├── configure_screen.dart       # openclaw configure terminal
 │   ├── web_dashboard_screen.dart   # WebView for OpenClaw dashboard
+│   ├── providers_screen.dart       # AI provider list
+│   ├── provider_detail_screen.dart # API key + model configuration
+│   ├── ssh_screen.dart             # SSH server management
 │   ├── packages_screen.dart        # Optional package manager
 │   ├── package_install_screen.dart # Terminal-based package installer
 │   ├── logs_screen.dart            # Gateway log viewer
@@ -248,6 +257,8 @@ flutter_app/lib/
 │   ├── bootstrap_service.dart # Environment setup orchestration
 │   ├── package_service.dart   # Optional package status checking
 │   ├── preferences_service.dart # Persistent settings (token URL, etc.)
+│   ├── provider_config_service.dart # AI provider config read/write
+│   ├── ssh_service.dart       # SSH server management via native bridge
 │   └── capabilities/
 │       ├── capability_handler.dart   # Base class with permission handling
 │       ├── camera_capability.dart    # Photo/video capture
 
@@ -66,6 +66,11 @@
             android:exported="false"
             android:foregroundServiceType="specialUse" />
 
+        <service
+            android:name=".SshForegroundService"
+            android:exported="false"
+            android:foregroundServiceType="specialUse" />
+
         <service
             android:name=".ScreenCaptureService"
             android:exported="false"
 
@@ -1213,10 +1213,16 @@ require('/root/.openclaw/proot-compat.js');
     }
 
     fun writeResolvConf() {
-        val configDir = File(this.configDir)
-        configDir.mkdirs()
-
-        File("$configDir/resolv.conf").writeText("nameserver 8.8.8.8\nnameserver 8.8.4.4\n")
+        // Ensure the config directory exists. Use context.filesDir as the
+        // canonical base (Android always ensures it exists) rather than
+        // relying solely on the String path, which may point to a directory
+        // that was cleared during an app upgrade. (#40)
+        val dir = File(context.filesDir, "config")
+        if (!dir.exists()) {
+            dir.mkdirs()
+        }
+        val resolv = File(dir, "resolv.conf")
+        resolv.writeText("nameserver 8.8.8.8\nnameserver 8.8.4.4\n")
     }
 
     /** Read a file from inside the rootfs (e.g. /root/.openclaw/openclaw.json). */
 
@@ -80,9 +80,11 @@ class GatewayService : Service() {
                 val nativeLibDir = applicationContext.applicationInfo.nativeLibraryDir
                 val pm = ProcessManager(filesDir, nativeLibDir)
 
-                // Refresh resolv.conf before every gateway start so DNS always works,
-                // even after Android clears the app's file cache.
+                // Recreate all directories (config, tmp, home, lib, proc/sys fakes)
+                // in case Android cleared them after an app update (#40).
+                // This must run before proot — it needs bind-mount targets.
                 val bootstrapManager = BootstrapManager(applicationContext, filesDir, nativeLibDir)
+                bootstrapManager.setupDirectories()
                 bootstrapManager.writeResolvConf()
 
                 gatewayProcess = pm.startProotProcess("openclaw gateway --verbose")
 
@@ -162,6 +162,50 @@ class MainActivity : FlutterActivity() {
                     NodeForegroundService.updateStatus(text)
                     result.success(true)
                 }
+                "startSshd" -> {
+                    val port = call.argument<Int>("port") ?: 8022
+                    try {
+                        SshForegroundService.start(applicationContext, port)
+                        result.success(true)
+                    } catch (e: Exception) {
+                        result.error("SERVICE_ERROR", e.message, null)
+                    }
+                }
+                "stopSshd" -> {
+                    try {
+                        SshForegroundService.stop(applicationContext)
+                        result.success(true)
+                    } catch (e: Exception) {
+                        result.error("SERVICE_ERROR", e.message, null)
+                    }
+                }
+                "isSshdRunning" -> {
+                    result.success(SshForegroundService.isRunning)
+                }
+                "getSshdPort" -> {
+                    result.success(SshForegroundService.currentPort)
+                }
+                "getDeviceIps" -> {
+                    result.success(SshForegroundService.getDeviceIps())
+                }
+                "setRootPassword" -> {
+                    val password = call.argument<String>("password")
+                    if (password != null) {
+                        Thread {
+                            try {
+                                val escaped = password.replace("'", "'\\''")
+                                processManager.runInProotSync(
+                                    "echo 'root:$escaped' | chpasswd", 15
+                                )
+                                runOnUiThread { result.success(true) }
+                            } catch (e: Exception) {
+                                runOnUiThread { result.error("SSH_ERROR", e.message, null) }
+                            }
+                        }.start()
+                    } else {
+                        result.error("INVALID_ARGS", "password required", null)
+                    }
+                }
                 "requestBatteryOptimization" -> {
                     try {
                         val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
 
@@ -0,0 +1,213 @@
+package com.nxg.openclawproot
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import android.os.PowerManager
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.net.NetworkInterface
+
+/**
+ * Foreground service that runs sshd in a persistent proot process.
+ * sshd must run with -D (no daemonize) so proot stays alive.
+ */
+class SshForegroundService : Service() {
+    companion object {
+        const val CHANNEL_ID = "openclaw_ssh"
+        const val NOTIFICATION_ID = 5
+        const val EXTRA_PORT = "port"
+        var isRunning = false
+            private set
+        var currentPort = 8022
+            private set
+        private var instance: SshForegroundService? = null
+
+        fun start(context: Context, port: Int = 8022) {
+            val intent = Intent(context, SshForegroundService::class.java).apply {
+                putExtra(EXTRA_PORT, port)
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+
+        fun stop(context: Context) {
+            val intent = Intent(context, SshForegroundService::class.java)
+            context.stopService(intent)
+        }
+
+        /** Get device IP addresses via Android NetworkInterface. */
+        fun getDeviceIps(): List<String> {
+            val ips = mutableListOf<String>()
+            try {
+                val interfaces = NetworkInterface.getNetworkInterfaces() ?: return ips
+                for (iface in interfaces) {
+                    if (iface.isLoopback || !iface.isUp) continue
+                    for (addr in iface.inetAddresses) {
+                        if (addr.isLoopbackAddress) continue
+                        val hostAddr = addr.hostAddress ?: continue
+                        // Skip IPv6 link-local
+                        if (hostAddr.contains("%")) continue
+                        // Prefer IPv4, but include IPv6 too
+                        ips.add(hostAddr)
+                    }
+                }
+            } catch (_: Exception) {}
+            return ips
+        }
+    }
+
+    private var sshdProcess: Process? = null
+    private var wakeLock: PowerManager.WakeLock? = null
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        createNotificationChannel()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val port = intent?.getIntExtra(EXTRA_PORT, 8022) ?: 8022
+        currentPort = port
+        startForeground(NOTIFICATION_ID, buildNotification("Starting SSH on port $port..."))
+        acquireWakeLock()
+        startSshd(port)
+        return START_STICKY
+    }
+
+    override fun onDestroy() {
+        isRunning = false
+        instance = null
+        stopSshd()
+        releaseWakeLock()
+        super.onDestroy()
+    }
+
+    private fun startSshd(port: Int) {
+        isRunning = true
+        instance = this
+
+        Thread {
+            try {
+                val filesDir = applicationContext.filesDir.absolutePath
+                val nativeLibDir = applicationContext.applicationInfo.nativeLibraryDir
+                val pm = ProcessManager(filesDir, nativeLibDir)
+
+                // Ensure directories exist
+                val bootstrapManager = BootstrapManager(applicationContext, filesDir, nativeLibDir)
+                bootstrapManager.setupDirectories()
+                bootstrapManager.writeResolvConf()
+
+                // Generate host keys if missing, configure sshd, then run in
+                // foreground mode (-D) so the proot process stays alive.
+                // -e logs to stderr instead of syslog (easier debugging).
+                // PermitRootLogin yes is needed since proot fakes root.
+                val cmd = "mkdir -p /run/sshd /etc/ssh && " +
+                    "test -f /etc/ssh/ssh_host_rsa_key || ssh-keygen -A && " +
+                    "sed -i 's/^#\\?PermitRootLogin.*/PermitRootLogin yes/' /etc/ssh/sshd_config 2>/dev/null; " +
+                    "grep -q '^PermitRootLogin' /etc/ssh/sshd_config || echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config; " +
+                    "/usr/sbin/sshd -D -e -p $port"
+
+                sshdProcess = pm.startProotProcess(cmd)
+                updateNotification("SSH running on port $port")
+
+                // Read stderr for logs
+                val stderrReader = BufferedReader(InputStreamReader(sshdProcess!!.errorStream))
+                Thread {
+                    try {
+                        var line: String?
+                        while (stderrReader.readLine().also { line = it } != null) {
+                            // Could log these if needed
+                        }
+                    } catch (_: Exception) {}
+                }.start()
+
+                val exitCode = sshdProcess!!.waitFor()
+                isRunning = false
+                updateNotification("SSH stopped (exit $exitCode)")
+                stopSelf()
+            } catch (e: Exception) {
+                isRunning = false
+                updateNotification("SSH error: ${e.message?.take(50)}")
+                stopSelf()
+            }
+        }.start()
+    }
+
+    private fun stopSshd() {
+        sshdProcess?.let {
+            it.destroyForcibly()
+            sshdProcess = null
+        }
+    }
+
+    private fun acquireWakeLock() {
+        val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
+        wakeLock = powerManager.newWakeLock(
+            PowerManager.PARTIAL_WAKE_LOCK,
+            "OpenClaw::SshWakeLock"
+        )
+        wakeLock?.acquire(24 * 60 * 60 * 1000L)
+    }
+
+    private fun releaseWakeLock() {
+        wakeLock?.let {
+            if (it.isHeld) it.release()
+        }
+        wakeLock = null
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                "OpenClaw SSH",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Keeps the SSH server running in the background"
+            }
+            val manager = getSystemService(NotificationManager::class.java)
+            manager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun buildNotification(text: String): Notification {
+        val intent = Intent(this, MainActivity::class.java)
+        val pendingIntent = PendingIntent.getActivity(
+            this, 0, intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val builder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            Notification.Builder(this, CHANNEL_ID)
+        } else {
+            @Suppress("DEPRECATION")
+            Notification.Builder(this)
+        }
+
+        builder.setContentTitle("OpenClaw SSH")
+            .setContentText(text)
+            .setSmallIcon(android.R.drawable.ic_lock_lock)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true)
+
+        return builder.build()
+    }
+
+    private fun updateNotification(text: String) {
+        try {
+            val manager = getSystemService(NotificationManager::class.java)
+            manager.notify(NOTIFICATION_ID, buildNotification(text))
+        } catch (_: Exception) {}
+    }
+}