skykoi 2026.3.85 → 2026.3.87

package/assets/chrome-extension/background.js

@@ -1,89 +1,178 @@
-/**
- * SKYKOI Browser Relay — Service Worker (MV3)
- *
- * Handles chrome.debugger API calls. WebSocket to the relay server is maintained
- * by an offscreen document (offscreen.js) for persistent connectivity.
- */
+const DEFAULT_PORT = 18792
 
 const BADGE = {
   on: { text: 'ON', color: '#FF5A36' },
   off: { text: '', color: '#000000' },
-  connecting: { text: '...', color: '#F59E0B' },
+  connecting: { text: '…', color: '#F59E0B' },
   error: { text: '!', color: '#B91C1C' },
 }
 
-let relayConnected = false
-let offscreenPort = null
+/** @type {WebSocket|null} */
+let relayWs = null
+/** @type {Promise<void>|null} */
+let relayConnectPromise = null
+
 let debuggerListenersInstalled = false
+
 let nextSession = 1
 
-/** @type {Map<number, {state:'connecting'|'connected', sessionId?:string, targetId?:string}>} */
+/** @type {Map<number, {state:'connecting'|'connected', sessionId?:string, targetId?:string, attachOrder?:number}>} */
 const tabs = new Map()
 /** @type {Map<string, number>} */
 const tabBySession = new Map()
 /** @type {Map<string, number>} */
 const childSessionToTab = new Map()
+
 /** @type {Map<number, {resolve:(v:any)=>void, reject:(e:Error)=>void}>} */
 const pending = new Map()
 
-// ---------------------------------------------------------------------------
-// Offscreen document lifecycle
-// ---------------------------------------------------------------------------
+function nowStack() {
+  try {
+    return new Error().stack || ''
+  } catch {
+    return ''
+  }
+}
 
-async function ensureOffscreen() {
-  const contexts = await chrome.runtime.getContexts({
-    contextTypes: ['OFFSCREEN_DOCUMENT'],
-  }).catch(() => [])
-  if (contexts.length > 0) return
+async function getRelayPort() {
+  const stored = await chrome.storage.local.get(['relayPort'])
+  const raw = stored.relayPort
+  const n = Number.parseInt(String(raw || ''), 10)
+  if (!Number.isFinite(n) || n <= 0 || n > 65535) return DEFAULT_PORT
+  return n
+}
 
-  await chrome.offscreen.createDocument({
-    url: 'offscreen.html',
-    reasons: [chrome.offscreen.Reason.BLOBS],
-    justification: 'Persistent WebSocket to SKYKOI relay server',
-  })
+function setBadge(tabId, kind) {
+  const cfg = BADGE[kind]
+  void chrome.action.setBadgeText({ tabId, text: cfg.text })
+  void chrome.action.setBadgeBackgroundColor({ tabId, color: cfg.color })
+  void chrome.action.setBadgeTextColor({ tabId, color: '#FFFFFF' }).catch(() => {})
 }
 
-function ensureOffscreenPort() {
-  if (offscreenPort) return
-  offscreenPort = chrome.runtime.connect({ name: 'skykoi-relay' })
-  offscreenPort.onMessage.addListener(onOffscreenMessage)
-  offscreenPort.onDisconnect.addListener(() => {
-    offscreenPort = null
-    relayConnected = false
-    onRelayClosed('port-disconnected')
-    // Recreate after brief delay
-    setTimeout(() => { void ensureOffscreen().then(ensureOffscreenPort) }, 2000)
-  })
+async function ensureRelayConnection() {
+  if (relayWs && relayWs.readyState === WebSocket.OPEN) return
+  if (relayConnectPromise) return await relayConnectPromise
+
+  relayConnectPromise = (async () => {
+    const port = await getRelayPort()
+    const httpBase = `http://127.0.0.1:${port}`
+    const wsUrl = `ws://127.0.0.1:${port}/extension`
+
+    // Fast preflight: is the relay server up?
+    try {
+      await fetch(`${httpBase}/`, { method: 'HEAD', signal: AbortSignal.timeout(2000) })
+    } catch (err) {
+      throw new Error(`Relay server not reachable at ${httpBase} (${String(err)})`)
+    }
+
+    const ws = new WebSocket(wsUrl)
+    relayWs = ws
+
+    await new Promise((resolve, reject) => {
+      const t = setTimeout(() => reject(new Error('WebSocket connect timeout')), 5000)
+      ws.onopen = () => {
+        clearTimeout(t)
+        resolve()
+      }
+      ws.onerror = () => {
+        clearTimeout(t)
+        reject(new Error('WebSocket connect failed'))
+      }
+      ws.onclose = (ev) => {
+        clearTimeout(t)
+        reject(new Error(`WebSocket closed (${ev.code} ${ev.reason || 'no reason'})`))
+      }
+    })
+
+    ws.onmessage = (event) => void onRelayMessage(String(event.data || ''))
+    ws.onclose = () => onRelayClosed('closed')
+    ws.onerror = () => onRelayClosed('error')
+
+    if (!debuggerListenersInstalled) {
+      debuggerListenersInstalled = true
+      chrome.debugger.onEvent.addListener(onDebuggerEvent)
+      chrome.debugger.onDetach.addListener(onDebuggerDetach)
+    }
+  })()
+
+  try {
+    await relayConnectPromise
+  } finally {
+    relayConnectPromise = null
+  }
 }
 
-function sendToRelay(payload) {
-  if (!offscreenPort || !relayConnected) throw new Error('Relay not connected')
-  offscreenPort.postMessage(payload)
+function onRelayClosed(reason) {
+  relayWs = null
+  for (const [id, p] of pending.entries()) {
+    pending.delete(id)
+    p.reject(new Error(`Relay disconnected (${reason})`))
+  }
+
+  for (const tabId of tabs.keys()) {
+    void chrome.debugger.detach({ tabId }).catch(() => {})
+    setBadge(tabId, 'connecting')
+    void chrome.action.setTitle({
+      tabId,
+      title: 'SKYKOI Browser Relay: disconnected (click to re-attach)',
+    })
+  }
+  tabs.clear()
+  tabBySession.clear()
+  childSessionToTab.clear()
 }
 
-// ---------------------------------------------------------------------------
-// Messages from offscreen document
-// ---------------------------------------------------------------------------
+function sendToRelay(payload) {
+  const ws = relayWs
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    throw new Error('Relay not connected')
+  }
+  ws.send(JSON.stringify(payload))
+}
 
-function onOffscreenMessage(msg) {
-  if (!msg) return
+async function maybeOpenHelpOnce() {
+  try {
+    const stored = await chrome.storage.local.get(['helpOnErrorShown'])
+    if (stored.helpOnErrorShown === true) return
+    await chrome.storage.local.set({ helpOnErrorShown: true })
+    await chrome.runtime.openOptionsPage()
+  } catch {
+    // ignore
+  }
+}
 
-  // Relay status updates
-  if (msg.type === 'relay-status') {
-    const wasConnected = relayConnected
-    relayConnected = msg.connected
-    if (msg.connected && !wasConnected) {
-      console.log('[bg] Relay connected via offscreen')
-      void autoAttachAllTabs()
+function requestFromRelay(command) {
+  const id = command.id
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject })
+    try {
+      sendToRelay(command)
+    } catch (err) {
+      pending.delete(id)
+      reject(err instanceof Error ? err : new Error(String(err)))
     }
-    if (!msg.connected && wasConnected) {
-      onRelayClosed('relay-disconnected')
+  })
+}
+
+async function onRelayMessage(text) {
+  /** @type {any} */
+  let msg
+  try {
+    msg = JSON.parse(text)
+  } catch {
+    return
+  }
+
+  if (msg && msg.method === 'ping') {
+    try {
+      sendToRelay({ method: 'pong' })
+    } catch {
+      // ignore
     }
     return
   }
 
-  // Response to a pending CDP command
-  if (typeof msg.id === 'number' && (msg.result !== undefined || msg.error !== undefined)) {
+  if (msg && typeof msg.id === 'number' && (msg.result !== undefined || msg.error !== undefined)) {
     const p = pending.get(msg.id)
     if (!p) return
     pending.delete(msg.id)
@@ -92,50 +181,32 @@ function onOffscreenMessage(msg) {
     return
   }
 
-  // CDP command forwarded from relay
-  if (typeof msg.id === 'number' && msg.method === 'forwardCDPCommand') {
-    void (async () => {
-      try {
-        const result = await handleForwardCdpCommand(msg)
-        sendToRelay({ id: msg.id, result })
-      } catch (err) {
-        sendToRelay({ id: msg.id, error: err instanceof Error ? err.message : String(err) })
-      }
-    })()
+  if (msg && typeof msg.id === 'number' && msg.method === 'forwardCDPCommand') {
+    try {
+      const result = await handleForwardCdpCommand(msg)
+      sendToRelay({ id: msg.id, result })
+    } catch (err) {
+      sendToRelay({ id: msg.id, error: err instanceof Error ? err.message : String(err) })
+    }
   }
 }
 
-// ---------------------------------------------------------------------------
-// Badge & relay disconnect
-// ---------------------------------------------------------------------------
-
-function setBadge(tabId, kind) {
-  const cfg = BADGE[kind]
-  void chrome.action.setBadgeText({ tabId, text: cfg.text })
-  void chrome.action.setBadgeBackgroundColor({ tabId, color: cfg.color })
-  void chrome.action.setBadgeTextColor({ tabId, color: '#FFFFFF' }).catch(() => {})
+function getTabBySessionId(sessionId) {
+  const direct = tabBySession.get(sessionId)
+  if (direct) return { tabId: direct, kind: 'main' }
+  const child = childSessionToTab.get(sessionId)
+  if (child) return { tabId: child, kind: 'child' }
+  return null
 }
 
-function onRelayClosed(reason) {
-  for (const [id, p] of pending.entries()) {
-    pending.delete(id)
-    p.reject(new Error(`Relay disconnected (${reason})`))
+function getTabByTargetId(targetId) {
+  for (const [tabId, tab] of tabs.entries()) {
+    if (tab.targetId === targetId) return tabId
   }
-  for (const tabId of tabs.keys()) {
-    void chrome.debugger.detach({ tabId }).catch(() => {})
-    setBadge(tabId, 'off')
-  }
-  tabs.clear()
-  tabBySession.clear()
-  childSessionToTab.clear()
+  return null
 }
 
-// ---------------------------------------------------------------------------
-// Tab attach / detach
-// ---------------------------------------------------------------------------
-
-async function attachTab(tabId) {
-  if (tabs.has(tabId)) return
+async function attachTab(tabId, opts = {}) {
   const debuggee = { tabId }
   await chrome.debugger.attach(debuggee, '1.3')
   await chrome.debugger.sendCommand(debuggee, 'Page.enable').catch(() => {})
@@ -143,21 +214,36 @@ async function attachTab(tabId) {
   const info = /** @type {any} */ (await chrome.debugger.sendCommand(debuggee, 'Target.getTargetInfo'))
   const targetInfo = info?.targetInfo
   const targetId = String(targetInfo?.targetId || '').trim()
-  if (!targetId) throw new Error('No targetId')
+  if (!targetId) {
+    throw new Error('Target.getTargetInfo returned no targetId')
+  }
 
   const sessionId = `cb-tab-${nextSession++}`
-  tabs.set(tabId, { state: 'connected', sessionId, targetId })
-  tabBySession.set(sessionId, tabId)
+  const attachOrder = nextSession
 
-  sendToRelay({
-    method: 'forwardCDPEvent',
-    params: {
-      method: 'Target.attachedToTarget',
-      params: { sessionId, targetInfo: { ...targetInfo, attached: true }, waitingForDebugger: false },
-    },
+  tabs.set(tabId, { state: 'connected', sessionId, targetId, attachOrder })
+  tabBySession.set(sessionId, tabId)
+  void chrome.action.setTitle({
+    tabId,
+    title: 'SKYKOI Browser Relay: attached (click to detach)',
   })
+
+  if (!opts.skipAttachedEvent) {
+    sendToRelay({
+      method: 'forwardCDPEvent',
+      params: {
+        method: 'Target.attachedToTarget',
+        params: {
+          sessionId,
+          targetInfo: { ...targetInfo, attached: true },
+          waitingForDebugger: false,
+        },
+      },
+    })
+  }
+
   setBadge(tabId, 'on')
-  void chrome.action.setTitle({ tabId, title: 'SKYKOI: attached' })
+  return { sessionId, targetId }
 }
 
 async function detachTab(tabId, reason) {
@@ -166,30 +252,69 @@ async function detachTab(tabId, reason) {
     try {
       sendToRelay({
         method: 'forwardCDPEvent',
-        params: { method: 'Target.detachedFromTarget', params: { sessionId: tab.sessionId, targetId: tab.targetId, reason } },
+        params: {
+          method: 'Target.detachedFromTarget',
+          params: { sessionId: tab.sessionId, targetId: tab.targetId, reason },
+        },
       })
-    } catch { /* ignore */ }
+    } catch {
+      // ignore
+    }
   }
+
   if (tab?.sessionId) tabBySession.delete(tab.sessionId)
   tabs.delete(tabId)
-  for (const [s, t] of childSessionToTab.entries()) { if (t === tabId) childSessionToTab.delete(s) }
-  void chrome.debugger.detach({ tabId }).catch(() => {})
+
+  for (const [childSessionId, parentTabId] of childSessionToTab.entries()) {
+    if (parentTabId === tabId) childSessionToTab.delete(childSessionId)
+  }
+
+  try {
+    await chrome.debugger.detach({ tabId })
+  } catch {
+    // ignore
+  }
+
   setBadge(tabId, 'off')
-  void chrome.action.setTitle({ tabId, title: 'SKYKOI Browser Relay' })
+  void chrome.action.setTitle({
+    tabId,
+    title: 'SKYKOI Browser Relay (click to attach/detach)',
+  })
 }
 
-// ---------------------------------------------------------------------------
-// CDP command handling (from relay via offscreen)
-// ---------------------------------------------------------------------------
+async function connectOrToggleForActiveTab() {
+  const [active] = await chrome.tabs.query({ active: true, currentWindow: true })
+  const tabId = active?.id
+  if (!tabId) return
 
-function getTabBySessionId(sid) {
-  const d = tabBySession.get(sid); if (d) return { tabId: d }
-  const c = childSessionToTab.get(sid); if (c) return { tabId: c }
-  return null
-}
-function getTabByTargetId(tid) {
-  for (const [id, t] of tabs.entries()) { if (t.targetId === tid) return id }
-  return null
+  const existing = tabs.get(tabId)
+  if (existing?.state === 'connected') {
+    await detachTab(tabId, 'toggle')
+    return
+  }
+
+  tabs.set(tabId, { state: 'connecting' })
+  setBadge(tabId, 'connecting')
+  void chrome.action.setTitle({
+    tabId,
+    title: 'SKYKOI Browser Relay: connecting to local relay…',
+  })
+
+  try {
+    await ensureRelayConnection()
+    await attachTab(tabId)
+  } catch (err) {
+    tabs.delete(tabId)
+    setBadge(tabId, 'error')
+    void chrome.action.setTitle({
+      tabId,
+      title: 'SKYKOI Browser Relay: relay not running (open options for setup)',
+    })
+    void maybeOpenHelpOnce()
+    // Extra breadcrumbs in chrome://extensions service worker logs.
+    const message = err instanceof Error ? err.message : String(err)
+    console.warn('attach failed', message, nowStack())
+  }
 }
 
 async function handleForwardCdpCommand(msg) {
@@ -197,131 +322,117 @@ async function handleForwardCdpCommand(msg) {
   const params = msg?.params?.params || undefined
   const sessionId = typeof msg?.params?.sessionId === 'string' ? msg.params.sessionId : undefined
 
+  // Map command to tab
   const bySession = sessionId ? getTabBySessionId(sessionId) : null
   const targetId = typeof params?.targetId === 'string' ? params.targetId : undefined
-  const tabId = bySession?.tabId
-    || (targetId ? getTabByTargetId(targetId) : null)
-    || (() => { for (const [id, t] of tabs.entries()) { if (t.state === 'connected') return id } return null })()
-  if (!tabId) throw new Error(`No attached tab for ${method}`)
+  const tabId =
+    bySession?.tabId ||
+    (targetId ? getTabByTargetId(targetId) : null) ||
+    (() => {
+      // No sessionId: pick the first connected tab (stable-ish).
+      for (const [id, tab] of tabs.entries()) {
+        if (tab.state === 'connected') return id
+      }
+      return null
+    })()
 
+  if (!tabId) throw new Error(`No attached tab for method ${method}`)
+
+  /** @type {chrome.debugger.DebuggerSession} */
   const debuggee = { tabId }
 
   if (method === 'Runtime.enable') {
-    await chrome.debugger.sendCommand(debuggee, 'Runtime.disable').catch(() => {})
-    await new Promise(r => setTimeout(r, 50))
+    try {
+      await chrome.debugger.sendCommand(debuggee, 'Runtime.disable')
+      await new Promise((r) => setTimeout(r, 50))
+    } catch {
+      // ignore
+    }
     return await chrome.debugger.sendCommand(debuggee, 'Runtime.enable', params)
   }
+
   if (method === 'Target.createTarget') {
     const url = typeof params?.url === 'string' ? params.url : 'about:blank'
     const tab = await chrome.tabs.create({ url, active: false })
     if (!tab.id) throw new Error('Failed to create tab')
-    await new Promise(r => setTimeout(r, 100))
-    await attachTab(tab.id)
-    const t = tabs.get(tab.id)
-    return { targetId: t?.targetId }
+    await new Promise((r) => setTimeout(r, 100))
+    const attached = await attachTab(tab.id)
+    return { targetId: attached.targetId }
   }
+
   if (method === 'Target.closeTarget') {
-    const tid = typeof params?.targetId === 'string' ? params.targetId : ''
-    const toClose = tid ? getTabByTargetId(tid) : tabId
+    const target = typeof params?.targetId === 'string' ? params.targetId : ''
+    const toClose = target ? getTabByTargetId(target) : tabId
     if (!toClose) return { success: false }
-    await chrome.tabs.remove(toClose).catch(() => {})
+    try {
+      await chrome.tabs.remove(toClose)
+    } catch {
+      return { success: false }
+    }
     return { success: true }
   }
+
   if (method === 'Target.activateTarget') {
-    const tid = typeof params?.targetId === 'string' ? params.targetId : ''
-    const toFocus = tid ? getTabByTargetId(tid) : tabId
-    if (toFocus) {
-      const tab = await chrome.tabs.get(toFocus).catch(() => null)
-      if (tab?.windowId) await chrome.windows.update(tab.windowId, { focused: true }).catch(() => {})
-      await chrome.tabs.update(toFocus, { active: true }).catch(() => {})
+    const target = typeof params?.targetId === 'string' ? params.targetId : ''
+    const toActivate = target ? getTabByTargetId(target) : tabId
+    if (!toActivate) return {}
+    const tab = await chrome.tabs.get(toActivate).catch(() => null)
+    if (!tab) return {}
+    if (tab.windowId) {
+      await chrome.windows.update(tab.windowId, { focused: true }).catch(() => {})
     }
+    await chrome.tabs.update(toActivate, { active: true }).catch(() => {})
     return {}
   }
 
   const tabState = tabs.get(tabId)
-  const mainSid = tabState?.sessionId
-  const debuggerSession = (sessionId && mainSid && sessionId !== mainSid) ? { ...debuggee, sessionId } : debuggee
+  const mainSessionId = tabState?.sessionId
+  const debuggerSession =
+    sessionId && mainSessionId && sessionId !== mainSessionId
+      ? { ...debuggee, sessionId }
+      : debuggee
+
   return await chrome.debugger.sendCommand(debuggerSession, method, params)
 }
 
-// ---------------------------------------------------------------------------
-// Debugger event forwarding
-// ---------------------------------------------------------------------------
-
-function installDebuggerListeners() {
-  if (debuggerListenersInstalled) return
-  debuggerListenersInstalled = true
-
-  chrome.debugger.onEvent.addListener((source, method, params) => {
-    const tabId = source.tabId; if (!tabId) return
-    const tab = tabs.get(tabId); if (!tab?.sessionId) return
-    if (method === 'Target.attachedToTarget' && params?.sessionId) childSessionToTab.set(String(params.sessionId), tabId)
-    if (method === 'Target.detachedFromTarget' && params?.sessionId) childSessionToTab.delete(String(params.sessionId))
-    try {
-      sendToRelay({ method: 'forwardCDPEvent', params: { sessionId: source.sessionId || tab.sessionId, method, params } })
-    } catch { /* ignore */ }
-  })
+function onDebuggerEvent(source, method, params) {
+  const tabId = source.tabId
+  if (!tabId) return
+  const tab = tabs.get(tabId)
+  if (!tab?.sessionId) return
 
-  chrome.debugger.onDetach.addListener((source, reason) => {
-    if (source.tabId && tabs.has(source.tabId)) void detachTab(source.tabId, reason)
-  })
-}
+  if (method === 'Target.attachedToTarget' && params?.sessionId) {
+    childSessionToTab.set(String(params.sessionId), tabId)
+  }
 
-// ---------------------------------------------------------------------------
-// Auto-attach: seamlessly attach to all tabs
-// ---------------------------------------------------------------------------
+  if (method === 'Target.detachedFromTarget' && params?.sessionId) {
+    childSessionToTab.delete(String(params.sessionId))
+  }
 
-async function autoAttachTab(tabId) {
-  if (tabs.has(tabId)) return
-  if (!relayConnected) return
   try {
-    installDebuggerListeners()
-    await attachTab(tabId)
-  } catch { /* silently skip unattachable tabs */ }
-}
-
-async function autoAttachAllTabs() {
-  if (!relayConnected) return
-  installDebuggerListeners()
-  const allTabs = await chrome.tabs.query({})
-  for (const tab of allTabs) {
-    if (tab.id && tab.url && !tab.url.startsWith('chrome://') && !tab.url.startsWith('chrome-extension://') && !tab.url.startsWith('devtools://')) {
-      void autoAttachTab(tab.id)
-    }
+    sendToRelay({
+      method: 'forwardCDPEvent',
+      params: {
+        sessionId: source.sessionId || tab.sessionId,
+        method,
+        params,
+      },
+    })
+  } catch {
+    // ignore
   }
 }
 
-// Auto-attach on tab events
-chrome.tabs.onUpdated.addListener((tabId, info, tab) => {
-  if (info.status === 'complete' && tab.url && !tab.url.startsWith('chrome://')) void autoAttachTab(tabId)
-})
-chrome.tabs.onActivated.addListener(({ tabId }) => void autoAttachTab(tabId))
-
-// Manual toggle
-chrome.action.onClicked.addListener(async () => {
-  const [active] = await chrome.tabs.query({ active: true, currentWindow: true })
-  if (!active?.id) return
-  if (tabs.has(active.id)) { await detachTab(active.id, 'toggle') }
-  else { void autoAttachTab(active.id) }
-})
-
-// ---------------------------------------------------------------------------
-// Startup: create offscreen document and connect
-// ---------------------------------------------------------------------------
-
-async function init() {
-  await ensureOffscreen()
-  ensureOffscreenPort()
+function onDebuggerDetach(source, reason) {
+  const tabId = source.tabId
+  if (!tabId) return
+  if (!tabs.has(tabId)) return
+  void detachTab(tabId, reason)
 }
 
-chrome.runtime.onStartup.addListener(() => void init())
-chrome.runtime.onInstalled.addListener(() => void init())
+chrome.action.onClicked.addListener(() => void connectOrToggleForActiveTab())
 
-// Keepalive alarm to ensure offscreen doc stays alive
-chrome.alarms.create('skykoi-keepalive', { periodInMinutes: 0.5 })
-chrome.alarms.onAlarm.addListener((alarm) => {
-  if (alarm.name === 'skykoi-keepalive') void init()
+chrome.runtime.onInstalled.addListener(() => {
+  // Useful: first-time instructions.
+  void chrome.runtime.openOptionsPage()
 })
-
-// Fire immediately
-void init()

package/assets/chrome-extension/manifest.json

@@ -1,17 +1,17 @@
 {
   "manifest_version": 3,
   "name": "SKYKOI Browser Relay",
-  "version": "0.2.0",
-  "description": "Attach SKYKOI to your existing Chrome tabs via a local CDP relay server.",
+  "version": "0.1.0",
+  "description": "Attach SKYKOI to your existing Chrome tab via a local CDP relay server.",
   "icons": {
     "16": "icons/icon16.png",
     "32": "icons/icon32.png",
     "48": "icons/icon48.png",
     "128": "icons/icon128.png"
   },
-  "permissions": ["debugger", "tabs", "activeTab", "storage", "alarms", "offscreen"],
+  "permissions": ["debugger", "tabs", "activeTab", "storage"],
   "host_permissions": ["http://127.0.0.1/*", "http://localhost/*"],
-  "background": { "service_worker": "background.js" },
+  "background": { "service_worker": "background.js", "type": "module" },
   "action": {
     "default_title": "SKYKOI Browser Relay (click to attach/detach)",
     "default_icon": {