feat(extension): complete extension bridge with protocol fixes

- Fix extension response format to use 'result' field (FGP protocol)
- Add AtomicBool for sync connection state checking
- Add browser.tabs.create, browser.tabs.query, browser.version methods
- Add version tracking to extension (0.1.1)
- Update CLI group command to chain tabs.group + tabGroups.update
- Add call_daemon_raw() helper for multi-step CLI commands

Extension bridge now fully working for:
- Tab groups (create, update, query, collapse)
- Real user cookies (any domain)
- Desktop notifications
- Query all user tabs

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: wolfiesch

extension/background.js

@@ -12,6 +12,7 @@ const FGP_WS_URL = 'ws://localhost:9223';  // FGP extension bridge port
 const RECONNECT_DELAY = 3000;
 const FGP_TAB_GROUP_NAME = 'FGP';
 const FGP_TAB_GROUP_COLOR = 'blue';
+const FGP_EXTENSION_VERSION = '0.1.1';  // Bump on protocol changes
 
 let ws = null;
 let fgpTabGroupId = null;
@@ -36,7 +37,7 @@ function connect() {
       updateBadge('connected');
 
       // Send hello message
-      send({ type: 'hello', version: '0.1.0', capabilities: getCapabilities() });
+      send({ type: 'hello', version: FGP_EXTENSION_VERSION, capabilities: getCapabilities() });
     };
 
     ws.onmessage = async (event) => {
@@ -157,9 +158,11 @@ async function handleRequest(request) {
 
     // === Utility ===
     case 'health':
-      return { ok: true, status: 'healthy' };
+      return { ok: true, result: { status: 'healthy' } };
     case 'capabilities':
-      return { ok: true, capabilities: getCapabilities() };
+      return { ok: true, result: getCapabilities() };
+    case 'version':
+      return { ok: true, result: { version: FGP_EXTENSION_VERSION } };
 
     default:
       return { ok: false, error: `Unknown method: ${method}` };
@@ -180,7 +183,7 @@ async function handleTabCreate(params) {
     await addTabToFgpGroup(tab.id);
   }
 
-  return { ok: true, tab: serializeTab(tab) };
+  return { ok: true, result: serializeTab(tab) };
 }
 
 async function handleTabUpdate(params) {
@@ -192,31 +195,31 @@ async function handleTabUpdate(params) {
   if (muted !== undefined) updates.muted = muted;
 
   const tab = await chrome.tabs.update(tabId, updates);
-  return { ok: true, tab: serializeTab(tab) };
+  return { ok: true, result: serializeTab(tab) };
 }
 
 async function handleTabRemove(params) {
   const { tabId, tabIds } = params;
   const ids = tabIds || [tabId];
   await chrome.tabs.remove(ids);
-  return { ok: true, removed: ids };
+  return { ok: true, result: { removed: ids } };
 }
 
 async function handleTabQuery(params) {
   const tabs = await chrome.tabs.query(params);
-  return { ok: true, tabs: tabs.map(serializeTab) };
+  return { ok: true, result: tabs.map(serializeTab) };
 }
 
 async function handleTabGet(params) {
   const { tabId } = params;
   const tab = await chrome.tabs.get(tabId);
-  return { ok: true, tab: serializeTab(tab) };
+  return { ok: true, result: serializeTab(tab) };
 }
 
 async function handleTabNavigate(params) {
   const { tabId, url } = params;
   const tab = await chrome.tabs.update(tabId, { url });
-  return { ok: true, tab: serializeTab(tab) };
+  return { ok: true, result: serializeTab(tab) };
 }
 
 // ============================================================================
@@ -231,7 +234,7 @@ async function handleTabGroup(params) {
   if (createProperties) options.createProperties = createProperties;
 
   const resultGroupId = await chrome.tabs.group(options);
-  return { ok: true, groupId: resultGroupId };
+  return { ok: true, result: { groupId: resultGroupId } };
 }
 
 async function handleTabUngroup(params) {
@@ -248,12 +251,12 @@ async function handleTabGroupUpdate(params) {
   if (collapsed !== undefined) updates.collapsed = collapsed;
 
   const group = await chrome.tabGroups.update(groupId, updates);
-  return { ok: true, group };
+  return { ok: true, result: group };
 }
 
 async function handleTabGroupQuery(params) {
   const groups = await chrome.tabGroups.query(params);
-  return { ok: true, groups };
+  return { ok: true, result: groups };
 }
 
 async function handleTabGroupCollapse(params) {
@@ -302,7 +305,7 @@ async function handleExecuteScript(params) {
     args
   });
 
-  return { ok: true, results: results.map(r => r.result) };
+  return { ok: true, result: results.map(r => r.result) };
 }
 
 async function handlePageSnapshot(params) {
@@ -314,7 +317,7 @@ async function handlePageSnapshot(params) {
     func: extractAriaTree
   });
 
-  return { ok: true, snapshot: results[0]?.result };
+  return { ok: true, result: results[0]?.result };
 }
 
 async function handlePageClick(params) {
@@ -331,7 +334,7 @@ async function handlePageClick(params) {
     args: [selector]
   });
 
-  return { ok: true, clicked: results[0]?.result };
+  return { ok: true, result: { clicked: results[0]?.result } };
 }
 
 async function handlePageFill(params) {
@@ -350,7 +353,7 @@ async function handlePageFill(params) {
     args: [selector, value]
   });
 
-  return { ok: true, filled: results[0]?.result };
+  return { ok: true, result: { filled: results[0]?.result } };
 }
 
 // ============================================================================
@@ -360,17 +363,17 @@ async function handlePageFill(params) {
 async function handleCookiesGet(params) {
   const { url, name } = params;
   const cookie = await chrome.cookies.get({ url, name });
-  return { ok: true, cookie };
+  return { ok: true, result: cookie };
 }
 
 async function handleCookiesGetAll(params) {
   const cookies = await chrome.cookies.getAll(params);
-  return { ok: true, cookies };
+  return { ok: true, result: cookies };
 }
 
 async function handleCookiesSet(params) {
   const cookie = await chrome.cookies.set(params);
-  return { ok: true, cookie };
+  return { ok: true, result: cookie };
 }
 
 // ============================================================================
@@ -381,7 +384,7 @@ async function handleStorageGet(params) {
   const { keys, area = 'local' } = params;
   const storage = area === 'sync' ? chrome.storage.sync : chrome.storage.local;
   const data = await storage.get(keys);
-  return { ok: true, data };
+  return { ok: true, result: data };
 }
 
 async function handleStorageSet(params) {
@@ -403,7 +406,7 @@ async function handleNotificationCreate(params) {
     title,
     message
   });
-  return { ok: true, notificationId: id };
+  return { ok: true, result: { notificationId: id } };
 }
 
 // ============================================================================
@@ -472,6 +475,29 @@ function extractAriaTree() {
   return { nodes, element_count: nodes.length };
 }
 
+// ============================================================================
+// Internal Message Handler (for popup communication)
+// ============================================================================
+
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message.type === 'getStatus') {
+    sendResponse({ status: connectionStatus });
+    return true;
+  }
+
+  if (message.type === 'reconnect') {
+    if (ws) {
+      ws.close();
+    }
+    ws = null;
+    connect();
+    sendResponse({ ok: true });
+    return true;
+  }
+
+  return false;
+});
+
 // ============================================================================
 // Initialize
 // ============================================================================

src/extension_bridge.rs

@@ -17,6 +17,7 @@ use anyhow::{Context, Result};
 use futures::{SinkExt, StreamExt};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use tokio::net::{TcpListener, TcpStream};
 use tokio::sync::{broadcast, mpsc, RwLock};
@@ -53,24 +54,37 @@ pub enum ConnectionState {
 }
 
 /// Methods that should be routed to the extension (not CDP)
+/// These use `browser.` prefix to pass FGP namespace validation,
+/// but the actual Chrome Extension API method is extracted when calling.
 pub const EXTENSION_METHODS: &[&str] = &[
+    // Tab Management (for grouping workflow)
+    "browser.tabs.create",
+    "browser.tabs.query",
     // Tab Groups (CDP can't do this!)
-    "tabs.group",
-    "tabs.ungroup",
-    "tabGroups.update",
-    "tabGroups.query",
-    "tabGroups.collapse",
+    "browser.tabs.group",
+    "browser.tabs.ungroup",
+    "browser.tabGroups.update",
+    "browser.tabGroups.query",
+    "browser.tabGroups.collapse",
     // Cookies (cleaner API than CDP)
-    "cookies.get",
-    "cookies.getAll",
-    "cookies.set",
+    "browser.cookies.get",
+    "browser.cookies.getAll",
+    "browser.cookies.set",
     // Notifications (extension-only)
-    "notifications.create",
+    "browser.notifications.create",
     // Storage (extension-only)
-    "storage.get",
-    "storage.set",
+    "browser.storage.get",
+    "browser.storage.set",
+    // Utility
+    "browser.version",
 ];
 
+/// Extract the Chrome Extension API method from a browser.* method
+/// e.g., "browser.tabs.group" -> "tabs.group"
+pub fn extension_method_name(method: &str) -> &str {
+    method.strip_prefix("browser.").unwrap_or(method)
+}
+
 /// Check if a method should be handled by the extension
 pub fn is_extension_method(method: &str) -> bool {
     EXTENSION_METHODS.iter().any(|m| *m == method)
@@ -80,6 +94,8 @@ pub fn is_extension_method(method: &str) -> bool {
 pub struct ExtensionBridge {
     /// Current connection state
     state: Arc<RwLock<ConnectionState>>,
+    /// Atomic flag for sync access to connection state
+    connected: Arc<AtomicBool>,
     /// Channel to send requests to extension
     request_tx: broadcast::Sender<ExtensionRequest>,
     /// Channel to receive responses from extension
@@ -99,6 +115,7 @@ impl ExtensionBridge {
 
         Self {
             state: Arc::new(RwLock::new(ConnectionState::Disconnected)),
+            connected: Arc::new(AtomicBool::new(false)),
             request_tx,
             response_tx,
             response_rx: Arc::new(RwLock::new(response_rx)),
@@ -117,6 +134,7 @@ impl ExtensionBridge {
         tracing::info!("Extension bridge listening on ws://{}", addr);
 
         let state = self.state.clone();
+        let connected = self.connected.clone();
         let request_tx = self.request_tx.clone();
         let response_tx = self.response_tx.clone();
         let pending = self.pending.clone();
@@ -128,13 +146,14 @@ impl ExtensionBridge {
                     Ok((stream, peer)) => {
                         tracing::info!("Extension connected from {}", peer);
                         let state = state.clone();
+                        let connected = connected.clone();
                         let request_rx = request_tx.subscribe();
                         let response_tx = response_tx.clone();
                         let pending = pending.clone();
 
                         tokio::spawn(async move {
                             if let Err(e) =
-                                handle_connection(stream, state, request_rx, response_tx, pending)
+                                handle_connection(stream, state, connected, request_rx, response_tx, pending)
                                     .await
                             {
                                 tracing::warn!("Extension connection error: {}", e);
@@ -170,17 +189,9 @@ impl ExtensionBridge {
     }
 
     /// Blocking version of is_connected() for use from synchronous code
+    /// Uses atomic bool for lock-free access
     pub fn is_connected_blocking(&self) -> bool {
-        match tokio::runtime::Handle::try_current() {
-            Ok(handle) => {
-                tokio::task::block_in_place(|| handle.block_on(self.is_connected()))
-            }
-            Err(_) => {
-                // Not in async context, check state directly (risky but okay for read)
-                // This is a best-effort check
-                false
-            }
-        }
+        self.connected.load(Ordering::SeqCst)
     }
 
     /// Send a request to the extension and wait for response
@@ -270,6 +281,7 @@ impl ExtensionBridge {
 async fn handle_connection(
     stream: TcpStream,
     state: Arc<RwLock<ConnectionState>>,
+    connected: Arc<AtomicBool>,
     mut request_rx: broadcast::Receiver<ExtensionRequest>,
     response_tx: mpsc::Sender<ExtensionResponse>,
     _pending: Arc<RwLock<HashMap<String, tokio::sync::oneshot::Sender<ExtensionResponse>>>>,
@@ -280,8 +292,9 @@ async fn handle_connection(
 
     let (mut ws_write, mut ws_read) = ws_stream.split();
 
-    // Mark as connected
+    // Mark as connected (both async state and atomic flag)
     *state.write().await = ConnectionState::Connected;
+    connected.store(true, Ordering::SeqCst);
     tracing::info!("Extension WebSocket connected");
 
     // Handle incoming messages from extension
@@ -344,8 +357,9 @@ async fn handle_connection(
         _ = write_handle => {},
     }
 
-    // Mark as disconnected
+    // Mark as disconnected (both async state and atomic flag)
     *state.write().await = ConnectionState::Disconnected;
+    connected.store(false, Ordering::SeqCst);
     tracing::info!("Extension WebSocket disconnected");
 
     Ok(())
@@ -357,10 +371,17 @@ mod tests {
 
     #[test]
     fn test_is_extension_method() {
-        assert!(is_extension_method("tabs.group"));
-        assert!(is_extension_method("tabGroups.update"));
-        assert!(is_extension_method("cookies.getAll"));
+        assert!(is_extension_method("browser.tabs.group"));
+        assert!(is_extension_method("browser.tabGroups.update"));
+        assert!(is_extension_method("browser.cookies.getAll"));
         assert!(!is_extension_method("browser.open"));
         assert!(!is_extension_method("browser.snapshot"));
     }
+
+    #[test]
+    fn test_extension_method_name() {
+        assert_eq!(extension_method_name("browser.tabs.group"), "tabs.group");
+        assert_eq!(extension_method_name("browser.cookies.getAll"), "cookies.getAll");
+        assert_eq!(extension_method_name("tabs.group"), "tabs.group"); // Already stripped
+    }
 }