prompt-exporter 2.0.1

package/dist/chunk-YHAS76TP.js

@@ -0,0 +1,436 @@
+// src/utils/paths.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+function getConfigDir() {
+  return process.env.PROMPT_EXPORTER_HOME?.trim() || path.join(os.homedir(), ".prompt-exporter");
+}
+function getDataParentDir() {
+  return process.env.PROMPT_EXPORTER_DATA?.trim() || process.env.CHATGPT_EXPORTER_DATA?.trim() || getConfigDir();
+}
+function getSourceDataDir(sourceId) {
+  return path.join(getDataParentDir(), sourceId);
+}
+function getDefaultDataDir() {
+  return getSourceDataDir("chatgpt");
+}
+function getSourceTokenPath(sourceId) {
+  return path.join(getConfigDir(), "sources", sourceId, "token");
+}
+function getIsolatedChromiumProfileDir() {
+  return path.join(getConfigDir(), "chromium");
+}
+function getSystemChromiumUserDataDir(browserPath) {
+  const home = os.homedir();
+  const binary = (browserPath || process.env.PROMPT_EXPORTER_BROWSER || process.env.CHATGPT_EXPORTER_BROWSER || "").toLowerCase();
+  if (process.platform === "darwin") {
+    if (binary.includes("chrome")) {
+      return path.join(home, "Library", "Application Support", "Google", "Chrome");
+    }
+    return path.join(home, "Library", "Application Support", "Chromium");
+  }
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+    if (binary.includes("chrome")) {
+      return path.join(local, "Google", "Chrome", "User Data");
+    }
+    return path.join(local, "Chromium", "User Data");
+  }
+  const config = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+  if (binary.includes("google-chrome") || /\/chrome$/.test(binary)) {
+    return path.join(config, "google-chrome");
+  }
+  return path.join(config, "chromium");
+}
+function resolveChromiumUserDataDir(options) {
+  const custom = options.userDataDir?.trim() || process.env.PROMPT_EXPORTER_USER_DATA_DIR?.trim() || process.env.CHATGPT_EXPORTER_USER_DATA_DIR?.trim();
+  if (custom) {
+    return { dir: custom, mode: "custom" };
+  }
+  if (options.isolated) {
+    return { dir: getIsolatedChromiumProfileDir(), mode: "isolated" };
+  }
+  return {
+    dir: getSystemChromiumUserDataDir(options.browserPath),
+    mode: "system"
+  };
+}
+var DEFAULT_CDP_PORT = 9222;
+var DEFAULT_SOURCE_ID = "chatgpt";
+async function ensureHomeLayout() {
+  const home = getConfigDir();
+  await fs.mkdir(home, { recursive: true });
+  await fs.mkdir(path.join(home, "sources"), { recursive: true });
+  const legacyHome = path.join(os.homedir(), ".chatgpt-exporter");
+  if (home !== legacyHome) {
+    try {
+      await fs.access(legacyHome);
+      const entries = await fs.readdir(legacyHome, { withFileTypes: true });
+      for (const entry of entries) {
+        const from = path.join(legacyHome, entry.name);
+        if (entry.name === "token") {
+          const destDir = path.join(home, "sources", "chatgpt");
+          await fs.mkdir(destDir, { recursive: true });
+          const dest = path.join(destDir, "token");
+          try {
+            await fs.access(dest);
+          } catch {
+            await fs.rename(from, dest).catch(async () => {
+              await fs.copyFile(from, dest);
+            });
+          }
+          continue;
+        }
+        if (entry.name === "data") {
+          const dest = path.join(home, "chatgpt");
+          try {
+            await fs.access(dest);
+          } catch {
+            await fs.rename(from, dest).catch(() => void 0);
+          }
+          continue;
+        }
+        if (entry.name === "chromium" || entry.name === "chatgpt") {
+          const dest = path.join(home, entry.name);
+          try {
+            await fs.access(dest);
+          } catch {
+            await fs.rename(from, dest).catch(() => void 0);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const flatToken = path.join(home, "token");
+  const nestedToken = getSourceTokenPath("chatgpt");
+  try {
+    await fs.access(flatToken);
+    await fs.mkdir(path.dirname(nestedToken), { recursive: true });
+    try {
+      await fs.access(nestedToken);
+    } catch {
+      await fs.rename(flatToken, nestedToken).catch(async () => {
+        await fs.copyFile(flatToken, nestedToken);
+      });
+    }
+  } catch {
+  }
+}
+
+// src/utils/cdp.ts
+async function cdpHttp(port, path2, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 2e3;
+  const url = `http://127.0.0.1:${port}${path2}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: options.method ?? "GET",
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`CDP HTTP ${response.status} for ${path2}`);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      if (options.allowPlainText) {
+        return text;
+      }
+      throw new Error(`CDP HTTP non-JSON response for ${path2}: ${text.slice(0, 80)}`);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function isCdpRunning(port = DEFAULT_CDP_PORT, options = {}) {
+  const info = await getCdpEndpointInfo(port, options);
+  return info !== null;
+}
+async function discoverCdpPort(preferred = DEFAULT_CDP_PORT) {
+  const fromEnv = (process.env.PROMPT_EXPORTER_CDP_PORT || process.env.CHATGPT_EXPORTER_CDP_PORT)?.trim();
+  const candidates = [
+    fromEnv ? Number.parseInt(fromEnv, 10) : NaN,
+    preferred,
+    9222,
+    9223,
+    9229,
+    9333
+  ].filter((n) => Number.isFinite(n) && n > 0 && n <= 65535);
+  const seen = /* @__PURE__ */ new Set();
+  for (const port of candidates) {
+    if (seen.has(port)) continue;
+    seen.add(port);
+    if (await isCdpRunning(port)) return port;
+  }
+  return null;
+}
+async function getCdpEndpointInfo(port = DEFAULT_CDP_PORT, options = {}) {
+  try {
+    const data = await cdpHttp(port, "/json/version", options);
+    return {
+      port,
+      webSocketDebuggerUrl: typeof data.webSocketDebuggerUrl === "string" ? data.webSocketDebuggerUrl : void 0,
+      Browser: typeof data.Browser === "string" ? data.Browser : void 0,
+      "Protocol-Version": typeof data["Protocol-Version"] === "string" ? data["Protocol-Version"] : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function isChatGptUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === "chatgpt.com" || parsed.hostname === "www.chatgpt.com" || parsed.hostname === "chat.openai.com";
+  } catch {
+    return false;
+  }
+}
+function parseTarget(raw) {
+  if (typeof raw.id !== "string") return null;
+  return {
+    id: raw.id,
+    type: typeof raw.type === "string" ? raw.type : "unknown",
+    title: typeof raw.title === "string" ? raw.title : "",
+    url: typeof raw.url === "string" ? raw.url : "",
+    webSocketDebuggerUrl: typeof raw.webSocketDebuggerUrl === "string" ? raw.webSocketDebuggerUrl : void 0
+  };
+}
+async function listCdpTargets(port) {
+  const data = await cdpHttp(port, "/json/list");
+  if (!Array.isArray(data)) return [];
+  return data.map((item) => parseTarget(item)).filter((t) => t !== null);
+}
+async function openCdpTab(port, url) {
+  const path2 = `/json/new?${encodeURIComponent(url)}`;
+  const data = await cdpHttp(port, path2, { method: "PUT" }).catch(
+    async () => cdpHttp(port, path2)
+  );
+  const target = parseTarget(data);
+  if (!target) {
+    throw new Error("CDP /json/new did not return a target");
+  }
+  return target;
+}
+async function activateCdpTarget(port, id) {
+  await cdpHttp(port, `/json/activate/${encodeURIComponent(id)}`, {
+    allowPlainText: true
+  });
+}
+function getWebSocket() {
+  const WS = globalThis.WebSocket;
+  if (!WS) {
+    throw new Error(
+      "WebSocket is not available in this Node runtime (need Node 22+ or a WebSocket polyfill)"
+    );
+  }
+  return WS;
+}
+async function withCdpSocket(webSocketDebuggerUrl, fn) {
+  const WS = getWebSocket();
+  const ws = new WS(webSocketDebuggerUrl);
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const send = (method, params) => {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      ws.send(JSON.stringify({ id, method, params }));
+    });
+  };
+  try {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("CDP WebSocket connect timeout")), 5e3);
+      ws.addEventListener("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      ws.addEventListener("error", () => {
+        clearTimeout(timer);
+        reject(new Error("CDP WebSocket connection failed"));
+      });
+    });
+    ws.addEventListener("message", (event) => {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      let msg;
+      try {
+        msg = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      const id = msg.id;
+      if (typeof id !== "number") return;
+      const waiter = pending.get(id);
+      if (!waiter) return;
+      pending.delete(id);
+      if (msg.error) {
+        const err = msg.error;
+        waiter.reject(
+          new Error(typeof err.message === "string" ? err.message : "CDP error")
+        );
+      } else {
+        waiter.resolve(msg.result ?? {});
+      }
+    });
+    return await fn(send);
+  } finally {
+    for (const [, waiter] of pending) {
+      waiter.reject(new Error("CDP WebSocket closed"));
+    }
+    pending.clear();
+    ws.close();
+  }
+}
+async function cdpNavigate(webSocketDebuggerUrl, url) {
+  const WS = getWebSocket();
+  const ws = new WS(webSocketDebuggerUrl);
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const send = (method, params) => {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      ws.send(JSON.stringify({ id, method, params }));
+    });
+  };
+  try {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("CDP WebSocket connect timeout")), 5e3);
+      ws.addEventListener("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      ws.addEventListener("error", () => {
+        clearTimeout(timer);
+        reject(new Error("CDP WebSocket connection failed"));
+      });
+    });
+    let loadResolve;
+    const loadPromise = new Promise((resolve) => {
+      loadResolve = resolve;
+    });
+    ws.addEventListener("message", (event) => {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      let msg;
+      try {
+        msg = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      if (msg.method === "Page.loadEventFired") {
+        loadResolve?.();
+      }
+      const id = msg.id;
+      if (typeof id !== "number") return;
+      const waiter = pending.get(id);
+      if (!waiter) return;
+      pending.delete(id);
+      if (msg.error) {
+        const err = msg.error;
+        waiter.reject(
+          new Error(typeof err.message === "string" ? err.message : "CDP error")
+        );
+      } else {
+        waiter.resolve(msg.result ?? {});
+      }
+    });
+    await send("Page.enable");
+    await send("Page.navigate", { url });
+    await Promise.race([
+      loadPromise,
+      new Promise((r) => setTimeout(r, 5e3))
+    ]);
+    await new Promise((r) => setTimeout(r, 300));
+  } finally {
+    for (const [, waiter] of pending) {
+      waiter.reject(new Error("CDP WebSocket closed"));
+    }
+    pending.clear();
+    ws.close();
+  }
+}
+async function ensureChatGptSessionTab(port, sessionUrl) {
+  const targets = await listCdpTargets(port);
+  const pages = targets.filter((t) => t.type === "page" || t.type === "tab");
+  const existing = pages.find((t) => t.url.startsWith(sessionUrl)) ?? pages.find((t) => isChatGptUrl(t.url));
+  if (existing) {
+    await activateCdpTarget(port, existing.id);
+    if (existing.webSocketDebuggerUrl && existing.url !== sessionUrl) {
+      await cdpNavigate(existing.webSocketDebuggerUrl, sessionUrl);
+      const refreshed = (await listCdpTargets(port)).find((t) => t.id === existing.id);
+      return { target: refreshed ?? existing, reused: true };
+    }
+    if (existing.url !== sessionUrl) {
+      const created2 = await openCdpTab(port, sessionUrl);
+      return { target: created2, reused: true };
+    }
+    return { target: existing, reused: true };
+  }
+  const created = await openCdpTab(port, sessionUrl);
+  return { target: created, reused: false };
+}
+async function extractAccessTokenViaCdp(webSocketDebuggerUrl, options = {}) {
+  const attempts = options.attempts ?? 5;
+  const delayMs = options.delayMs ?? 400;
+  return withCdpSocket(webSocketDebuggerUrl, async (send) => {
+    await send("Runtime.enable");
+    for (let i = 0; i < attempts; i++) {
+      const result = await send("Runtime.evaluate", {
+        expression: `(() => {
+          const readBody = () => {
+            const text = document.body && document.body.innerText;
+            if (!text) return null;
+            try {
+              const parsed = JSON.parse(text.trim());
+              if (parsed && typeof parsed.accessToken === 'string') return parsed.accessToken;
+            } catch {}
+            return null;
+          };
+          const fromBody = readBody();
+          if (fromBody) return Promise.resolve(fromBody);
+          return fetch('https://chatgpt.com/api/auth/session', { credentials: 'include' })
+            .then((r) => r.json())
+            .then((j) => (j && typeof j.accessToken === 'string' ? j.accessToken : null))
+            .catch(() => null);
+        })()`,
+        awaitPromise: true,
+        returnByValue: true
+      });
+      const remote = result.result;
+      const value = remote?.value;
+      if (typeof value === "string" && value.startsWith("eyJ")) {
+        return value;
+      }
+      if (i < attempts - 1) {
+        await new Promise((r) => setTimeout(r, delayMs));
+      }
+    }
+    return null;
+  });
+}
+
+export {
+  getSourceDataDir,
+  getDefaultDataDir,
+  getSourceTokenPath,
+  resolveChromiumUserDataDir,
+  DEFAULT_CDP_PORT,
+  DEFAULT_SOURCE_ID,
+  ensureHomeLayout,
+  isCdpRunning,
+  discoverCdpPort,
+  getCdpEndpointInfo,
+  isChatGptUrl,
+  listCdpTargets,
+  openCdpTab,
+  activateCdpTarget,
+  cdpNavigate,
+  ensureChatGptSessionTab,
+  extractAccessTokenViaCdp
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node