background.js

/**
 * Background service worker.
 */

const HITOMI_REFERER_RULE_ID = 1001;
const NHENTAI_CORS_RULE_ID = 1002;

function installNetworkRules() {
  if (!chrome.declarativeNetRequest || typeof chrome.declarativeNetRequest.updateDynamicRules !== 'function') {
    return;
  }

  const hitomiRefererRule = {
    id: HITOMI_REFERER_RULE_ID,
    priority: 1,
    action: {
      type: 'modifyHeaders',
      requestHeaders: [
        {
          header: 'referer',
          operation: 'set',
          value: 'https://hitomi.la/'
        }
      ]
    },
    condition: {
      urlFilter: '||gold-usergeneratedcontent.net/',
      initiatorDomains: ['hitomi.la'],
      resourceTypes: ['image']
    }
  };

  const nhentaiCorsRule = {
    id: NHENTAI_CORS_RULE_ID,
    priority: 1,
    action: {
      type: 'modifyHeaders',
      responseHeaders: [
        {
          header: 'access-control-allow-origin',
          operation: 'set',
          value: '*'
        },
        {
          header: 'access-control-expose-headers',
          operation: 'set',
          value: 'content-length, content-type'
        }
      ]
    },
    condition: {
      urlFilter: '||nhentai.net/galleries/',
      initiatorDomains: ['nhentai.net'],
      resourceTypes: ['xmlhttprequest']
    }
  };

  try {
    chrome.declarativeNetRequest.updateDynamicRules({
      removeRuleIds: [HITOMI_REFERER_RULE_ID, NHENTAI_CORS_RULE_ID],
      addRules: [hitomiRefererRule, nhentaiCorsRule]
    }, () => {
      const lastError = chrome.runtime && chrome.runtime.lastError;
      if (lastError) {
        console.warn('[Gallery Reader] failed to install network rules:', lastError.message);
      }
    });
  } catch (error) {
    console.warn('[Gallery Reader] failed to install network rules:', error);
  }
}

chrome.runtime.onInstalled.addListener((details) => {
  installNetworkRules();
  if (details.reason === 'install') {
    console.log('[Gallery Reader] installed');
    chrome.tabs.create({ url: 'welcome.html' });
  } else if (details.reason === 'update') {
    console.log('[Gallery Reader] updated');
  }
});

chrome.runtime.onStartup.addListener(() => {
  installNetworkRules();
});

installNetworkRules();

async function fetchAllowedText(url) {
  const parsed = new URL(url);
  const host = parsed.hostname.toLowerCase();
  const allowed =
    host === 'hitomi.la' ||
    host.endsWith('.hitomi.la') ||
    host === 'gold-usergeneratedcontent.net' ||
    host.endsWith('.gold-usergeneratedcontent.net');

  if (!allowed) {
    throw new Error(`Blocked fetch host: ${host}`);
  }

  const response = await fetch(parsed.href, {
    method: 'GET',
    credentials: 'omit',
    cache: 'no-store'
  });

  const text = await response.text();
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${text.slice(0, 160)}`);
  }

  return text;
}

chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.action === 'ensureReaderContentScript') {
    const tabId = sender && sender.tab && sender.tab.id;
    const frameId = sender && typeof sender.frameId === 'number' ? sender.frameId : 0;

    if (typeof tabId !== 'number') {
      sendResponse({ success: false, error: 'No sender tab available' });
      return false;
    }

    if (!chrome.scripting || typeof chrome.scripting.executeScript !== 'function') {
      sendResponse({ success: false, error: 'chrome.scripting is unavailable' });
      return false;
    }

    try {
      const injection = chrome.scripting.executeScript({
        target: { tabId, frameIds: [frameId] },
        files: ['i18n.js', 'reader-shell.js', 'reader-prefetch.js', 'content.js']
      });

      if (injection && typeof injection.then === 'function') {
        injection
          .then(() => sendResponse({ success: true }))
          .catch((error) => {
            sendResponse({
              success: false,
              error: error && error.message ? error.message : String(error)
            });
          });
        return true;
      }

      sendResponse({ success: true });
    } catch (error) {
      sendResponse({
        success: false,
        error: error && error.message ? error.message : String(error)
      });
    }
    return true;
  }

  if (request.action === 'fetchHitomiText') {
    fetchAllowedText(request.url)
      .then((text) => sendResponse({ success: true, text }))
      .catch((error) => {
        sendResponse({
          success: false,
          error: error && error.message ? error.message : String(error)
        });
      });
    return true;
  }

  if (request.action === 'getSettings') {
    chrome.storage.sync.get(['readerSettings'], (result) => {
      sendResponse(result.readerSettings || {});
    });
    return true;
  }

  if (request.action === 'saveSettings') {
    chrome.storage.sync.set({ readerSettings: request.settings }, () => {
      sendResponse({ success: true });
    });
    return true;
  }
});