assist/background.js

var tempData = null
var openList = {}
// 从 storage 中读取数据
chrome.storage.local.get(['owoOpenList'], (result) => {
  if (result.owoOpenList) {
    openList = result.owoOpenList
  }
})

// 保存到 storage 中
function saveOpenList() {
  chrome.storage.local.set({ owoOpenList: openList })
}



// 对数据进行处理
function clearData (data) {
  let returnData = []
  data.forEach(element => {
    if (openList[element.id] || element.type == 'autoRun') {
      returnData.push(element)
    }
  })
  return returnData
}

function reGetData (url, callBack) {
  const nowTime = Date.parse(new Date())
  const serverUrl = 'https://assist.lamp.run/assistAll'
  fetch(`${serverUrl}`, {
    method: 'POST',
    body: JSON.stringify({
      "edition": 7,
      "url": url
    }),
    redirect: 'follow'
  }).then(data => data.json()).then(dataTemp => {
    
    tempData = {
      time: nowTime,
      data: dataTemp
    }
    if (callBack) callBack(dataTemp)
  })
}

function handleFetchRequest(url, options) {
  return new Promise((resolve, reject) => {
    fetch(url, options)
      .then(async response => {
        try {
          const contentType = response.headers.get('content-type');
          let data;
          
          if (contentType && contentType.includes('application/json')) {
            data = await response.json();
          } else {
            data = await response.text();
          }
          
          resolve({
            ok: response.ok,
            status: response.status,
            statusText: response.statusText,
            headers: Object.fromEntries(response.headers.entries()),
            data: data,
            url: response.url
          });
        } catch (error) {
          reject({
            error: '解析响应失败',
            details: error.message,
            status: response.status
          });
        }
      })
      .catch(error => {
        reject({
          error: '请求失败',
          details: error.message,
          type: error.name
        });
      });
  });
}



// 监听消息
chrome.runtime.onMessage.addListener(function(message, sender, sendResponse) {
  // console.log(message)
  switch (message.name) {
    case 'getData':
      const nowTime = Date.parse(new Date())
      // 缓存
      if (tempData && (tempData.time + 60 * 60 * 1000) > nowTime) {
        console.log('使用缓存返回!', tempData)
        sendResponse(clearData(tempData.data))
      } else {
        reGetData(message.url, (dataTemp) => {
          sendResponse(clearData(dataTemp))
        })
      }
      break;
    case 'fetch':  // 新增的 fetch 处理方法
      const { url, options = {} } = message;
      handleFetchRequest(url, options)
        .then(result => {
          sendResponse({
            success: true,
            ...result
          });
        })
        .catch(error => {
          sendResponse({
            success: false,
            error: error
          });
        });
      break;
    default:
      break;
  }
  return true
})


// 在文件开头添加调试
console.log('Background service worker 启动');
console.log('Manifest 权限:', chrome.runtime.getManifest().permissions);
console.log('declarativeNetRequest API:', chrome.declarativeNetRequest);

// 初始化加载拦截规则
function initBlockList() {
  fetch(`https://assist.lamp.run/blockList`)
    .then(response => {
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      return response.json();
    })
    .then(dataTemp => {
      console.log('获取到拦截规则:', dataTemp);
      blockListTemp = dataTemp;
      return lanjie(dataTemp);
    })
    .catch(error => {
      console.error('获取拦截规则失败:', error);
      // 设置空的拦截规则
      blockListTemp = {};
      lanjie({});
    });
}

// 插件安装/更新时初始化
chrome.runtime.onInstalled.addListener(() => {
  console.log('插件已安装/更新');
  initBlockList();
});

// 插件启动时也初始化
initBlockList();

async function lanjie(blockList) {
  // 先检查 API 是否可用
  if (!chrome.declarativeNetRequest || !chrome.declarativeNetRequest.updateDynamicRules) {
    console.error('declarativeNetRequest API 不可用，请检查 manifest.json 配置');
    
    // 重新检查权限
    chrome.management.getSelf((extensionInfo) => {
      console.log('插件权限信息:', extensionInfo.permissions);
    });
    
    return;
  }
  
  console.log('开始设置拦截规则...');
  
  const rules = [];
  let id = 1000; // 使用较大的ID避免冲突
  
  for (const [url, redirect] of Object.entries(blockList)) {
    rules.push({
      id: id++,
      priority: 1,
      action: { 
        type: 'redirect', 
        redirect: { url: redirect } 
      },
      condition: { 
        urlFilter: url,
        resourceTypes: ['main_frame', 'sub_frame', 'xmlhttprequest', 'script'] 
      }
    });
  }
  
  try {
    // 先获取现有规则
    const oldRules = await chrome.declarativeNetRequest.getDynamicRules();
    console.log('现有规则数量:', oldRules.length);
    
    // 移除所有现有规则
    const oldIds = oldRules.map(rule => rule.id);
    if (oldIds.length > 0) {
      await chrome.declarativeNetRequest.updateDynamicRules({
        removeRuleIds: oldIds
      });
      console.log(`移除 ${oldIds.length} 条旧规则`);
    }
    
    // 添加新规则
    if (rules.length > 0) {
      await chrome.declarativeNetRequest.updateDynamicRules({
        addRules: rules
      });
      console.log(`添加 ${rules.length} 条新规则成功`);
    }
    
  } catch (error) {
    console.error('更新规则失败:', error);
    
    // 调试信息
    console.log('当前插件 manifest:', chrome.runtime.getManifest());
    console.log('API 支持状态:', {
      declarativeNetRequest: !!chrome.declarativeNetRequest,
      updateDynamicRules: !!chrome.declarativeNetRequest?.updateDynamicRules,
      getDynamicRules: !!chrome.declarativeNetRequest?.getDynamicRules
    });
  }
}


chrome.runtime.onMessageExternal.addListener(
  function(request, sender, sendResponse) {
    console.log(request)
    switch (request.name) {
      case 'sendMessage':
        var myHeaders = new Headers();
        myHeaders.append("Content-Type", "application/json");

        var raw = JSON.stringify({
          "first": {
            "value": "插件提示",
            "color": "#173177"
          },
          "keyword1": {
            "value": request.keyword1,
            "color": "#173177"
          },
          "keyword2": {
            "value": request.keyword1,
            "color": "#173177"
          },
          "keyword3": {
            "value": (new Date()).toLocaleString(),
            "color": "#173177"
          },
          "remark": {
            "value": request.remark,
            "color": "#173177"
          }
        });

        var requestOptions = {
          method: 'POST',
          headers: myHeaders,
          body: raw,
          redirect: 'follow'
        };

        fetch(`https://message.lamp.run/workWeixin?type=${request.type}&template=EvpHwEBpG2rkLHYMtIH2ADww9JCQwEaWlTAqyoPF6xQ`, requestOptions)
          .then(response => response.text())
          .then(result => console.log(result))
          .catch(error => console.log('error', error));
      case 'notifications':
        chrome.notifications.create(null, {
          type: 'basic',
          iconUrl: 'img/48.png',
          title: request.title,
          message: request.message
        });
      case 'playMusic':
        let musicUrl = request.url ? request.url : 'https://cunchu.site/work/assist/lingyin.wav'
        new Audio(musicUrl).play()
        default:
          break;
    }
    sendResponse('ok')
  }
);


// function logResponse(responseDetails) {
//   console.log(responseDetails);
// }

// chrome.webRequest.onCompleted.addListener(
//   logResponse,
//   {urls: ["<all_urls>"]}
// );