Pivot v0.6.0: chrome-less shell + ⌘ palette + unrestricted defaults

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

@@ -7,17 +7,12 @@ 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 org.mozilla.geckoview.GeckoResult
 import org.mozilla.geckoview.GeckoRuntime
 import org.mozilla.geckoview.GeckoRuntimeSettings
@@ -26,6 +21,19 @@ import org.mozilla.geckoview.GeckoView
 import org.mozilla.geckoview.WebExtension
 import org.mozilla.geckoview.WebExtensionController
 
+/**
+ * Nova after the pivot: a chrome-less, unrestricted browser.
+ *
+ * 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).
+ */
 class BrowserActivity : ComponentActivity() {
 
     companion object {
@@ -39,58 +47,49 @@ 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.
+            // 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.RECOMMENDED)
-                            .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 to false to restore the prompt UI.)
+            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; if a
+        // palette/screen is open it consumes back instead.
         onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
                 if (tabManager.canGoBack()) {
@@ -123,10 +122,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")
@@ -142,7 +137,6 @@ class BrowserActivity : ComponentActivity() {
             )
     }
 
-    /** Receives messages from the extension's background script. */
     private inner class NovaBackgroundMessageDelegate : WebExtension.MessageDelegate {
         override fun onMessage(
             nativeApp: String,
@@ -155,76 +149,55 @@ 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) }
         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() } }
-
-        // 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("") }
-
         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, paletteOpen, 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 (paletteOpen) {
+            CommandPalette(
+                tabCount = tabManager.tabs.size,
+                activeTabId = activeId,
+                onSubmit = { input ->
+                    paletteOpen = false
+                    tabManager.activeSession()?.loadUri(normalize(input))
+                },
+                onCommand = { cmd ->
+                    paletteOpen = false
+                    when (cmd) {
+                        "new_tab" -> tabManager.open("about:blank")
+                        "close_tab" -> {
+                            val id = activeId
+                            if (id != null) tabManager.close(id)
+                        }
+                        "reload" -> tabManager.activeSession()?.reload()
+                        "tray" -> trayOpen = true
+                        "addons" -> addonsOpen = true
+                        "console" -> consoleOpen = true
+                        "clear_console" -> tabManager.consoleLines.clear()
+                    }
+                },
+                onDismiss = { paletteOpen = false },
+            )
+            return
         }
 
-        // M2: autocomplete suggestions from history while typing
-        val suggestions = if (urlFocused) tabManager.suggestionsFor(urlInput) else emptyList()
-
         if (trayOpen) {
             TabTray(
                 tabs = tabManager.tabs.toList(),
@@ -239,6 +212,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 ->
@@ -253,7 +230,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) {} },
@@ -271,67 +248,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 },
@@ -339,43 +263,14 @@ 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 = { paletteOpen = true },
+                modifier = Modifier
+                    .align(Alignment.BottomEnd)
+                    .padding(20.dp),
             )
         }
     }