Wire AI chat/settings into the chrome-less shell; version 0.7.0

app/src/main/java/dev/nova/browser/BrowserActivity.kt

@@ -7,30 +7,43 @@ import androidx.activity.ComponentActivity
 import androidx.activity.OnBackPressedCallback
 import androidx.activity.compose.setContent
 import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.LazyRow
-import androidx.compose.foundation.lazy.items
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.onFocusChanged
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
-import org.mozilla.geckoview.ContentBlocking
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.mozilla.geckoview.GeckoResult
 import org.mozilla.geckoview.GeckoRuntime
 import org.mozilla.geckoview.GeckoRuntimeSettings
-import org.mozilla.geckoview.GeckoSession
 import org.mozilla.geckoview.GeckoView
 import org.mozilla.geckoview.WebExtension
 import org.mozilla.geckoview.WebExtensionController
 
+/**
+ * Nova: a chrome-less, unrestricted browser with a built-in AI.
+ *
+ * Unrestricted defaults:
+ *  - NO tracking protection / content blocking (conventional browsers ship it on).
+ *  - Extension install permissions AUTO-GRANTED (no prompts).
+ *  - about:config enabled (full engine configuration surface).
+ *  - Remote debugging always on (desktop Firefox DevTools via about:debugging).
+ *
+ * New UI paradigm: no URL bar, no toolbar, no tab strip. Content is
+ * edge-to-edge; a floating ⌘ button summons the command palette which routes
+ * everything (navigate, search, tabs, add-ons, console, AI).
+ */
 class BrowserActivity : ComponentActivity() {
 
     companion object {
         // GeckoRuntime must be created exactly once per process (see GeckoView quick-start).
         private var runtime: GeckoRuntime? = null
+
+        /** Unrestricted mode: install permission requests are auto-granted. */
+        private const val AUTO_GRANT_PERMISSIONS = true
     }
 
     private lateinit var tabManager: TabManager
@@ -39,59 +52,48 @@ class BrowserActivity : ComponentActivity() {
         super.onCreate(savedInstanceState)
 
         if (runtime == null) {
-            // M6: content blocking (tracking protection) at the runtime level.
-            // NB: the old GeckoSession.TrackingProtectionPolicy API is gone in
-            // current GV; the modern API is ContentBlocking settings.
-            // AntiTracking.DEFAULT = block ad, analytic, social and test trackers.
+            // Unrestricted: no ContentBlocking settings passed — Gecko's default
+            // is no anti-tracking policy. about:config gives full engine access.
             runtime = GeckoRuntime.create(
                 this,
                 GeckoRuntimeSettings.Builder()
-                    .contentBlocking(
-                        ContentBlocking.Settings.Builder()
-                            .antiTracking(ContentBlocking.AntiTracking.DEFAULT)
-                            .cookieBehavior(ContentBlocking.CookieBehavior.ACCEPT_NON_TRACKERS)
-                            .build()
-                    )
+                    .aboutConfigEnabled(true)
                     .build()
             )
-            // Layer 2 of the dev console: desktop Firefox DevTools can attach
-            // via about:debugging over USB / Wi-Fi. GV 147 API:
-            // GeckoRuntimeSettings.setRemoteDebuggingEnabled(boolean).
+            // Desktop Firefox DevTools attach via about:debugging (USB / Wi-Fi).
             runtime!!.settings.setRemoteDebuggingEnabled(true)
 
-            // M5: installs REQUIRE a prompt delegate (GV refuses otherwise).
-            // The user decision is surfaced as a Compose dialog through
-            // TabManager.pendingInstall.
-            runtime!!.webExtensionController.setPromptDelegate(
-                object : WebExtensionController.PromptDelegate {
-                    override fun onInstallPromptRequest(
-                        extension: WebExtension,
-                        permissions: Array<out String>,
-                        origins: Array<out String>,
-                        dataCollectionPermissions: Array<out String>,
-                    ): GeckoResult<WebExtension.PermissionPromptResponse> {
-                        val result = GeckoResult<WebExtension.PermissionPromptResponse>()
-                        val name = extension.metaData?.name ?: extension.id
-                        tabManager.pendingInstall.value = TabManager.InstallPrompt(
-                            name = name,
-                            permissions = permissions.toList(),
-                            origins = origins.toList(),
-                        ) { allow ->
-                            tabManager.pendingInstall.value = null
-                            result.complete(
-                                WebExtension.PermissionPromptResponse(allow, false, false)
+            // Unrestricted: install permission requests are auto-granted, no
+            // dialog. (GV refuses installs without a registered PromptDelegate
+            // that returns a GeckoResult, so we register one that always
+            // allows. Flip AUTO_GRANT_PERMISSIONS to false to restore prompts.)
+            if (AUTO_GRANT_PERMISSIONS) {
+                runtime!!.webExtensionController.setPromptDelegate(
+                    object : WebExtensionController.PromptDelegate {
+                        override fun onInstallPromptRequest(
+                            extension: WebExtension,
+                            permissions: Array<out String>,
+                            origins: Array<out String>,
+                            dataCollectionPermissions: Array<out String>,
+                        ): GeckoResult<WebExtension.PermissionPromptResponse> {
+                            Log.i(
+                                "Nova",
+                                "Auto-granting install permissions for ${extension.id}: " +
+                                    "permissions=${permissions.toList()} origins=${origins.toList()}"
+                            )
+                            return GeckoResult.fromValue(
+                                WebExtension.PermissionPromptResponse(true, false, false)
                             )
                         }
-                        return result
                     }
-                }
-            )
+                )
+            }
         }
         tabManager = TabManager(runtime!!, this)
 
         installDevConsoleExtension()
 
-        // Hardware back button: navigate the page back before leaving the app.
+        // Hardware back: navigate the page back before leaving the app.
         onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
                 if (tabManager.canGoBack()) {
@@ -124,10 +126,6 @@ class BrowserActivity : ComponentActivity() {
         tabManager.persistSession()
     }
 
-    /**
-     * Installs the bundled dev-console extension (idempotent) and wires the
-     * background-script native messaging channel.
-     */
     private fun installDevConsoleExtension() {
         val controller = runtime!!.webExtensionController
         controller.ensureBuiltIn("resource://android/assets/devconsole/", "devconsole@nova")
@@ -143,7 +141,6 @@ class BrowserActivity : ComponentActivity() {
             )
     }
 
-    /** Receives messages from the extension's background script. */
     private inner class NovaBackgroundMessageDelegate : WebExtension.MessageDelegate {
         override fun onMessage(
             nativeApp: String,
@@ -156,75 +153,130 @@ class BrowserActivity : ComponentActivity() {
     }
 
     // ------------------------------------------------------------------
-    // UI
+    // UI: edge-to-edge content + floating ⌘ + overlays
     // ------------------------------------------------------------------
     @Composable
     private fun NovaUI() {
-        var urlInput by remember { mutableStateOf("https://example.com") }
-        var urlFocused by remember { mutableStateOf(false) }
+        var paletteOpen by remember { mutableStateOf(false) }
         var trayOpen by remember { mutableStateOf(false) }
         var addonsOpen by remember { mutableStateOf(false) }
         var consoleOpen by remember { mutableStateOf(false) }
+        var aiOpen by remember { mutableStateOf(false) }
+        var aiSettingsOpen by remember { mutableStateOf(false) }
+        var aiInitialPrompt by remember { mutableStateOf<String?>(null) }
         val geckoView = remember { GeckoView(this) }
-        val focusManager = LocalFocusManager.current
         val activeId by tabManager.activeTabId
 
-        val canGoBack by remember { derivedStateOf { tabManager.canGoBack() } }
-        val canGoForward by remember { derivedStateOf { tabManager.canGoForward() } }
+        // --- AI state (hoisted so chat survives overlay switches) ---
+        var aiConfig by remember { mutableStateOf(AiStore.load(this@BrowserActivity)) }
+        val aiMessages = remember { mutableStateListOf<Pair<String, String>>() }
+        var aiBusy by remember { mutableStateOf(false) }
+        var aiError by remember { mutableStateOf<String?>(null) }
+        val aiScope = rememberCoroutineScope()
+
+        val sendAi: (String) -> Unit = { text ->
+            val t = text.trim()
+            if (t.isNotBlank() && !aiBusy) {
+                aiMessages.add("user" to t)
+                aiBusy = true
+                aiError = null
+                aiScope.launch {
+                    val reply = try {
+                        withContext(Dispatchers.IO) { AiClient.chat(aiConfig, aiMessages.toList()) }
+                    } catch (e: Exception) {
+                        Log.e("NovaAI", "AI call failed", e)
+                        aiError = e.message ?: "AI call failed"
+                        null
+                    }
+                    if (reply != null) aiMessages.add("assistant" to reply)
+                    aiBusy = false
+                }
+            }
+        }
 
-        // M3 add-ons manager state
-        var extensions by remember { mutableStateOf<List<TabManager.ExtInfo>>(emptyList()) }
-        var addonsLoading by remember { mutableStateOf(false) }
-        var installMessage by remember { mutableStateOf("") }
+        // A question launched from the palette ("ask_ai:...") sends immediately.
+        var pendingAiPrompt by remember { mutableStateOf<String?>(null) }
+        LaunchedEffect(pendingAiPrompt) {
+            val p = pendingAiPrompt
+            if (p != null) {
+                pendingAiPrompt = null
+                if (aiMessages.isEmpty()) sendAi(p)
+                else sendAi(p)
+            }
+        }
+        // (kept aiInitialPrompt for API compat with the palette flow)
+        val aiInitialPrompt = pendingAiPrompt
 
         val loading = activeId != null && tabManager.loadingStates[activeId!!] == true
         val progress = activeId?.let { tabManager.progressStates[it] } ?: 0
 
-        // M5: install permission prompt — visible over every screen.
-        val pendingInstall by tabManager.pendingInstall
-        pendingInstall?.let { prompt ->
-            AlertDialog(
-                onDismissRequest = { prompt.respond(false) },
-                title = { Text("Install \"${prompt.name}\"?") },
-                text = {
-                    Column {
-                        if (prompt.permissions.isEmpty()) {
-                            Text("This add-on requests no special permissions.")
-                        } else {
-                            Text("It requests access to:")
-                            prompt.permissions.forEach { Text("• $it") }
-                        }
-                        if (prompt.origins.isNotEmpty()) {
-                            Text("Site access:")
-                            prompt.origins.forEach { Text("• $it") }
-                        }
-                    }
-                },
-                confirmButton = {
-                    TextButton(onClick = { prompt.respond(true) }) { Text("Install") }
-                },
-                dismissButton = {
-                    TextButton(onClick = { prompt.respond(false) }) { Text("Cancel") }
-                },
-            )
-        }
-
         // Re-attach the active session whenever we come back from any overlay.
-        LaunchedEffect(activeId, trayOpen, addonsOpen, consoleOpen) {
+        LaunchedEffect(activeId, aiOpen, aiSettingsOpen, trayOpen, addonsOpen, consoleOpen) {
             val id = activeId ?: return@LaunchedEffect
             val tab = tabManager.tabs.firstOrNull { t -> t.id == id } ?: return@LaunchedEffect
             geckoView.setSession(tab.session)
         }
 
-        // M2: live URL sync — follow the active tab's navigation while the
-        // user is not editing the address bar.
-        val activeUrl = activeId?.let { tabManager.lastUrls[it] }
-        LaunchedEffect(activeUrl) {
-            if (!urlFocused && activeUrl != null) urlInput = activeUrl
+        if (aiSettingsOpen) {
+            AiSettingsScreen(
+                config = aiConfig,
+                onSave = { cfg ->
+                    aiConfig = cfg
+                    AiStore.save(this, cfg)
+                    aiSettingsOpen = false
+                },
+                onDismiss = { aiSettingsOpen = false },
+            )
+            return
         }
 
-        // M2: autocomplete suggestions from history while typing
-        val suggestions = if (urlFocused) tabManager.suggestionsFor(urlInput) else emptyList()
+        if (aiOpen) {
+            AiChatScreen(
+                config = aiConfig,
+                messages = aiMessages.toList(),
+                busy = aiBusy,
+                error = aiError,
+                onSend = sendAi,
+                onOpenSettings = { aiOpen = false; aiSettingsOpen = true },
+                onClear = { aiMessages.clear() },
+                onDismiss = { aiOpen = false },
+            )
+            return
+        }
+
+        if (paletteOpenState) {
+            CommandPalette(
+                tabCount = tabManager.tabs.size,
+                activeTabId = activeId,
+                onSubmit = { input ->
+                    paletteOpenState = false
+                    tabManager.activeSession()?.loadUri(normalize(input))
+                },
+                onCommand = { cmd ->
+                    paletteOpenState = false
+                    when {
+                        cmd == "new_tab" -> tabManager.open("about:blank")
+                        cmd == "close_tab" -> {
+                            val id = activeId
+                            if (id != null) tabManager.close(id)
+                        }
+                        cmd == "reload" -> tabManager.activeSession()?.reload()
+                        cmd == "tray" -> trayOpen = true
+                        cmd == "addons" -> addonsOpen = true
+                        cmd == "console" -> consoleOpen = true
+                        cmd == "clear_console" -> tabManager.consoleLines.clear()
+                        cmd == "ai_chat" -> aiOpen = true
+                        cmd == "ai_settings" -> aiSettingsOpen = true
+                        cmd.startsWith("ask_ai:") -> {
+                            aiOpen = true
+                            pendingAiPrompt = cmd.removePrefix("ask_ai:")
+                        }
+                    }
+                },
+                onDismiss = { paletteOpenState = false },
+            )
+            return
+        }
 
         if (trayOpen) {
             TabTray(
@@ -240,6 +292,10 @@ class BrowserActivity : ComponentActivity() {
         }
 
         if (addonsOpen) {
+            var extensions by remember { mutableStateOf<List<TabManager.ExtInfo>>(emptyList()) }
+            var addonsLoading by remember { mutableStateOf(false) }
+            var installMessage by remember { mutableStateOf("") }
+
             LaunchedEffect(Unit) {
                 addonsLoading = true
                 tabManager.refreshExtensions { list ->
@@ -254,7 +310,7 @@ class BrowserActivity : ComponentActivity() {
                 installMessage = installMessage,
                 onInstall = { input ->
                     installMessage = "Installing…"
-                    tabManager.installFromAmo(input) { ok, msg -> installMessage = msg }
+                    tabManager.installFromAmo(input) { _, msg -> installMessage = msg }
                 },
                 onToggle = { id, enabled -> tabManager.setExtensionEnabled(id, enabled) {} },
                 onUninstall = { id -> tabManager.uninstallExtension(id) {} },
@@ -272,67 +328,14 @@ class BrowserActivity : ComponentActivity() {
             return
         }
 
-        Column(Modifier.fillMaxSize()) {
-            OutlinedTextField(
-                value = urlInput,
-                onValueChange = { urlInput = it },
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 8.dp, vertical = 4.dp)
-                    .onFocusChanged { urlFocused = it.isFocused },
-                label = { Text("Search or enter address") },
-                singleLine = true,
+        // Chrome-less browsing surface
+        Box(Modifier.fillMaxSize()) {
+            AndroidView(
+                factory = { geckoView },
+                modifier = Modifier.fillMaxSize(),
             )
 
-            // Autocomplete dropdown (history matches, most recent first)
-            if (urlFocused && suggestions.isNotEmpty()) {
-                Surface(
-                    tonalElevation = 4.dp,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 8.dp),
-                ) {
-                    Column {
-                        suggestions.forEach { suggestion ->
-                            TextButton(
-                                onClick = {
-                                    urlInput = suggestion
-                                    urlFocused = false
-                                    focusManager.clearFocus()
-                                    tabManager.activeSession()?.loadUri(suggestion)
-                                },
-                                modifier = Modifier.fillMaxWidth(),
-                            ) {
-                                Text(suggestion, maxLines = 1, overflow = TextOverflow.Ellipsis)
-                            }
-                        }
-                    }
-                }
-            }
-
-            Row(Modifier.padding(horizontal = 8.dp)) {
-                TextButton(
-                    onClick = { tabManager.activeSession()?.goBack() },
-                    enabled = canGoBack,
-                ) { Text("◀") }
-                TextButton(
-                    onClick = { tabManager.activeSession()?.goForward() },
-                    enabled = canGoForward,
-                ) { Text("▶") }
-                TextButton(onClick = { tabManager.activeSession()?.reload() }) { Text("⟳") }
-                TextButton(onClick = {
-                    focusManager.clearFocus()
-                    tabManager.activeSession()?.loadUri(normalize(urlInput))
-                }) { Text("Go") }
-                TextButton(onClick = { tabManager.open("about:blank") }) { Text("+") }
-                TextButton(onClick = { trayOpen = true }) { Text("Tabs ${tabManager.tabs.size}") }
-                TextButton(onClick = { addonsOpen = true }) { Text("Add-ons") }
-                TextButton(onClick = { consoleOpen = true }) {
-                    Text("Console ${tabManager.consoleLines.size}")
-                }
-            }
-
-            // M2: loading bar for the active tab
+            // Minimal status: loading bar hugging the top edge
             if (loading) {
                 LinearProgressIndicator(
                     progress = { progress / 100f },
@@ -340,47 +343,20 @@ class BrowserActivity : ComponentActivity() {
                 )
             }
 
-            // Tab strip
-            LazyRow(Modifier.padding(horizontal = 8.dp)) {
-                items(tabManager.tabs, key = { it.id }) { tab ->
-                    AssistChip(
-                        onClick = { tabManager.activate(tab.id) },
-                        label = {
-                            Text(
-                                "Tab ${tab.id}" + (if (tab.id == activeId) " ●" else ""),
-                                maxLines = 1,
-                            )
-                        },
-                        trailingIcon = {
-                            TextButton(onClick = { tabManager.close(tab.id) }) { Text("✕") }
-                        },
-                        modifier = Modifier.padding(end = 4.dp),
-                    )
-                }
-            }
-
-            // Console preview (full screen lives behind the Console button)
-            val lines = tabManager.consoleLines.takeLast(3)
-            if (lines.isNotEmpty()) {
-                Surface(
-                    tonalElevation = 2.dp,
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .heightIn(max = 72.dp),
-                ) {
-                    Column(Modifier.padding(6.dp)) {
-                        lines.forEach { line -> Text(line, style = MaterialTheme.typography.labelSmall, maxLines = 1) }
-                    }
-                }
-            }
-
-            AndroidView(
-                factory = { geckoView },
-                modifier = Modifier.fillMaxWidth().weight(1f),
+            // The single piece of chrome: ⌘ summons the palette
+            ExtendedFloatingActionButton(
+                text = { Text("⌘") },
+                icon = {},
+                onClick = { paletteOpenState = true },
+                modifier = Modifier
+                    .align(Alignment.BottomEnd)
+                    .padding(20.dp),
             )
         }
     }
 
+    private var paletteOpenState by mutableStateOf(false)
+
     private fun normalize(input: String): String = when {
         input.startsWith("http://") || input.startsWith("https://") -> input
         input.startsWith("about:") -> input