decant-core 1.0.0

package/ai/chatgpt_helper.js

@@ -0,0 +1,137 @@
+if (!window.__chatgptHelperInjected) {
+  window.__chatgptHelperInjected = true;
+
+  window.capturedAuthStore = window.capturedAuthStore || {
+    authorization: null,
+    extraHeaders: {},
+  };
+
+  function getCookieDeviceId() {
+    try {
+      const match = typeof document !== 'undefined' && document.cookie.match(/oai-did=([^;]+)/);
+      return match ? match[1] : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // Hook fetch to store Authorization and custom headers when page performs network calls
+  if (typeof window !== 'undefined' && window.fetch) {
+    const originalFetch = window.fetch;
+    window.fetch = function (...args) {
+      try {
+        const url = typeof args[0] === 'string' ? args[0] : args[0]?.url;
+        if (url && (url.includes('/backend-api/') || url.includes('/api/auth/'))) {
+          const options = args[1];
+          if (options?.headers) {
+            let auth = null;
+            if (options.headers instanceof Headers) {
+              auth = options.headers.get('Authorization');
+            } else if (typeof options.headers === 'object') {
+              auth = options.headers.Authorization || options.headers.authorization;
+            }
+            if (auth) {
+              window.capturedAuthStore.authorization = auth;
+            }
+          }
+        }
+      } catch {
+        // Ignore interception errors
+      }
+      return originalFetch.apply(this, args);
+    };
+  }
+
+  window.addEventListener('message', async (event) => {
+    if (event.origin !== 'https://chatgpt.com') return;
+    if (event.data?.source !== 'chatgpt-exporter-ext') return;
+    if (event.data?.type !== 'fetch_conversation') return;
+
+    const { convId, token, requestId, includeImages } = event.data;
+
+    try {
+      const headers = {
+        Accept: 'application/json',
+      };
+
+      const authToken = token ? `Bearer ${token}` : window.capturedAuthStore?.authorization;
+      if (authToken) {
+        headers.Authorization = authToken;
+      }
+
+      const deviceId = getCookieDeviceId();
+      if (deviceId) {
+        headers['oai-device-id'] = deviceId;
+      }
+
+      const res = await fetch(`https://chatgpt.com/backend-api/conversation/${convId}`, {
+        headers,
+      });
+      if (!res.ok) throw new Error(`API returned ${res.status}`);
+      const data = await res.json();
+
+      let images = {};
+      if (includeImages) {
+        const fileIds = new Set();
+        for (const node of Object.values(data.mapping)) {
+          const msg = node.message;
+          if (msg && msg.content && Array.isArray(msg.content.parts)) {
+            for (const part of msg.content.parts) {
+              if (part && part.content_type === 'image_asset_pointer' && part.asset_pointer) {
+                fileIds.add(part.asset_pointer.split('://')[1]);
+              }
+            }
+          }
+        }
+
+        const entries = await Promise.all(
+          [...fileIds].map(async (id) => {
+            try {
+              const b64 = await fetchImageAsBase64(id, token);
+              return [id, b64];
+            } catch (e) {
+              console.error('[AI Exporter] Error fetching image:', id, e);
+              return [id, null];
+            }
+          }),
+        );
+        images = Object.fromEntries(entries.filter(([, b64]) => b64 !== null));
+      }
+
+      window.postMessage(
+        { source: 'chatgpt-exporter-page', requestId, data, images },
+        'https://chatgpt.com',
+      );
+    } catch (err) {
+      window.postMessage(
+        { source: 'chatgpt-exporter-page', requestId, error: err.message },
+        'https://chatgpt.com',
+      );
+    }
+  });
+
+  async function fetchImageAsBase64(fileId, token) {
+    try {
+      const dlRes = await fetch(`https://chatgpt.com/backend-api/files/download/${fileId}`, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      if (!dlRes.ok) return null;
+      const { download_url } = await dlRes.json();
+      if (!download_url) return null;
+
+      const imgRes = await fetch(download_url);
+      if (!imgRes.ok) return null;
+
+      const blob = await imgRes.blob();
+      return await new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = () => resolve(null);
+        reader.readAsDataURL(blob);
+      });
+    } catch (e) {
+      console.error('[AI Exporter] fetchImageAsBase64 error:', e);
+      return null;
+    }
+  }
+}

package/ai/chatgpt_scroll_collector.js

@@ -0,0 +1,193 @@
+const TURN_SELECTOR =
+  'article, [data-testid^="conversation-turn-"], section[data-turn-id], [data-message-author-role]';
+const DEFAULT_RENDER_WAIT_MS = 160;
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isScrollable(element) {
+  return element && element.scrollHeight > element.clientHeight + 80;
+}
+
+function messageKey(message) {
+  if (message.key) return message.key;
+  return `${message.role}:${message.content.replace(/\s+/g, ' ').trim()}`;
+}
+
+function publicMessage(message) {
+  return {
+    role: message.role,
+    content: message.content,
+  };
+}
+
+export function getConversationTurnIndex(turn) {
+  if (!turn || typeof turn.getAttribute !== 'function') return Number.POSITIVE_INFINITY;
+  const testId = turn.getAttribute('data-testid') || '';
+  const match = testId.match(/^conversation-turn-(\d+)$/);
+  if (match) return Number(match[1]);
+  const turnId = turn.getAttribute('data-turn-id');
+  if (turnId && /^\d+$/.test(turnId)) return Number(turnId);
+  return Number.POSITIVE_INFINITY;
+}
+
+export function getConversationTurns(doc = document) {
+  if (!doc || typeof doc.querySelectorAll !== 'function') return [];
+  const turns = Array.from(doc.querySelectorAll(TURN_SELECTOR));
+  // Filter out nested duplicates (e.g. [data-message-author-role] inside an article)
+  const filtered = turns.filter((el) => {
+    return !turns.some((parent) => parent !== el && parent.contains(el));
+  });
+
+  return filtered.sort((a, b) => {
+    const idxA = getConversationTurnIndex(a);
+    const idxB = getConversationTurnIndex(b);
+    if (idxA !== idxB) return idxA - idxB;
+    if (typeof a.compareDocumentPosition === 'function') {
+      return a.compareDocumentPosition(b) &
+        (doc.defaultView?.Node?.DOCUMENT_POSITION_FOLLOWING || 4)
+        ? -1
+        : 1;
+    }
+    return 0;
+  });
+}
+
+export function findChatGPTScrollRoot(turns, doc = document) {
+  const firstTurn = turns.find(Boolean);
+  let current = firstTurn?.parentElement || null;
+
+  while (current) {
+    if (isScrollable(current)) return current;
+    current = current.parentElement;
+  }
+
+  const main = doc.querySelector('main');
+  if (isScrollable(main)) return main;
+
+  return doc.scrollingElement || doc.documentElement || doc.body;
+}
+
+function createProgressOverlay(doc) {
+  if (!doc || typeof doc.createElement !== 'function' || !doc.body) return null;
+  try {
+    const overlay = doc.createElement('div');
+    overlay.id = 'ai-exporter-progress-overlay';
+    Object.assign(overlay.style, {
+      position: 'fixed',
+      top: '16px',
+      left: '50%',
+      transform: 'translateX(-50%)',
+      zIndex: '999999',
+      padding: '10px 20px',
+      background: 'rgba(15, 23, 42, 0.92)',
+      color: '#f8fafc',
+      borderRadius: '8px',
+      fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+      fontSize: '14px',
+      fontWeight: '500',
+      boxShadow: '0 10px 25px -5px rgba(0, 0, 0, 0.3), 0 8px 10px -6px rgba(0, 0, 0, 0.3)',
+      pointerEvents: 'none',
+      transition: 'opacity 0.2s ease',
+    });
+    overlay.textContent = 'Preparing conversation export...';
+    doc.body.appendChild(overlay);
+    return overlay;
+  } catch {
+    return null;
+  }
+}
+
+function updateProgressOverlay(overlay, current, total) {
+  if (!overlay) return;
+  const percentage = total > 0 ? Math.round((current / total) * 100) : 0;
+  overlay.textContent = `Processing messages (${current}/${total} - ${percentage}%)...`;
+}
+
+function removeProgressOverlay(overlay) {
+  if (!overlay) return;
+  try {
+    overlay.style.opacity = '0';
+    setTimeout(() => overlay.remove(), 200);
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+export async function collectMountedTurnMessages({
+  turns,
+  scrollRoot,
+  extractMessage,
+  waitForRender = delay,
+  renderWaitMs = DEFAULT_RENDER_WAIT_MS,
+  renderAttempts = 4,
+  doc = typeof document !== 'undefined' ? document : null,
+}) {
+  const originalTop = scrollRoot?.scrollTop;
+  const originalBehavior = scrollRoot?.style?.scrollBehavior;
+  const overlay = createProgressOverlay(doc);
+
+  if (scrollRoot && scrollRoot.style) {
+    scrollRoot.style.scrollBehavior = 'auto';
+  }
+
+  const seen = new Set();
+  const messages = [];
+
+  try {
+    // Scroll to top first to trigger un-virtualization of earlier turns
+    if (scrollRoot && typeof scrollRoot.scrollTop === 'number') {
+      scrollRoot.scrollTop = 0;
+      await waitForRender(renderWaitMs);
+    }
+
+    // Accumulate all turns dynamically across scroll passes
+    const allTurnElements = new Set(turns || []);
+    if (doc) {
+      getConversationTurns(doc).forEach((t) => allTurnElements.add(t));
+    }
+
+    const orderedTurns = Array.from(allTurnElements).sort((a, b) => {
+      return getConversationTurnIndex(a) - getConversationTurnIndex(b);
+    });
+
+    const totalTurns = orderedTurns.length;
+
+    for (let idx = 0; idx < totalTurns; idx += 1) {
+      const turn = orderedTurns[idx];
+      updateProgressOverlay(overlay, idx + 1, totalTurns);
+
+      if (typeof turn.scrollIntoView === 'function') {
+        turn.scrollIntoView({ block: 'center' });
+      }
+
+      let message = null;
+      for (let attempt = 0; attempt < renderAttempts; attempt += 1) {
+        await waitForRender(renderWaitMs);
+        message = extractMessage(turn);
+        if (message?.content) break;
+      }
+
+      if (!message?.content) continue;
+
+      const key = messageKey(message);
+      if (seen.has(key)) continue;
+
+      seen.add(key);
+      messages.push(publicMessage(message));
+    }
+  } finally {
+    removeProgressOverlay(overlay);
+
+    if (scrollRoot && scrollRoot.style) {
+      scrollRoot.style.scrollBehavior = originalBehavior || '';
+    }
+
+    if (scrollRoot && Number.isFinite(originalTop)) {
+      scrollRoot.scrollTop = originalTop;
+    }
+  }
+
+  return messages;
+}