background.js

const RULE_ID = 1;
const RULE_TYPES = [
  "main_frame",
  "sub_frame",
  "xmlhttprequest",
  "script",
  "image",
  "stylesheet",
  "font",
  "media",
  "ping",
  "object",
  "other"
];

const defaults = {
  enabled: true,
  lang: "auto",
  activeGroupId: "default",
  groups: [
    {
      id: "default",
      name: "debug",
      headers: [{ name: "", value: "" }]
    }
  ]
};
const HEADER_NAME_RE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
const LANGS = ["auto", "en", "zh"];

chrome.runtime.onInstalled.addListener(async () => {
  await saveState(await getState());
  await applyActiveGroup();
});

chrome.runtime.onStartup.addListener(applyActiveGroup);

chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
  (async () => {
    if (message?.type === "saveState") {
      await saveState(message.state);
      await applyActiveGroup();
    }
    sendResponse(await getState());
  })();
  return true;
});

async function getState() {
  const state = await chrome.storage.local.get(defaults);
  const groups = normalizeGroups(state.groups);
  const activeGroupId = groups.some(group => group.id === state.activeGroupId) ? state.activeGroupId : groups[0].id;
  return {
    enabled: state.enabled !== false,
    lang: normalizeLang(state.lang),
    activeGroupId,
    groups
  };
}

async function saveState(next) {
  await chrome.storage.local.set({
    enabled: next.enabled !== false,
    lang: normalizeLang(next.lang),
    activeGroupId: next.activeGroupId,
    groups: normalizeGroups(next.groups)
  });
}

function normalizeGroups(groups) {
  const cleaned = (Array.isArray(groups) ? groups : [])
    .map(group => ({
      id: group.id || crypto.randomUUID(),
      name: String(group.name || "Group").trim().slice(0, 24) || "Group",
      headers: (Array.isArray(group.headers) ? group.headers : [])
        .map(header => ({
          name: String(header.name ?? ""),
          value: String(header.value ?? "")
        }))
    }))
    .filter(group => group.name);
  return cleaned.length ? cleaned : defaults.groups;
}

async function applyActiveGroup() {
  const state = await getState();
  const group = activeGroup(state);
  const headers = group.headers.filter(header => HEADER_NAME_RE.test(header.name));
  const removeRuleIds = [RULE_ID];
  const addRules = state.enabled && headers.length
    ? [
        {
          id: RULE_ID,
          priority: 1,
          action: {
            type: "modifyHeaders",
            requestHeaders: headers.map(header => ({
              header: header.name,
              operation: "set",
              value: header.value
            }))
          },
          condition: {
            urlFilter: "*",
            resourceTypes: RULE_TYPES
          }
        }
      ]
    : [];

  try {
    await chrome.declarativeNetRequest.updateDynamicRules({ removeRuleIds, addRules });
    await chrome.action.setBadgeText({ text: state.enabled ? firstBadgeChar(group.name) : "OFF" });
    await chrome.action.setBadgeBackgroundColor({ color: state.enabled && headers.length ? "#2563eb" : "#64748b" });
  } catch {
    await chrome.declarativeNetRequest.updateDynamicRules({ removeRuleIds });
    await chrome.action.setBadgeText({ text: "!" });
    await chrome.action.setBadgeBackgroundColor({ color: "#dc2626" });
  }
  await chrome.action.setTitle({ title: `HeaderHack: ${state.enabled ? group.name : offText(state.lang)}` });
}

function firstBadgeChar(name) {
  const char = Array.from(String(name || "?").trim())[0] || "?";
  return char;
}

function activeGroup(state) {
  return state.groups.find(group => group.id === state.activeGroupId) || state.groups[0];
}

function normalizeLang(lang) {
  return LANGS.includes(lang) ? lang : "auto";
}

function offText(lang) {
  const locale = lang === "zh" || (lang === "auto" && chrome.i18n.getUILanguage().startsWith("zh")) ? "zh" : "en";
  return locale === "zh" ? "已关闭" : "Off";
}