@duheso/zerocli 0.8.6 → 0.8.8

package/chrome-extension/background.js

@@ -6,6 +6,8 @@ const VERSION = '1.0.0';
 
 let nativePort = null;
 let isConnected = false;
+let isConnecting = false;       // guard against concurrent connect attempts
+let reconnectTimer = null;      // handle for pending reconnect setTimeout
 let pendingRequests = new Map(); // requestId -> { resolve, reject, timeoutId }
 let requestCounter = 0;
 let debuggerAttachedTabs = new Set();
@@ -14,53 +16,114 @@ let networkRequests = new Map(); // tabId -> [requests]
 let captureStreams = new Map(); // tabId -> MediaRecorder
 let gifFrames = new Map(); // requestId -> [frames]
 
-// ─── Native Messaging ──────────────────────────────────────────────────────
+// ─── Debug Stats ──────────────────────────────────────────────────────────────
+
+const debugStats = {
+  connectAttempts: 0,
+  connectSuccesses: 0,
+  disconnects: 0,
+  toolsDispatched: 0,
+  toolErrors: 0,
+  lastError: null,
+  lastErrorTime: null,
+  lastToolCall: null,
+  lastToolCallTime: null,
+  workerStartTime: Date.now(),
+};
+
+function dbg(msg, ...args) {
+  const ts = new Date().toISOString();
+  console.log(`[ZeroCLI ${ts}] ${msg}`, ...args);
+}
+
+function scheduleReconnect(delayMs) {
+  // Cancel any pending reconnect to avoid stacking timers
+  if (reconnectTimer !== null) {
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  }
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    connectNativeHost();
+  }, delayMs);
+}
 
 function connectNativeHost() {
+  // Guard: don't start a new connection if one is already in progress or live
+  if (isConnecting || isConnected) {
+    dbg(`connectNativeHost skipped (isConnecting=${isConnecting}, isConnected=${isConnected})`);
+    return;
+  }
+  isConnecting = true;
+  debugStats.connectAttempts++;
+  dbg(`Connecting to native host (attempt #${debugStats.connectAttempts})...`);
   try {
-    nativePort = chrome.runtime.connectNative(NATIVE_HOST_NAME);
-    isConnected = true;
-    updateIcon(true);
+    const port = chrome.runtime.connectNative(NATIVE_HOST_NAME);
+    nativePort = port;
 
-    nativePort.onMessage.addListener((message) => {
+    port.onMessage.addListener((message) => {
       handleNativeMessage(message);
     });
 
-    nativePort.onDisconnect.addListener(() => {
+    port.onDisconnect.addListener(() => {
       // Read lastError to mark it as "checked" and suppress DevTools warning
       const err = chrome.runtime.lastError;
+      const errMsg = err?.message ?? 'unknown reason';
       const hostNotFound = err && (
         err.message?.includes('not found') ||
         err.message?.includes('Cannot find native messaging host') ||
         err.message?.includes('Specified native messaging host not found')
       );
+
+      // Only process disconnect for the port we currently own
+      if (nativePort !== port) {
+        dbg(`Stale port disconnect ignored: ${errMsg}`);
+        return;
+      }
+
+      debugStats.disconnects++;
+      debugStats.lastError = errMsg;
+      debugStats.lastErrorTime = Date.now();
       isConnected = false;
+      isConnecting = false;
       nativePort = null;
       updateIcon(false);
+      dbg(`Native host disconnected (total disconnects: ${debugStats.disconnects}): ${errMsg}`);
+
       // Reject all pending requests
-      for (const [id, pending] of pendingRequests) {
+      for (const [, pending] of pendingRequests) {
         clearTimeout(pending.timeoutId);
         pending.reject(new Error(err?.message ?? 'Native host disconnected'));
       }
       pendingRequests.clear();
+
       if (hostNotFound) {
-        // Native host not installed yet — retry slowly (every 30s)
-        // User needs to run: zero --chrome  (to register the native host)
         console.warn('[ZeroCLI] Native messaging host not found. Run "zero --chrome" once to register it, then reload this extension.');
-        setTimeout(connectNativeHost, 30000);
+        scheduleReconnect(30000);
       } else {
-        // Normal disconnect — reconnect after short delay
-        setTimeout(connectNativeHost, 3000);
+        scheduleReconnect(3000);
       }
     });
 
+    // Mark connected only after port is set up (Chrome fires onDisconnect
+    // synchronously if the host binary isn't found, so this must come after)
+    isConnected = true;
+    isConnecting = false;
+    debugStats.connectSuccesses++;
+    updateIcon(true);
+    dbg('Native host connected successfully.');
+
     // Send initial ping
     sendToNative({ type: 'ping' });
   } catch (err) {
     isConnected = false;
+    isConnecting = false;
+    nativePort = null;
     updateIcon(false);
+    debugStats.lastError = err?.message ?? String(err);
+    debugStats.lastErrorTime = Date.now();
     console.warn('[ZeroCLI] connectNativeHost error:', err?.message);
-    setTimeout(connectNativeHost, 30000);
+    scheduleReconnect(30000);
   }
 }
 
@@ -79,7 +142,7 @@ async function handleNativeMessage(message) {
 
   switch (message.type) {
     case 'pong':
-      // Connection confirmed
+      dbg('Received pong from native host — connection healthy.');
       break;
 
     case 'status_response':
@@ -88,14 +151,23 @@ async function handleNativeMessage(message) {
 
     case 'tool_request': {
       const { method, params, id: requestId } = message;
+      debugStats.toolsDispatched++;
+      debugStats.lastToolCall = method;
+      debugStats.lastToolCallTime = Date.now();
+      dbg(`Tool request #${debugStats.toolsDispatched}: ${method} (id=${requestId})`);
       try {
         const result = await dispatchTool(method, params || {});
+        dbg(`Tool success: ${method}`);
         sendToNative({
           type: 'tool_response',
           id: requestId,
           result,
         });
       } catch (err) {
+        debugStats.toolErrors++;
+        debugStats.lastError = `${method}: ${err.message}`;
+        debugStats.lastErrorTime = Date.now();
+        console.error(`[ZeroCLI] Tool error: ${method}:`, err.message);
         sendToNative({
           type: 'tool_response',
           id: requestId,
@@ -106,10 +178,12 @@ async function handleNativeMessage(message) {
     }
 
     case 'mcp_connected':
+      dbg('MCP client connected.');
       updateIcon(true);
       break;
 
     case 'mcp_disconnected':
+      dbg('MCP client disconnected.');
       updateIcon(false);
       break;
 
@@ -156,6 +230,8 @@ async function dispatchTool(method, params) {
       return toolShortcutsList(params);
     case 'shortcuts_execute':
       return toolShortcutsExecute(params);
+    case 'debug_info':
+      return toolDebugInfo(params);
     default:
       throw new Error(`Unknown tool: ${method}`);
   }
@@ -467,6 +543,40 @@ async function toolShortcutsExecute(params) {
   return result;
 }
 
+async function toolDebugInfo(_params) {
+  const uptimeMs = Date.now() - debugStats.workerStartTime;
+  const tabs = await chrome.tabs.query({}).catch(() => []);
+  return {
+    version: VERSION,
+    isConnected,
+    nativePortAlive: nativePort !== null,
+    uptime_ms: uptimeMs,
+    uptime_human: `${Math.floor(uptimeMs / 60000)}m ${Math.floor((uptimeMs % 60000) / 1000)}s`,
+    stats: {
+      connectAttempts: debugStats.connectAttempts,
+      connectSuccesses: debugStats.connectSuccesses,
+      disconnects: debugStats.disconnects,
+      toolsDispatched: debugStats.toolsDispatched,
+      toolErrors: debugStats.toolErrors,
+    },
+    flags: {
+      isConnected,
+      isConnecting,
+      hasPendingReconnectTimer: reconnectTimer !== null,
+    },
+    lastError: debugStats.lastError,
+    lastErrorAgo: debugStats.lastErrorTime
+      ? `${Math.round((Date.now() - debugStats.lastErrorTime) / 1000)}s ago`
+      : null,
+    lastToolCall: debugStats.lastToolCall,
+    lastToolCallAgo: debugStats.lastToolCallTime
+      ? `${Math.round((Date.now() - debugStats.lastToolCallTime) / 1000)}s ago`
+      : null,
+    openTabs: tabs.length,
+    debuggerAttachedTabs: debuggerAttachedTabs.size,
+  };
+}
+
 // ─── Helper Functions ────────────────────────────────────────────────────────
 
 async function getActiveTabId() {
@@ -492,10 +602,14 @@ async function waitForTabLoad(tabId, timeoutMs = 10000) {
 }
 
 async function executeInTab(tabId, func, args) {
+  // chrome.scripting.executeScript requires all args to be structured-clone
+  // serializable. undefined is NOT serializable, so replace with null.
+  // The injected functions already treat null as "not provided" (falsy checks).
+  const safeArgs = args.map(v => v === undefined ? null : v);
   const results = await chrome.scripting.executeScript({
     target: { tabId },
     func,
-    args,
+    args: safeArgs,
   });
   return results[0]?.result;
 }
@@ -906,23 +1020,50 @@ chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
   if (message?.type === 'get_status') {
     sendResponse({
       isConnected,
+      isConnecting,
       nativePortAlive: nativePort !== null,
       version: VERSION,
+      stats: { ...debugStats },
     });
   }
   // Return false: we handled synchronously.
   return false;
 });
 
+// ─── Service Worker Keep-Alive (MV3) ─────────────────────────────────────────
+//
+// Chrome MV3 service workers are killed after ~30s of inactivity. We use the
+// alarms API to wake the worker every 20 seconds, keeping the native messaging
+// connection alive. Without this, the native host process exits, the Unix socket
+// disappears, and all tool calls fail with "Browser extension is not connected".
+
+chrome.alarms.create('zerocli-keepalive', { periodInMinutes: 0.33 }); // ~20 seconds
+
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === 'zerocli-keepalive') {
+    if (isConnected) {
+      // Send a lightweight ping to verify the connection is still healthy
+      sendToNative({ type: 'ping' });
+    } else if (!isConnecting && reconnectTimer === null) {
+      // Only reconnect if nothing else has already scheduled one
+      dbg('Keep-alive alarm: not connected, scheduling reconnect...');
+      scheduleReconnect(0);
+    }
+  }
+});
+
 // ─── Init ────────────────────────────────────────────────────────────────────
 
 chrome.runtime.onInstalled.addListener(() => {
   updateIcon(false);
+  dbg('Extension installed/updated.');
 });
 
 chrome.runtime.onStartup.addListener(() => {
+  dbg('Browser startup — connecting native host.');
   connectNativeHost();
 });
 
 // Connect when extension loads
+dbg('Service worker started.');
 connectNativeHost();

package/chrome-extension/manifest.json

@@ -39,7 +39,8 @@
     "storage",
     "tabCapture",
     "windows",
-    "notifications"
+    "notifications",
+    "alarms"
   ],
   "host_permissions": [
     "<all_urls>"