prompt-exporter 2.0.1

package/dist/index.js

@@ -0,0 +1,2961 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_CDP_PORT,
+  DEFAULT_SOURCE_ID,
+  activateCdpTarget,
+  cdpNavigate,
+  discoverCdpPort,
+  ensureChatGptSessionTab,
+  ensureHomeLayout,
+  getCdpEndpointInfo,
+  getDefaultDataDir,
+  getSourceDataDir,
+  getSourceTokenPath,
+  isCdpRunning,
+  isChatGptUrl,
+  listCdpTargets,
+  openCdpTab,
+  resolveChromiumUserDataDir
+} from "./chunk-YHAS76TP.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/backup.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+
+// src/sources/chatgpt/api/client.ts
+import crypto from "crypto";
+
+// src/sources/chatgpt/api/endpoints.ts
+var BASE_URL = "https://chatgpt.com";
+var ENDPOINTS = {
+  SESSION: "/api/auth/session",
+  CONVERSATIONS: "/backend-api/conversations",
+  CONVERSATION: (id) => `/backend-api/conversation/${id}`,
+  PROJECTS_SIDEBAR: "/backend-api/gizmos/snorlax/sidebar",
+  PROJECT_CONVERSATIONS: (gizmoId) => `/backend-api/gizmos/${gizmoId}/conversations`,
+  FILE_DOWNLOAD: (fileId) => `/backend-api/files/download/${fileId}`
+};
+
+// src/sources/chatgpt/api/types.ts
+import { z } from "zod";
+var SessionSchema = z.looseObject({
+  accessToken: z.string(),
+  user: z.looseObject({
+    id: z.string(),
+    name: z.string().optional(),
+    email: z.string().optional(),
+    image: z.string().optional()
+  }).optional(),
+  expires: z.string().optional()
+});
+var ConversationItemSchema = z.looseObject({
+  id: z.string(),
+  title: z.string().nullable(),
+  create_time: z.string().or(z.number()).nullable(),
+  update_time: z.string().or(z.number()).nullable(),
+  mapping: z.record(z.string(), z.unknown()).nullable().optional(),
+  current_node: z.string().nullable().optional(),
+  conversation_template_id: z.string().nullable().optional(),
+  gizmo_id: z.string().nullable().optional(),
+  is_archived: z.boolean().optional(),
+  workspace_id: z.string().nullable().optional()
+});
+var ConversationsResponseSchema = z.looseObject({
+  items: z.array(ConversationItemSchema),
+  total: z.number(),
+  limit: z.number(),
+  offset: z.number(),
+  has_missing_conversations: z.boolean().optional()
+});
+var MessageContentSchema = z.looseObject({
+  content_type: z.string(),
+  parts: z.array(z.unknown()).optional(),
+  text: z.string().optional()
+});
+var MessageSchema = z.looseObject({
+  id: z.string(),
+  author: z.looseObject({
+    role: z.string(),
+    name: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional()
+  }),
+  create_time: z.number().nullable().optional(),
+  update_time: z.number().nullable().optional(),
+  content: MessageContentSchema.optional(),
+  status: z.string().optional(),
+  end_turn: z.boolean().nullable().optional(),
+  weight: z.number().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  recipient: z.string().optional()
+});
+var MappingNodeSchema = z.looseObject({
+  id: z.string(),
+  message: MessageSchema.nullable().optional(),
+  parent: z.string().nullable().optional(),
+  children: z.array(z.string()).optional()
+});
+var ConversationDetailSchema = z.looseObject({
+  id: z.string().optional(),
+  title: z.string().nullable(),
+  create_time: z.number().nullable(),
+  update_time: z.number().nullable(),
+  mapping: z.record(z.string(), MappingNodeSchema),
+  moderation_results: z.array(z.unknown()).optional(),
+  current_node: z.string().nullable().optional(),
+  conversation_id: z.string().optional(),
+  is_archived: z.boolean().optional()
+});
+var ProjectGizmoSchema = z.looseObject({
+  id: z.string(),
+  display: z.looseObject({
+    name: z.string(),
+    theme: z.unknown().optional()
+  }),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+  last_interacted_at: z.string().nullable().optional(),
+  num_interactions: z.number().optional(),
+  is_archived: z.boolean().optional(),
+  gizmo_type: z.string().optional()
+});
+var SidebarItemSchema = z.looseObject({
+  gizmo: ProjectGizmoSchema
+});
+var ProjectsSidebarResponseSchema = z.looseObject({
+  items: z.array(SidebarItemSchema),
+  cursor: z.string().nullable().optional()
+});
+var ProjectConversationsResponseSchema = z.looseObject({
+  items: z.array(ConversationItemSchema),
+  cursor: z.string().nullable().optional()
+});
+var AuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends Error {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NetworkError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "NetworkError";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/utils/retry.ts
+var defaultOptions = {
+  maxRetries: 5,
+  baseDelay: 1e3,
+  maxDelay: 6e4
+};
+function calculateDelay(attempt, baseDelay, maxDelay) {
+  const exponentialDelay = baseDelay * Math.pow(2, attempt);
+  const jitter = Math.random() * 0.3 * exponentialDelay;
+  return Math.min(exponentialDelay + jitter, maxDelay);
+}
+async function withRetry(fn, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  let lastError;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === opts.maxRetries) {
+        break;
+      }
+      const statusCode = lastError.statusCode;
+      if (lastError.name === "AuthenticationError" || lastError.name === "NetworkError" && (statusCode === 403 || statusCode === 404)) {
+        throw lastError;
+      }
+      const delay = calculateDelay(attempt, opts.baseDelay, opts.maxDelay);
+      opts.onRetry?.(lastError, attempt + 1, delay);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/throttle-stats.ts
+var ThrottleStats = class {
+  latenciesMs = [];
+  maxSamples;
+  successes = 0;
+  rateLimits = 0;
+  failures = 0;
+  startedAt = Date.now();
+  lastReportAt = Date.now();
+  constructor(maxSamples = 200) {
+    this.maxSamples = maxSamples;
+  }
+  recordSuccess(latencyMs) {
+    this.successes++;
+    this.pushLatency(latencyMs);
+  }
+  recordRateLimit(latencyMs) {
+    this.rateLimits++;
+    if (latencyMs != null) this.pushLatency(latencyMs);
+  }
+  recordFailure(latencyMs) {
+    this.failures++;
+    if (latencyMs != null) this.pushLatency(latencyMs);
+  }
+  pushLatency(ms) {
+    this.latenciesMs.push(ms);
+    if (this.latenciesMs.length > this.maxSamples) {
+      this.latenciesMs.shift();
+    }
+  }
+  percentile(p) {
+    if (this.latenciesMs.length === 0) return 0;
+    const sorted = [...this.latenciesMs].sort((a, b) => a - b);
+    const idx = Math.min(
+      sorted.length - 1,
+      Math.max(0, Math.ceil(p / 100 * sorted.length) - 1)
+    );
+    return sorted[idx] ?? 0;
+  }
+  summary() {
+    const elapsedSec = Math.max(1e-3, (Date.now() - this.startedAt) / 1e3);
+    const done = this.successes + this.failures + this.rateLimits;
+    const rps = (this.successes / elapsedSec).toFixed(2);
+    const p50 = Math.round(this.percentile(50));
+    const p95 = Math.round(this.percentile(95));
+    return [
+      `ok=${this.successes}`,
+      `429=${this.rateLimits}`,
+      `fail=${this.failures}`,
+      `rps=${rps}`,
+      `p50=${p50}ms`,
+      `p95=${p95}ms`,
+      `n=${done}`
+    ].join(" ");
+  }
+  /** True if enough time passed to emit another verbose line. */
+  shouldReport(intervalMs = 15e3) {
+    if (Date.now() - this.lastReportAt >= intervalMs) {
+      this.lastReportAt = Date.now();
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/sources/chatgpt/api/cdp-http.ts
+var CdpHttpSession = class _CdpHttpSession {
+  port;
+  poolSize;
+  workers = [];
+  waiters = [];
+  cachedBearer = null;
+  connecting = null;
+  stats = new ThrottleStats();
+  /** Adaptive pause after 429 (ms); decays on success. */
+  cooldownMs = 0;
+  minGapMs;
+  lastStartAt = 0;
+  constructor(port, options = {}) {
+    this.port = port;
+    this.poolSize = Math.max(1, options.poolSize ?? 3);
+    this.minGapMs = Math.max(0, options.minGapMs ?? 150);
+  }
+  get debuggingPort() {
+    return this.port;
+  }
+  get workerCount() {
+    return this.workers.length;
+  }
+  static async connect(preferredPort = DEFAULT_CDP_PORT, options = {}) {
+    let port = preferredPort;
+    const { isCdpRunning: isCdpRunning2 } = await import("./cdp-PRMCSQGL.js");
+    if (!await isCdpRunning2(port)) {
+      const found = await discoverCdpPort(port);
+      if (found === null) {
+        throw new Error("No Chromium CDP endpoint found (tried 9222/9223/\u2026)");
+      }
+      port = found;
+    }
+    const session = new _CdpHttpSession(port, options);
+    await session.ensurePool();
+    return session;
+  }
+  async close() {
+    for (const w of this.workers) {
+      for (const [, waiter] of w.pending) {
+        waiter.reject(new Error("CDP session closed"));
+      }
+      w.pending.clear();
+      try {
+        w.ws.close();
+      } catch {
+      }
+    }
+    this.workers = [];
+    this.waiters = [];
+    this.connecting = null;
+  }
+  async ensurePool() {
+    if (this.workers.length >= this.poolSize) return;
+    if (this.connecting) return this.connecting;
+    this.connecting = (async () => {
+      const pages = await this.pickOrOpenPages(this.poolSize);
+      for (let i = 0; i < pages.length; i++) {
+        if (this.workers.some((w) => w.targetId === pages[i].id)) continue;
+        const worker = await this.attachWorker(i, pages[i]);
+        this.workers.push(worker);
+      }
+      if (this.workers.length === 0) {
+        throw new Error("Failed to attach any CDP page workers");
+      }
+    })();
+    try {
+      await this.connecting;
+    } finally {
+      this.connecting = null;
+    }
+  }
+  async pickOrOpenPages(n) {
+    const targets = await listCdpTargets(this.port);
+    const pages = targets.filter((t) => t.type === "page" || t.type === "tab");
+    const chatgpt = pages.filter(
+      (t) => isChatGptUrl(t.url) && !t.url.includes("/api/auth/session")
+    );
+    const chosen = [...chatgpt];
+    while (chosen.length < n) {
+      const created = await openCdpTab(this.port, "https://chatgpt.com/");
+      chosen.push(created);
+      await new Promise((r) => setTimeout(r, 400));
+    }
+    return chosen.slice(0, n);
+  }
+  async attachWorker(id, page) {
+    await activateCdpTarget(this.port, page.id);
+    const refreshed = (await listCdpTargets(this.port)).find((t) => t.id === page.id) ?? page;
+    const wsUrl = refreshed.webSocketDebuggerUrl;
+    if (!wsUrl) throw new Error("CDP page has no webSocketDebuggerUrl");
+    const WS = globalThis.WebSocket;
+    if (!WS) throw new Error("WebSocket not available");
+    const ws = new WS(wsUrl);
+    const worker = {
+      id,
+      targetId: page.id,
+      ws,
+      nextId: 1,
+      pending: /* @__PURE__ */ new Map(),
+      busy: false
+    };
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error("CDP WebSocket connect timeout")),
+        8e3
+      );
+      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 mid = msg.id;
+      if (typeof mid !== "number") return;
+      const waiter = worker.pending.get(mid);
+      if (!waiter) return;
+      worker.pending.delete(mid);
+      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 this.send(worker, "Runtime.enable");
+    return worker;
+  }
+  send(worker, method, params) {
+    if (worker.ws.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("CDP WebSocket not open"));
+    }
+    const id = worker.nextId++;
+    return new Promise((resolve, reject) => {
+      worker.pending.set(id, { resolve, reject });
+      worker.ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+  acquire() {
+    const free = this.workers.find((w) => !w.busy);
+    if (free) {
+      free.busy = true;
+      return Promise.resolve(free);
+    }
+    return new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+  release(worker) {
+    const next = this.waiters.shift();
+    if (next) {
+      next(worker);
+    } else {
+      worker.busy = false;
+    }
+  }
+  async respectGap() {
+    const gap = Math.max(this.minGapMs, this.cooldownMs);
+    if (gap <= 0) return;
+    const wait = gap - (Date.now() - this.lastStartAt);
+    if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+    this.lastStartAt = Date.now();
+  }
+  async fetch(url, options = {}) {
+    await this.ensurePool();
+    await this.respectGap();
+    const worker = await this.acquire();
+    const t0 = Date.now();
+    try {
+      const response = await this.fetchOnWorker(worker, url, options);
+      const latency = Date.now() - t0;
+      if (response.status === 429) {
+        this.stats.recordRateLimit(latency);
+        this.cooldownMs = Math.min(15e3, Math.max(1e3, this.cooldownMs * 2 || 1e3));
+      } else if (response.status >= 200 && response.status < 300) {
+        this.stats.recordSuccess(latency);
+        this.cooldownMs = Math.floor(this.cooldownMs * 0.5);
+      } else {
+        this.stats.recordFailure(latency);
+      }
+      return response;
+    } catch (e) {
+      this.stats.recordFailure(Date.now() - t0);
+      throw e;
+    } finally {
+      this.release(worker);
+    }
+  }
+  async fetchOnWorker(worker, url, options) {
+    const method = options.method ?? "GET";
+    const wantRaw = options.raw ?? false;
+    const extraHeaders = options.headers ?? {};
+    const body = options.body;
+    const cachedBearer = this.cachedBearer;
+    const result = await this.send(worker, "Runtime.evaluate", {
+      expression: `(() => {
+        const url = ${JSON.stringify(url)};
+        const method = ${JSON.stringify(method)};
+        const extraHeaders = ${JSON.stringify(extraHeaders)};
+        const body = ${JSON.stringify(body ?? null)};
+        const wantRaw = ${JSON.stringify(wantRaw)};
+        const cachedBearer = ${JSON.stringify(cachedBearer)};
+
+        const toBase64 = async (buf) => {
+          const bytes = new Uint8Array(buf);
+          const chunk = 0x8000;
+          let binary = '';
+          for (let i = 0; i < bytes.length; i += chunk) {
+            binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk));
+          }
+          return btoa(binary);
+        };
+
+        return (async () => {
+          const auth = {};
+          if (cachedBearer) {
+            auth.Authorization = 'Bearer ' + cachedBearer;
+          } else {
+            try {
+              const session = await fetch('/api/auth/session', {
+                credentials: 'include',
+                headers: { Accept: 'application/json' },
+                cache: 'no-store',
+              }).then((r) => r.json());
+              if (session && typeof session.accessToken === 'string') {
+                auth.Authorization = 'Bearer ' + session.accessToken;
+              }
+            } catch {}
+          }
+
+          const response = await fetch(url, {
+            method,
+            credentials: 'include',
+            headers: Object.assign(
+              { Accept: 'application/json' },
+              auth,
+              extraHeaders || {}
+            ),
+            body: body == null ? undefined : body,
+          });
+
+          const accessToken =
+            auth.Authorization && auth.Authorization.startsWith('Bearer ')
+              ? auth.Authorization.slice(7)
+              : null;
+
+          if (wantRaw) {
+            const buf = await response.arrayBuffer();
+            return {
+              status: response.status,
+              statusText: response.statusText,
+              bodyText: '',
+              bodyBase64: await toBase64(buf),
+              accessToken,
+            };
+          }
+
+          const bodyText = await response.text();
+          return {
+            status: response.status,
+            statusText: response.statusText,
+            bodyText,
+            accessToken,
+          };
+        })();
+      })()`,
+      awaitPromise: true,
+      returnByValue: true
+    });
+    const value = result.result?.value;
+    if (!value || typeof value.status !== "number") {
+      throw new Error("CDP fetch returned no usable response");
+    }
+    if (typeof value.accessToken === "string" && value.accessToken.startsWith("eyJ")) {
+      this.cachedBearer = value.accessToken;
+    }
+    return {
+      status: value.status,
+      statusText: value.statusText,
+      bodyText: value.bodyText,
+      bodyBase64: value.bodyBase64
+    };
+  }
+};
+
+// src/sources/chatgpt/api/client.ts
+var BROWSER_HEADERS = {
+  "Content-Type": "application/json",
+  "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36",
+  Accept: "application/json",
+  "Accept-Language": "en-US,en;q=0.9",
+  Referer: "https://chatgpt.com/",
+  Origin: "https://chatgpt.com",
+  "Sec-Ch-Ua": '"Chromium";v="152", "Not_A Brand";v="24"',
+  "Sec-Ch-Ua-Mobile": "?0",
+  "Sec-Ch-Ua-Platform": '"Linux"',
+  "Sec-Fetch-Dest": "empty",
+  "Sec-Fetch-Mode": "cors",
+  "Sec-Fetch-Site": "same-origin"
+};
+var ChatGPTClient = class {
+  accessToken;
+  verbose;
+  deviceId;
+  cdpPort;
+  cdpPoolSize;
+  cdpMinGapMs;
+  cdp;
+  ownsCdp = false;
+  constructor(accessToken = "", options = {}) {
+    this.accessToken = accessToken;
+    this.verbose = options.verbose ?? false;
+    this.deviceId = crypto.randomUUID();
+    this.cdpPort = options.cdpPort;
+    this.cdpPoolSize = options.cdpPoolSize ?? 3;
+    this.cdpMinGapMs = options.cdpMinGapMs ?? 150;
+    if (options.cdpSession) {
+      this.cdp = options.cdpSession;
+      this.ownsCdp = false;
+    }
+  }
+  get usesCdp() {
+    return this.cdpPort !== void 0 || this.cdp !== void 0;
+  }
+  get throttleStats() {
+    return this.cdp?.stats;
+  }
+  get cdpWorkers() {
+    return this.cdp?.workerCount ?? 0;
+  }
+  getHeaders() {
+    const headers = {
+      ...BROWSER_HEADERS,
+      "Oai-Device-Id": this.deviceId,
+      "Oai-Language": "en-US"
+    };
+    if (this.accessToken) {
+      headers.Authorization = `Bearer ${this.accessToken}`;
+    }
+    return headers;
+  }
+  async ensureCdp() {
+    if (this.cdp) return this.cdp;
+    if (this.cdpPort === void 0) {
+      throw new Error("CDP port not configured");
+    }
+    this.cdp = await CdpHttpSession.connect(this.cdpPort, {
+      poolSize: this.cdpPoolSize,
+      minGapMs: this.cdpMinGapMs
+    });
+    this.ownsCdp = true;
+    return this.cdp;
+  }
+  async close() {
+    if (this.ownsCdp && this.cdp) {
+      await this.cdp.close();
+      this.cdp = void 0;
+    }
+  }
+  async request(endpointOrUrl, options = {}) {
+    const method = options.method ?? "GET";
+    const absolute = options.absolute || endpointOrUrl.startsWith("http://") || endpointOrUrl.startsWith("https://");
+    const url = absolute ? endpointOrUrl : `${BASE_URL}${endpointOrUrl}`;
+    if (this.usesCdp) {
+      const cdp = await this.ensureCdp();
+      const pathOrUrl = absolute ? url : endpointOrUrl;
+      const response2 = await cdp.fetch(pathOrUrl, {
+        method,
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        headers: options.body !== void 0 ? { "Content-Type": "application/json" } : void 0,
+        raw: options.raw
+      });
+      if (options.raw) {
+        const b64 = response2.bodyBase64 ?? "";
+        const binary = Buffer.from(b64, "base64");
+        return {
+          status: response2.status,
+          statusText: response2.statusText,
+          raw: binary.buffer.slice(
+            binary.byteOffset,
+            binary.byteOffset + binary.byteLength
+          )
+        };
+      }
+      let json2;
+      try {
+        json2 = response2.bodyText ? JSON.parse(response2.bodyText) : null;
+      } catch {
+        json2 = void 0;
+      }
+      return {
+        status: response2.status,
+        statusText: response2.statusText,
+        text: response2.bodyText,
+        json: json2
+      };
+    }
+    const response = await fetch(url, {
+      method,
+      headers: this.getHeaders(),
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    if (options.raw) {
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        raw: await response.arrayBuffer()
+      };
+    }
+    const text = await response.text();
+    let json;
+    try {
+      json = text ? JSON.parse(text) : null;
+    } catch {
+      json = void 0;
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      text,
+      json
+    };
+  }
+  throwForStatus(status, statusText, bodyPreview) {
+    if (status === 401 || status === 403) {
+      throw new AuthenticationError(
+        `Access rejected (HTTP ${status})${this.usesCdp ? "" : " \u2014 prefer CDP: prompt-exporter chromium start"}.${this.verbose && bodyPreview ? ` Body: ${bodyPreview.slice(0, 200)}` : ""}`
+      );
+    }
+    if (status === 429) {
+      throw new RateLimitError("Rate limited by API");
+    }
+    throw new NetworkError(`Request failed: ${status} ${statusText}`, status);
+  }
+  async initialize() {
+    if (this.usesCdp) {
+      await this.ensureCdp();
+    }
+    const result = await this.request(
+      "/backend-api/conversations?offset=0&limit=1&order=updated"
+    );
+    if (result.status < 200 || result.status >= 300) {
+      if (this.verbose) {
+        console.error(`Auth check failed: HTTP ${result.status}`);
+        console.error(`Response body: ${(result.text ?? "").slice(0, 500)}`);
+      }
+      this.throwForStatus(result.status, result.statusText, result.text);
+    }
+    if (this.verbose) {
+      console.log(
+        this.usesCdp ? `Authenticated via Chromium CDP (port ${this.cdp?.debuggingPort ?? this.cdpPort})` : "Successfully authenticated"
+      );
+    }
+  }
+  async fetch(endpoint, options = {}) {
+    if (!this.usesCdp && !this.accessToken) {
+      throw new AuthenticationError(
+        "No access token and no CDP session. Run: prompt-exporter token"
+      );
+    }
+    const { method = "GET", body, parseResponse, retryOptions } = options;
+    return withRetry(
+      async () => {
+        const result = await this.request(endpoint, { method, body });
+        if (result.status < 200 || result.status >= 300) {
+          this.throwForStatus(result.status, result.statusText, result.text);
+        }
+        const data = result.json;
+        return parseResponse ? parseResponse(data) : data;
+      },
+      {
+        ...retryOptions,
+        onRetry: (error, attempt, delay) => {
+          if (this.verbose) {
+            console.log(
+              `Retry ${attempt}: ${error.message} (waiting ${Math.round(delay / 1e3)}s)`
+            );
+          }
+        }
+      }
+    );
+  }
+  async fetchRaw(url, retryOptions) {
+    const isAbsolute = url.startsWith("http://") || url.startsWith("https://");
+    const fullUrl = isAbsolute ? url : `${BASE_URL}${url}`;
+    const isSameOrigin = !isAbsolute || fullUrl.startsWith(BASE_URL);
+    return withRetry(
+      async () => {
+        const result = await this.request(fullUrl, {
+          absolute: true,
+          raw: true
+        });
+        if (result.status < 200 || result.status >= 300) {
+          if (isSameOrigin && (result.status === 401 || result.status === 403)) {
+            throw new AuthenticationError("Access token expired or invalid.");
+          }
+          this.throwForStatus(result.status, result.statusText);
+        }
+        return result.raw ?? new ArrayBuffer(0);
+      },
+      {
+        ...retryOptions,
+        onRetry: (error, attempt, delay) => {
+          if (this.verbose) {
+            console.log(
+              `Retry ${attempt}: ${error.message} (waiting ${Math.round(delay / 1e3)}s)`
+            );
+          }
+        }
+      }
+    );
+  }
+};
+
+// src/utils/credentials.ts
+import fs from "fs/promises";
+import path from "path";
+function getTokenPath(sourceId = "chatgpt") {
+  return getSourceTokenPath(sourceId);
+}
+async function loadSavedToken(sourceId = "chatgpt") {
+  await ensureHomeLayout();
+  try {
+    const raw = await fs.readFile(getTokenPath(sourceId), "utf-8");
+    const token = raw.trim();
+    return token.startsWith("eyJ") ? token : null;
+  } catch {
+    return null;
+  }
+}
+async function saveToken(token, sourceId = "chatgpt") {
+  if (!token.startsWith("eyJ")) {
+    throw new Error(
+      "Refusing to save a value that does not look like a JWT accessToken"
+    );
+  }
+  await ensureHomeLayout();
+  const file = getTokenPath(sourceId);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, `${token}
+`, { encoding: "utf-8", mode: 384 });
+  await fs.chmod(file, 384).catch(() => void 0);
+  return file;
+}
+
+// src/sources/chatgpt/api/create-client.ts
+async function createChatGptClient(options = {}) {
+  const preferCdp = options.preferCdp !== false;
+  let port = options.cdpPort ?? DEFAULT_CDP_PORT;
+  const poolSize = options.cdpPoolSize ?? 3;
+  const minGapMs = options.cdpMinGapMs ?? 150;
+  if (preferCdp) {
+    if (!await isCdpRunning(port)) {
+      const found = await discoverCdpPort(port);
+      if (found !== null) port = found;
+    }
+    if (await isCdpRunning(port)) {
+      const client = new ChatGPTClient(options.token ?? "", {
+        verbose: options.verbose,
+        cdpPort: port,
+        cdpPoolSize: poolSize,
+        cdpMinGapMs: minGapMs
+      });
+      return { client, mode: "cdp" };
+    }
+  }
+  const token = options.token?.trim() || process.env.PROMPT_EXPORTER_CHATGPT_TOKEN?.trim() || process.env.CHATGPT_TOKEN?.trim() || await loadSavedToken("chatgpt");
+  if (!token) {
+    throw new Error(
+      "No CDP browser and no access token. Run: prompt-exporter chromium start"
+    );
+  }
+  return {
+    client: new ChatGPTClient(token, { verbose: options.verbose }),
+    mode: "token"
+  };
+}
+
+// src/sources/chatgpt/api/pagination.ts
+async function* fetchAllConversations(client, options = {}) {
+  const { limit = 100, delay = 500, onProgress } = options;
+  let offset = 0;
+  let total = Infinity;
+  let fetched = 0;
+  while (offset < total) {
+    const response = await client.fetch(
+      `${ENDPOINTS.CONVERSATIONS}?offset=${offset}&limit=${limit}&order=updated`,
+      {
+        parseResponse: (data) => ConversationsResponseSchema.parse(data)
+      }
+    );
+    total = response.total;
+    for (const item of response.items) {
+      yield item;
+      fetched++;
+    }
+    onProgress?.(fetched, total);
+    offset += limit;
+    if (offset < total && delay > 0) {
+      await sleep(delay);
+    }
+  }
+}
+async function countConversations(client) {
+  const response = await client.fetch(
+    `${ENDPOINTS.CONVERSATIONS}?offset=0&limit=1`,
+    {
+      parseResponse: (data) => ConversationsResponseSchema.parse(data)
+    }
+  );
+  return response.total;
+}
+async function fetchAllProjects(client, options = {}) {
+  const { delay = 500 } = options;
+  const allItems = [];
+  let cursor = null;
+  do {
+    const url = cursor ? `${ENDPOINTS.PROJECTS_SIDEBAR}?cursor=${encodeURIComponent(cursor)}` : ENDPOINTS.PROJECTS_SIDEBAR;
+    const response = await client.fetch(url, {
+      parseResponse: (data) => ProjectsSidebarResponseSchema.parse(data)
+    });
+    allItems.push(...response.items);
+    cursor = response.cursor;
+    if (cursor && delay > 0) {
+      await sleep(delay);
+    }
+  } while (cursor);
+  return allItems;
+}
+async function* fetchProjectConversations(client, gizmoId, options = {}) {
+  const { delay = 500, onProgress } = options;
+  let cursor = "0";
+  let fetched = 0;
+  while (cursor !== null && cursor !== void 0) {
+    const url = `${ENDPOINTS.PROJECT_CONVERSATIONS(gizmoId)}?cursor=${encodeURIComponent(cursor)}`;
+    const response = await client.fetch(url, {
+      parseResponse: (data) => ProjectConversationsResponseSchema.parse(data)
+    });
+    for (const item of response.items) {
+      yield item;
+      fetched++;
+    }
+    cursor = response.cursor;
+    onProgress?.(fetched, fetched);
+    if (cursor && delay > 0) {
+      await sleep(delay);
+    }
+  }
+}
+
+// src/services/backup-service.ts
+var BackupService = class {
+  client;
+  storage;
+  constructor(client, storage) {
+    this.client = client;
+    this.storage = storage;
+  }
+  async listConversations(options) {
+    const conversations = [];
+    for await (const conversation of fetchAllConversations(this.client, {
+      delay: options.delay,
+      onProgress: options.onListProgress
+    })) {
+      conversations.push(conversation);
+    }
+    return conversations;
+  }
+  async getConversationCount() {
+    return countConversations(this.client);
+  }
+  async listProjects() {
+    return fetchAllProjects(this.client);
+  }
+  async listProjectConversations(gizmoId, options = {}) {
+    const conversations = [];
+    for await (const conversation of fetchProjectConversations(this.client, gizmoId, {
+      delay: options.delay,
+      onProgress: options.onListProgress
+    })) {
+      conversations.push(conversation);
+    }
+    return conversations;
+  }
+  async resolveProjectId(nameOrId) {
+    const projects = await this.listProjects();
+    const match = projects.find(
+      (p) => p.gizmo.id === nameOrId || p.gizmo.display.name.toLowerCase() === nameOrId.toLowerCase()
+    );
+    if (!match) {
+      const available = projects.map((p) => p.gizmo.display.name).join(", ");
+      throw new Error(
+        `Project "${nameOrId}" not found. Available projects: ${available || "(none)"}`
+      );
+    }
+    return { gizmoId: match.gizmo.id, name: match.gizmo.display.name };
+  }
+  async downloadConversation(id) {
+    return this.client.fetch(ENDPOINTS.CONVERSATION(id), {
+      parseResponse: (data) => ConversationDetailSchema.parse(data)
+    });
+  }
+  async backup(options) {
+    const {
+      concurrency,
+      delay,
+      incremental,
+      verbose,
+      projectGizmoId,
+      onListProgress,
+      onDownloadProgress,
+      onError
+    } = options;
+    await this.storage.initialize();
+    await this.storage.appendLog("Starting backup...");
+    const conversations = projectGizmoId ? await this.listProjectConversations(projectGizmoId, { delay, onListProgress }) : await this.listConversations({ delay, onListProgress });
+    await this.storage.saveIndex(conversations);
+    const errors = [];
+    let downloaded = 0;
+    let skipped = 0;
+    let failed = 0;
+    let completed = 0;
+    const toDownload = [];
+    for (const conv of conversations) {
+      if (incremental) {
+        const existingUpdateTime = await this.storage.getExistingConversationUpdateTime(conv.id);
+        const convUpdateTime = typeof conv.update_time === "number" ? conv.update_time : conv.update_time ? new Date(conv.update_time).getTime() / 1e3 : null;
+        if (existingUpdateTime !== null && convUpdateTime !== null && existingUpdateTime >= convUpdateTime) {
+          skipped++;
+          completed++;
+          onDownloadProgress?.(completed, conversations.length, conv.title ?? conv.id);
+          continue;
+        }
+      }
+      toDownload.push(conv);
+    }
+    const downloadQueue = [...toDownload];
+    const inProgress = /* @__PURE__ */ new Set();
+    const processOne = async (conv) => {
+      try {
+        const detail = await this.downloadConversation(conv.id);
+        await this.storage.saveConversation(conv.id, detail);
+        downloaded++;
+        if (verbose) {
+          await this.storage.appendLog(`Downloaded: ${conv.id} - ${conv.title ?? "Untitled"}`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push({ conversationId: conv.id, error: errorMessage });
+        failed++;
+        onError?.(conv.id, error);
+        await this.storage.appendLog(`Failed: ${conv.id} - ${errorMessage}`);
+      } finally {
+        completed++;
+        onDownloadProgress?.(completed, conversations.length, conv.title ?? conv.id);
+      }
+    };
+    while (downloadQueue.length > 0 || inProgress.size > 0) {
+      while (inProgress.size < concurrency && downloadQueue.length > 0) {
+        const conv = downloadQueue.shift();
+        const promise = processOne(conv).then(() => {
+          inProgress.delete(promise);
+        });
+        inProgress.add(promise);
+        if (downloadQueue.length > 0 && delay > 0) {
+          await sleep(delay);
+        }
+      }
+      if (inProgress.size > 0) {
+        await Promise.race(inProgress);
+      }
+    }
+    const metadata = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      totalConversations: conversations.length,
+      successfulDownloads: downloaded,
+      failedDownloads: failed,
+      errors
+    };
+    await this.storage.saveMetadata(metadata);
+    await this.storage.appendLog(`Backup completed: ${downloaded} downloaded, ${skipped} skipped, ${failed} failed`);
+    return {
+      totalConversations: conversations.length,
+      downloaded,
+      skipped,
+      failed,
+      errors
+    };
+  }
+};
+
+// src/services/file-service.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/utils/conversation-files.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+function conversationsRoot(outputDir, projectName) {
+  if (projectName) {
+    const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return path2.join(outputDir, "projects", safeName, "conversations");
+  }
+  return path2.join(outputDir, "conversations");
+}
+function jsonDir(conversationsDir) {
+  return path2.join(conversationsDir, "json");
+}
+function jsonPathForId(conversationsDir, id) {
+  return path2.join(jsonDir(conversationsDir), `${id}.json`);
+}
+function indexPath(conversationsDir) {
+  return path2.join(jsonDir(conversationsDir), "index.json");
+}
+function toDate(value) {
+  if (value == null) return null;
+  if (typeof value === "number") {
+    const ms = value > 1e12 ? value : value * 1e3;
+    const d2 = new Date(ms);
+    return Number.isNaN(d2.getTime()) ? null : d2;
+  }
+  const asNum = Number(value);
+  if (Number.isFinite(asNum) && value.trim() !== "") {
+    return toDate(asNum);
+  }
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function formatUpdateStamp(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const hh = String(date.getHours()).padStart(2, "0");
+  const mm = String(date.getMinutes()).padStart(2, "0");
+  return `${y}-${m}-${d}-${hh}${mm}`;
+}
+function sanitizeTitleForFilename(title) {
+  const base = (title?.trim() || "Untitled").replace(/[/\\]/g, "-").replace(/[:*?"<>|]/g, "-").replace(/[\0\x00-\x1f\x7f]/g, "").replace(/\s+/g, " ").trim().replace(/^\.+/, "").slice(0, 120).trim();
+  return base || "Untitled";
+}
+function markdownFilename(detail) {
+  const date = toDate(detail.update_time) ?? toDate(detail.create_time) ?? /* @__PURE__ */ new Date(0);
+  const stamp = formatUpdateStamp(date);
+  const title = sanitizeTitleForFilename(detail.title);
+  return `${stamp}.${title}.md`;
+}
+function buildFrontmatter(meta) {
+  const lines = ["---"];
+  lines.push(`id: ${yamlScalar(meta.id)}`);
+  lines.push(`title: ${yamlScalar(meta.title)}`);
+  if (meta.updated) lines.push(`updated: ${yamlScalar(meta.updated)}`);
+  if (meta.created) lines.push(`created: ${yamlScalar(meta.created)}`);
+  lines.push(`json: ${yamlScalar(meta.json)}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+function yamlScalar(value) {
+  if (/^[A-Za-z0-9_./:@+-]+$/.test(value) && !value.includes(":")) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function relativeJsonFromMd(id) {
+  return path2.posix.join("json", `${id}.json`);
+}
+function isoOrNull(value) {
+  const d = toDate(value);
+  return d ? d.toISOString() : null;
+}
+async function listJsonInDir(dir) {
+  const files = [];
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".json") && entry.name !== "index.json") {
+        files.push(path2.join(dir, entry.name));
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+async function collectAllJsonFiles(inputDir) {
+  const byId = /* @__PURE__ */ new Map();
+  const consider = (filePath, preferred) => {
+    const id = path2.basename(filePath, ".json");
+    const prev = byId.get(id);
+    if (!prev || preferred && !prev.preferred) {
+      byId.set(id, { path: filePath, preferred });
+    }
+  };
+  const roots = [conversationsRoot(inputDir)];
+  try {
+    const projectsDir = path2.join(inputDir, "projects");
+    const entries = await fs2.readdir(projectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        roots.push(conversationsRoot(inputDir, entry.name));
+      }
+    }
+  } catch {
+  }
+  for (const root of roots) {
+    for (const f of await listJsonInDir(jsonDir(root))) {
+      consider(f, true);
+    }
+    for (const f of await listJsonInDir(root)) {
+      consider(f, false);
+    }
+  }
+  return [...byId.values()].map((v) => v.path);
+}
+
+// src/services/file-service.ts
+var FILE_SERVICE_PREFIX = "file-service://";
+function extractFileIdFromPointer(pointer) {
+  if (!pointer.startsWith(FILE_SERVICE_PREFIX)) return null;
+  return pointer.slice(FILE_SERVICE_PREFIX.length);
+}
+function extractFileReferences(detail) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const node of Object.values(detail.mapping)) {
+    const msg = node.message;
+    if (!msg) continue;
+    if (msg.content?.parts) {
+      for (const part of msg.content.parts) {
+        if (part && typeof part === "object") {
+          const obj = part;
+          if (obj.content_type === "image_asset_pointer") {
+            const pointer = obj.asset_pointer;
+            if (pointer) {
+              const fileId = extractFileIdFromPointer(pointer);
+              if (fileId && !refs.has(fileId)) {
+                refs.set(fileId, { fileId, source: "image_asset_pointer" });
+              }
+            }
+          }
+        }
+      }
+    }
+    const metadata = msg.metadata;
+    if (metadata?.attachments && Array.isArray(metadata.attachments)) {
+      for (const att of metadata.attachments) {
+        const a = att;
+        const id = a.id;
+        if (id && !refs.has(id)) {
+          refs.set(id, {
+            fileId: id,
+            filename: a.name,
+            source: "attachment"
+          });
+        }
+      }
+    }
+    if (metadata?.citations && Array.isArray(metadata.citations)) {
+      for (const cit of metadata.citations) {
+        const c = cit;
+        const metadata2 = c.metadata;
+        const fileId = metadata2?.file_id ?? c.file_id;
+        if (fileId && !refs.has(fileId)) {
+          refs.set(fileId, {
+            fileId,
+            filename: metadata2?.title ?? c.title,
+            source: "citation"
+          });
+        }
+      }
+    }
+  }
+  return Array.from(refs.values());
+}
+async function scanAllConversations(inputDir) {
+  const refs = /* @__PURE__ */ new Map();
+  const jsonFiles = await collectAllJsonFiles(inputDir);
+  for (const jsonPath of jsonFiles) {
+    try {
+      const raw = await fs3.readFile(jsonPath, "utf-8");
+      const detail = JSON.parse(raw);
+      for (const ref of extractFileReferences(detail)) {
+        if (!refs.has(ref.fileId)) {
+          refs.set(ref.fileId, ref);
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(refs.values());
+}
+async function dirHasFiles(dir) {
+  try {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) return true;
+      if (entry.isDirectory()) {
+        if (await dirHasFiles(path3.join(dir, entry.name))) return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+async function downloadFiles(client, allRefs, outputDir, options) {
+  const { concurrency, delay, verbose, skipFileIds, onProgress, onError } = options;
+  const filesDir = path3.join(outputDir, "files");
+  const refs = skipFileIds && skipFileIds.size > 0 ? allRefs.filter((ref) => !skipFileIds.has(ref.fileId)) : allRefs;
+  let downloaded = 0;
+  let skipped = 0;
+  let failed = 0;
+  let completed = 0;
+  const failedFileIds = [];
+  const queue = [...refs];
+  const inProgress = /* @__PURE__ */ new Set();
+  const reportProgress = () => {
+    completed++;
+    onProgress?.(completed, refs.length, { downloaded, skipped, failed });
+  };
+  const processOne = async (ref) => {
+    const fileDir = path3.join(filesDir, ref.fileId);
+    if (await dirHasFiles(fileDir)) {
+      skipped++;
+      reportProgress();
+      return;
+    }
+    try {
+      const meta = await client.fetch(ENDPOINTS.FILE_DOWNLOAD(ref.fileId), {
+        retryOptions: { maxRetries: 1 }
+      });
+      if (!meta.download_url) {
+        throw new Error("File not available");
+      }
+      const buffer = await client.fetchRaw(meta.download_url, { maxRetries: 1 });
+      const filename = meta.file_name || ref.filename || ref.fileId;
+      const filePath = path3.join(fileDir, filename);
+      await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+      await fs3.writeFile(filePath, Buffer.from(buffer));
+      downloaded++;
+      if (verbose) {
+        console.log(`  Downloaded file: ${ref.fileId} \u2192 ${filename}`);
+      }
+    } catch (error) {
+      failed++;
+      failedFileIds.push(ref.fileId);
+      onError?.(ref.fileId, error);
+    } finally {
+      reportProgress();
+    }
+  };
+  while (queue.length > 0 || inProgress.size > 0) {
+    while (inProgress.size < concurrency && queue.length > 0) {
+      const ref = queue.shift();
+      const promise = processOne(ref).then(() => {
+        inProgress.delete(promise);
+      });
+      inProgress.add(promise);
+      if (queue.length > 0 && delay > 0) {
+        await sleep(delay);
+      }
+    }
+    if (inProgress.size > 0) {
+      await Promise.race(inProgress);
+    }
+  }
+  return { downloaded, skipped, failed, total: refs.length, failedFileIds };
+}
+async function findFirstFile(dir) {
+  try {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) return entry.name;
+      if (entry.isDirectory()) {
+        const nested = await findFirstFile(path3.join(dir, entry.name));
+        if (nested) return path3.join(entry.name, nested);
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function buildFileMap(filesDir) {
+  const fileMap = /* @__PURE__ */ new Map();
+  try {
+    const fileIdDirs = await fs3.readdir(filesDir, { withFileTypes: true });
+    for (const entry of fileIdDirs) {
+      if (!entry.isDirectory()) continue;
+      const fileId = entry.name;
+      const dirPath = path3.join(filesDir, fileId);
+      const relFile = await findFirstFile(dirPath);
+      if (relFile) {
+        fileMap.set(fileId, path3.join("files", fileId, relFile));
+      }
+    }
+  } catch {
+  }
+  return fileMap;
+}
+
+// src/services/markdown-service.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+function extractTextFromParts(parts, fileMap) {
+  const pieces = [];
+  for (const part of parts) {
+    if (typeof part === "string") {
+      pieces.push(part);
+    } else if (part && typeof part === "object") {
+      const obj = part;
+      if (obj.content_type === "image_asset_pointer") {
+        const pointer = obj.asset_pointer;
+        if (pointer && fileMap) {
+          const fileId = pointer.startsWith("file-service://") ? pointer.slice("file-service://".length) : null;
+          if (fileId && fileMap.has(fileId)) {
+            pieces.push(`![image](${fileMap.get(fileId)})`);
+            continue;
+          }
+        }
+        pieces.push(`![image](${pointer ?? "unknown"})`);
+      }
+    }
+  }
+  return pieces.join("\n");
+}
+function getLinearThread(mapping, currentNode) {
+  if (currentNode && mapping[currentNode]) {
+    const pathNodes = [];
+    let nodeId = currentNode;
+    while (nodeId && mapping[nodeId]) {
+      pathNodes.unshift(mapping[nodeId]);
+      nodeId = mapping[nodeId].parent;
+    }
+    return pathNodes;
+  }
+  let root;
+  for (const node of Object.values(mapping)) {
+    if (node.parent === null || node.parent === void 0) {
+      root = node;
+      break;
+    }
+  }
+  if (!root) return [];
+  const thread = [root];
+  let current = root;
+  while (current.children && current.children.length > 0) {
+    const nextId = current.children[0];
+    const next = mapping[nextId];
+    if (!next) break;
+    thread.push(next);
+    current = next;
+  }
+  return thread;
+}
+function formatRole(role) {
+  switch (role) {
+    case "user":
+      return "User";
+    case "assistant":
+      return "Assistant";
+    default:
+      return role.charAt(0).toUpperCase() + role.slice(1);
+  }
+}
+function convertConversation(detail, fileMap, options = {}) {
+  const id = options.conversationId ?? detail.conversation_id ?? detail.id ?? "unknown";
+  const title = detail.title ?? "Untitled";
+  const frontmatter = buildFrontmatter({
+    id,
+    title,
+    updated: isoOrNull(detail.update_time),
+    created: isoOrNull(detail.create_time),
+    json: relativeJsonFromMd(id)
+  });
+  const lines = [frontmatter, "", `# ${title}`];
+  const thread = getLinearThread(
+    detail.mapping,
+    detail.current_node
+  );
+  let firstMessage = true;
+  for (const node of thread) {
+    const msg = node.message;
+    if (!msg) continue;
+    const role = msg.author.role;
+    if (role === "system" || role === "tool") continue;
+    if (msg.metadata?.is_visually_hidden_from_conversation) continue;
+    if (msg.weight === 0) continue;
+    let text = "";
+    if (msg.content) {
+      if (msg.content.parts && msg.content.parts.length > 0) {
+        text = extractTextFromParts(msg.content.parts, fileMap);
+      } else if (msg.content.text) {
+        text = msg.content.text;
+      }
+    }
+    if (!text.trim()) continue;
+    if (firstMessage) {
+      lines.push("");
+      firstMessage = false;
+    } else {
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    lines.push(`**${formatRole(role)}:**`);
+    lines.push("");
+    lines.push(text);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function removeStaleMarkdown(conversationsDir, conversationId, keepName) {
+  let entries;
+  try {
+    entries = await fs4.readdir(conversationsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const needle = `id: ${conversationId}`;
+  const needleQuoted = `id: "${conversationId}"`;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    if (entry.name === keepName) continue;
+    const full = path4.join(conversationsDir, entry.name);
+    try {
+      const head = await fs4.readFile(full, "utf-8");
+      const fm = head.slice(0, 800);
+      if (fm.includes(needle) || fm.includes(needleQuoted)) {
+        await fs4.unlink(full);
+      }
+    } catch {
+    }
+  }
+  const legacySidecar = path4.join(conversationsDir, `${conversationId}.md`);
+  if (path4.basename(legacySidecar) !== keepName) {
+    await fs4.unlink(legacySidecar).catch(() => void 0);
+  }
+}
+var UUID_MD = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.md$/i;
+async function removeLegacyUuidMarkdown(conversationsDir) {
+  let entries;
+  try {
+    entries = await fs4.readdir(conversationsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && UUID_MD.test(entry.name)) {
+      await fs4.unlink(path4.join(conversationsDir, entry.name)).catch(() => void 0);
+    }
+  }
+}
+async function convertDirectory(inputDir, filesDir) {
+  const jsonFiles = await collectAllJsonFiles(inputDir);
+  const globalFileMap = filesDir ? await buildFileMap(filesDir) : null;
+  let converted = 0;
+  let errors = 0;
+  const touchedDirs = /* @__PURE__ */ new Set();
+  for (const jsonPath of jsonFiles) {
+    try {
+      const raw = await fs4.readFile(jsonPath, "utf-8");
+      const detail = JSON.parse(raw);
+      const id = detail.conversation_id ?? detail.id ?? path4.basename(jsonPath, ".json");
+      const conversationsDir = jsonPath.includes(`${path4.sep}json${path4.sep}`) ? path4.dirname(path4.dirname(jsonPath)) : path4.dirname(jsonPath);
+      touchedDirs.add(conversationsDir);
+      let fileMap;
+      if (globalFileMap && globalFileMap.size > 0) {
+        fileMap = /* @__PURE__ */ new Map();
+        for (const [fileId, filePath] of globalFileMap) {
+          const absFilePath = path4.join(inputDir, filePath);
+          fileMap.set(fileId, path4.relative(conversationsDir, absFilePath));
+        }
+      }
+      const markdown = convertConversation(detail, fileMap, {
+        conversationId: id
+      });
+      const mdName = markdownFilename(detail);
+      const mdPath = path4.join(conversationsDir, mdName);
+      await removeStaleMarkdown(conversationsDir, id, mdName);
+      await fs4.writeFile(mdPath, markdown, "utf-8");
+      converted++;
+    } catch {
+      errors++;
+    }
+  }
+  for (const dir of touchedDirs) {
+    await removeLegacyUuidMarkdown(dir);
+  }
+  return { converted, errors };
+}
+
+// src/services/storage-service.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+var StorageService = class {
+  outputDir;
+  conversationsDir;
+  constructor(outputDir, projectName) {
+    this.outputDir = outputDir;
+    this.conversationsDir = conversationsRoot(outputDir, projectName);
+  }
+  getConversationsDir() {
+    return this.conversationsDir;
+  }
+  async initialize() {
+    await fs5.mkdir(jsonDir(this.conversationsDir), { recursive: true });
+    await this.migrateLegacyJson();
+  }
+  /** Move conversations/*.json → conversations/json/*.json (one-time). */
+  async migrateLegacyJson() {
+    let entries;
+    try {
+      entries = await fs5.readdir(this.conversationsDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const from = path5.join(this.conversationsDir, entry.name);
+      const to = path5.join(jsonDir(this.conversationsDir), entry.name);
+      try {
+        await fs5.rename(from, to);
+      } catch {
+      }
+    }
+  }
+  async saveConversation(id, data) {
+    const filePath = jsonPathForId(this.conversationsDir, id);
+    await fs5.mkdir(path5.dirname(filePath), { recursive: true });
+    await fs5.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+  async saveIndex(conversations) {
+    const filePath = indexPath(this.conversationsDir);
+    await fs5.mkdir(path5.dirname(filePath), { recursive: true });
+    await fs5.writeFile(filePath, JSON.stringify(conversations, null, 2), "utf-8");
+  }
+  async saveMetadata(metadata) {
+    const filePath = path5.join(this.outputDir, "metadata.json");
+    await fs5.writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
+  }
+  async appendLog(message) {
+    const filePath = path5.join(this.outputDir, "backup.log");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    await fs5.appendFile(filePath, `[${timestamp}] ${message}
+`, "utf-8");
+  }
+  async conversationExists(id) {
+    try {
+      await fs5.access(jsonPathForId(this.conversationsDir, id));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getExistingConversationUpdateTime(id) {
+    try {
+      const content = await fs5.readFile(
+        jsonPathForId(this.conversationsDir, id),
+        "utf-8"
+      );
+      const data = JSON.parse(content);
+      return data.update_time ?? null;
+    } catch {
+      return null;
+    }
+  }
+  getConversationPath(id) {
+    return jsonPathForId(this.conversationsDir, id);
+  }
+};
+
+// src/utils/progress.ts
+import cliProgress from "cli-progress";
+import chalk from "chalk";
+function createProgressBar(total, label) {
+  const bar = new cliProgress.SingleBar({
+    format: `${chalk.cyan(label)} |${chalk.cyan("{bar}")}| {percentage}% | {value}/{total}`,
+    barCompleteChar: "\u2588",
+    barIncompleteChar: "\u2591",
+    hideCursor: true,
+    gracefulExit: true
+  });
+  bar.start(total, 0);
+  return bar;
+}
+
+// src/cli/commands/backup.ts
+function runBackupWithProgress(service, spinner, options) {
+  let listProgressBar = null;
+  let downloadProgressBar = null;
+  let listingDone = false;
+  return service.backup({
+    ...options,
+    onListProgress: (fetched, totalList) => {
+      if (!listingDone) {
+        if (!listProgressBar) {
+          spinner.stop();
+          listProgressBar = createProgressBar(totalList, "Listing    ");
+        }
+        listProgressBar.setTotal(totalList);
+        listProgressBar.update(fetched);
+        if (fetched >= totalList) {
+          listProgressBar.stop();
+          listingDone = true;
+          console.log();
+        }
+      }
+    },
+    onDownloadProgress: (completed, totalDownload) => {
+      if (listingDone) {
+        if (!downloadProgressBar) {
+          downloadProgressBar = createProgressBar(
+            totalDownload,
+            "Downloading"
+          );
+        }
+        downloadProgressBar.update(completed);
+        if (options.verbose && options.getThrottleSummary) {
+          const summary = options.getThrottleSummary();
+          if (summary && completed % 10 === 0) {
+            process.stderr.write(`
+${chalk2.dim(`[throttle] ${summary}`)}
+`);
+          }
+        }
+      }
+    },
+    onError: (id, error) => {
+      if (options.verbose) {
+        console.error(
+          chalk2.red(`
+Failed to download ${id}: ${error.message}`)
+        );
+      }
+    }
+  }).then((result) => {
+    downloadProgressBar?.stop();
+    if (options.verbose && options.getThrottleSummary) {
+      const summary = options.getThrottleSummary();
+      if (summary) {
+        console.log(chalk2.dim(`
+Throttle stats: ${summary}`));
+      }
+    }
+    return result;
+  });
+}
+async function backupCommand(options) {
+  const {
+    token,
+    output,
+    concurrency: requestedConcurrency,
+    delay: requestedDelay,
+    incremental,
+    downloadFiles: shouldDownloadFiles,
+    verbose,
+    project,
+    cdpPort
+  } = options;
+  const spinner = ora("Connecting...").start();
+  let client;
+  let mode = "token";
+  try {
+    const concurrency = Math.min(Math.max(requestedConcurrency, 1), 6);
+    const delay = Math.max(0, requestedDelay);
+    const created = await createChatGptClient({
+      token,
+      verbose,
+      cdpPort,
+      cdpPoolSize: concurrency,
+      cdpMinGapMs: Math.max(delay, 50)
+    });
+    client = created.client;
+    mode = created.mode;
+    const effectiveConcurrency = mode === "cdp" ? concurrency : requestedConcurrency;
+    const effectiveDelay = delay;
+    spinner.text = mode === "cdp" ? `Authenticating via Chromium CDP (${effectiveConcurrency} tabs)...` : "Authenticating via access token...";
+    await client.initialize();
+    spinner.succeed(
+      mode === "cdp" ? `Authenticated (Chromium CDP, ${client.cdpWorkers || effectiveConcurrency} workers)` : "Authenticated (access token)"
+    );
+    const activeClient = client;
+    const getThrottleSummary = () => activeClient.throttleStats?.summary();
+    console.log(chalk2.dim(`
+Backup settings:`));
+    console.log(chalk2.dim(`  Output: ${output}`));
+    console.log(chalk2.dim(`  Concurrency: ${effectiveConcurrency}`));
+    console.log(chalk2.dim(`  Delay/gap: ${effectiveDelay}ms`));
+    if (mode === "cdp") {
+      console.log(
+        chalk2.dim(
+          `  Transport: CDP tab pool (tune --concurrency / --delay; -v prints throttle stats)`
+        )
+      );
+    }
+    console.log(chalk2.dim(`  Incremental: ${incremental}`));
+    console.log(chalk2.dim(`  Download files: ${shouldDownloadFiles}`));
+    if (project) {
+      console.log(chalk2.dim(`  Project: ${project}`));
+    }
+    console.log();
+    if (project) {
+      const baseService = new BackupService(client, new StorageService(output));
+      spinner.start("Resolving project...");
+      const { gizmoId, name } = await baseService.resolveProjectId(project);
+      spinner.succeed(`Project: ${name}`);
+      const storage = new StorageService(output, name);
+      const service = new BackupService(client, storage);
+      spinner.start(`Backing up project "${name}"...`);
+      const result = await runBackupWithProgress(service, spinner, {
+        concurrency: effectiveConcurrency,
+        delay: effectiveDelay,
+        incremental,
+        verbose,
+        projectGizmoId: gizmoId,
+        getThrottleSummary
+      });
+      if (shouldDownloadFiles) {
+        await runFileDownloads(client, output, {
+          concurrency: effectiveConcurrency,
+          delay: effectiveDelay,
+          verbose
+        });
+      }
+      const filesDir = shouldDownloadFiles ? path6.join(output, "files") : void 0;
+      const md = await convertDirectory(output, filesDir);
+      printResult(result, output);
+      console.log(`Converted ${md.converted} conversations to markdown.`);
+      if (md.errors > 0) {
+        console.log(`Markdown conversion errors: ${chalk2.red(md.errors)}`);
+      }
+    } else {
+      let totalDownloaded = 0;
+      let totalSkipped = 0;
+      let totalFailed = 0;
+      let totalConversations = 0;
+      console.log(chalk2.bold("Main conversations\n"));
+      const mainStorage = new StorageService(output);
+      const mainService = new BackupService(client, mainStorage);
+      spinner.start("Fetching conversation list...");
+      const mainResult = await runBackupWithProgress(mainService, spinner, {
+        concurrency: effectiveConcurrency,
+        delay: effectiveDelay,
+        incremental,
+        verbose,
+        getThrottleSummary
+      });
+      totalDownloaded += mainResult.downloaded;
+      totalSkipped += mainResult.skipped;
+      totalFailed += mainResult.failed;
+      totalConversations += mainResult.totalConversations;
+      console.log();
+      console.log(
+        `  Downloaded: ${chalk2.green(mainResult.downloaded)}, Skipped: ${chalk2.yellow(mainResult.skipped)}, Failed: ${chalk2.red(mainResult.failed)}`
+      );
+      console.log();
+      spinner.start("Fetching projects...");
+      const projects = await mainService.listProjects();
+      spinner.succeed(`Found ${projects.length} projects`);
+      for (const proj of projects) {
+        const name = proj.gizmo.display.name;
+        const gizmoId = proj.gizmo.id;
+        console.log();
+        console.log(chalk2.bold(`Project: ${name}
+`));
+        const projStorage = new StorageService(output, name);
+        const projService = new BackupService(client, projStorage);
+        spinner.start(`Backing up "${name}"...`);
+        const projResult = await runBackupWithProgress(projService, spinner, {
+          concurrency: effectiveConcurrency,
+          delay: effectiveDelay,
+          incremental,
+          verbose,
+          projectGizmoId: gizmoId,
+          getThrottleSummary
+        });
+        totalDownloaded += projResult.downloaded;
+        totalSkipped += projResult.skipped;
+        totalFailed += projResult.failed;
+        totalConversations += projResult.totalConversations;
+        console.log();
+        console.log(
+          `  Downloaded: ${chalk2.green(projResult.downloaded)}, Skipped: ${chalk2.yellow(projResult.skipped)}, Failed: ${chalk2.red(projResult.failed)}`
+        );
+      }
+      if (shouldDownloadFiles) {
+        await runFileDownloads(client, output, {
+          concurrency: effectiveConcurrency,
+          delay: effectiveDelay,
+          verbose
+        });
+      }
+      const filesDir = shouldDownloadFiles ? path6.join(output, "files") : void 0;
+      const md = await convertDirectory(output, filesDir);
+      console.log();
+      console.log(chalk2.green("\nBackup completed!"));
+      console.log(`  Total conversations: ${totalConversations}`);
+      console.log(`  Downloaded: ${chalk2.green(totalDownloaded)}`);
+      if (totalSkipped > 0) {
+        console.log(`  Skipped (unchanged): ${chalk2.yellow(totalSkipped)}`);
+      }
+      if (totalFailed > 0) {
+        console.log(`  Failed: ${chalk2.red(totalFailed)}`);
+      }
+      console.log(`  Converted ${md.converted} conversations to markdown`);
+      if (md.errors > 0) {
+        console.log(`  Markdown errors: ${chalk2.red(md.errors)}`);
+      }
+      console.log(`
+Output directory: ${chalk2.cyan(output)}`);
+    }
+  } catch (error) {
+    spinner.fail("Backup failed");
+    if (error instanceof Error) {
+      if (error.name === "AuthenticationError") {
+        console.error(chalk2.red(`
+Authentication failed: ${error.message}`));
+        console.error(
+          chalk2.yellow(
+            "\nKeep Chromium CDP logged in to chatgpt.com, then retry:"
+          )
+        );
+        console.error("  prompt-exporter chromium start");
+        console.error("  prompt-exporter sync");
+        console.error(
+          chalk2.dim(
+            "\nNode Bearer requests are blocked by Cloudflare (HTTP 403)."
+          )
+        );
+      } else {
+        console.error(chalk2.red(`
+Error: ${error.message}`));
+      }
+    }
+    process.exit(1);
+  } finally {
+    await client?.close();
+  }
+}
+function printResult(result, output) {
+  console.log();
+  console.log(chalk2.green("\nBackup completed!"));
+  console.log(`  Total conversations: ${result.totalConversations}`);
+  console.log(`  Downloaded: ${chalk2.green(result.downloaded)}`);
+  if (result.skipped > 0) {
+    console.log(`  Skipped (unchanged): ${chalk2.yellow(result.skipped)}`);
+  }
+  if (result.failed > 0) {
+    console.log(`  Failed: ${chalk2.red(result.failed)}`);
+    console.log(chalk2.dim(`  See ${output}/backup.log for details`));
+  }
+  console.log(`
+Output directory: ${chalk2.cyan(output)}`);
+}
+async function loadFailedFiles(output) {
+  try {
+    const raw = await fs6.readFile(path6.join(output, "metadata.json"), "utf-8");
+    const metadata = JSON.parse(raw);
+    if (Array.isArray(metadata.failedFiles)) {
+      return new Set(metadata.failedFiles);
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
+async function saveFailedFiles(output, failedFileIds) {
+  const metadataPath = path6.join(output, "metadata.json");
+  let metadata = {};
+  try {
+    const raw = await fs6.readFile(metadataPath, "utf-8");
+    metadata = JSON.parse(raw);
+  } catch {
+  }
+  metadata.failedFiles = failedFileIds;
+  await fs6.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+}
+async function runFileDownloads(client, output, options) {
+  console.log();
+  const spinner = ora("Scanning conversations for file references...").start();
+  const refs = await scanAllConversations(output);
+  const skipFileIds = await loadFailedFiles(output);
+  const skippedKnown = skipFileIds.size > 0 ? refs.filter((r) => skipFileIds.has(r.fileId)).length : 0;
+  const activeCount = refs.length - skippedKnown;
+  spinner.succeed(
+    `Found ${refs.length} file references` + (skippedKnown > 0 ? ` (${skippedKnown} previously failed, skipped)` : "") + "\n"
+  );
+  if (activeCount === 0) return;
+  const state = { bar: null };
+  const errors = [];
+  const result = await downloadFiles(client, refs, output, {
+    concurrency: options.concurrency,
+    delay: options.delay,
+    verbose: options.verbose,
+    skipFileIds,
+    onProgress: (completed, total) => {
+      if (!state.bar) {
+        state.bar = createProgressBar(total, "Files      ");
+      }
+      state.bar.update(completed);
+    },
+    onError: (fileId, error) => {
+      errors.push({ fileId, message: error.message });
+    }
+  });
+  state.bar?.stop();
+  console.log();
+  console.log(
+    `  Downloaded: ${chalk2.green(result.downloaded)}, Skipped: ${chalk2.yellow(result.skipped)}, Failed: ${chalk2.red(result.failed)}`
+  );
+  const allFailed = [...skipFileIds, ...result.failedFileIds];
+  await saveFailedFiles(output, allFailed);
+  if (errors.length > 0) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const e of errors) {
+      const list = grouped.get(e.message) ?? [];
+      list.push(e.fileId);
+      grouped.set(e.message, list);
+    }
+    for (const [message, fileIds] of grouped) {
+      console.log(chalk2.red(`    ${fileIds.length} files: ${message}`));
+      if (options.verbose) {
+        for (const id of fileIds) {
+          console.log(chalk2.dim(`      ${id}`));
+        }
+      }
+    }
+  }
+}
+
+// src/cli/commands/chromium.ts
+import { spawn } from "child_process";
+import fs7 from "fs/promises";
+import path7 from "path";
+import chalk3 from "chalk";
+
+// src/utils/browser.ts
+import { access } from "fs/promises";
+import { constants } from "fs";
+function chromiumCandidates() {
+  return [
+    process.env.PROMPT_EXPORTER_BROWSER,
+    process.env.CHATGPT_EXPORTER_BROWSER,
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/google-chrome"
+  ].filter((v) => Boolean(v));
+}
+async function resolveBrowser() {
+  for (const candidate of chromiumCandidates()) {
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  throw new Error(
+    "Chromium not found. Install the chromium package (Arch: pacman -S chromium) or set PROMPT_EXPORTER_BROWSER to a Chromium-based browser path."
+  );
+}
+
+// src/cli/commands/chromium.ts
+function printNextSteps() {
+  console.log("Then run:");
+  console.log(chalk3.cyan("  prompt-exporter token"));
+  console.log("to read accessToken from this browser session.");
+  console.log("");
+  console.log("Then sync conversations:");
+  console.log(chalk3.cyan("  prompt-exporter sync"));
+  console.log("");
+}
+async function isProfileLocked(userDataDir) {
+  for (const name of ["SingletonLock", "lockfile", "SingletonSocket"]) {
+    try {
+      await fs7.access(path7.join(userDataDir, name));
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function reuseExistingCdp(port, url, existing) {
+  const info = existing ?? await getCdpEndpointInfo(port);
+  if (!info) {
+    throw new Error(`No CDP endpoint on port ${port}`);
+  }
+  console.log(chalk3.green(`Reusing Chromium CDP on port ${port}.`));
+  console.log(chalk3.dim(`  CDP:  http://127.0.0.1:${port}`));
+  if (info.Browser) {
+    console.log(chalk3.dim(`  Browser: ${info.Browser}`));
+  }
+  if (info.webSocketDebuggerUrl) {
+    console.log(chalk3.dim(`  WS: ${info.webSocketDebuggerUrl}`));
+  }
+  console.log("");
+  const targets = await listCdpTargets(port);
+  const pages = targets.filter((t) => t.type === "page" || t.type === "tab");
+  const exact = pages.find((t) => t.url === url || t.url.startsWith(url + "?"));
+  const chatgpt = exact ?? (isChatGptUrl(url) ? pages.find((t) => isChatGptUrl(t.url)) : void 0);
+  if (chatgpt) {
+    await activateCdpTarget(port, chatgpt.id);
+    console.log(chalk3.green(`Focused existing tab in that browser.`));
+    console.log(chalk3.dim(`  ${chatgpt.title || chatgpt.id}`));
+    console.log(chalk3.dim(`  ${chatgpt.url}`));
+  } else {
+    const created = await openCdpTab(port, url);
+    console.log(chalk3.green(`Opened a new tab in that browser (same session).`));
+    console.log(chalk3.dim(`  ${created.url || url}`));
+  }
+  console.log("");
+  printNextSteps();
+}
+async function chromiumStartCommand(options) {
+  let port = options.port || DEFAULT_CDP_PORT;
+  const url = options.url ?? "https://chatgpt.com/";
+  const userSetPort = options.port !== void 0 && options.port !== DEFAULT_CDP_PORT;
+  let existing = await getCdpEndpointInfo(port);
+  if (!existing && !userSetPort && !options.force) {
+    const found = await discoverCdpPort(port);
+    if (found !== null) {
+      port = found;
+      existing = await getCdpEndpointInfo(port);
+    }
+  }
+  if (existing && !options.force) {
+    await reuseExistingCdp(port, url, existing);
+    return;
+  }
+  const browser = await resolveBrowser();
+  const { dir: userDataDir, mode } = resolveChromiumUserDataDir({
+    isolated: options.isolated,
+    userDataDir: options.userDataDir,
+    browserPath: browser
+  });
+  await fs7.mkdir(userDataDir, { recursive: true });
+  if (await isProfileLocked(userDataDir)) {
+    const again = await getCdpEndpointInfo(port);
+    if (again && !options.force) {
+      await reuseExistingCdp(port, url, again);
+      return;
+    }
+    console.log(
+      chalk3.yellow("Chromium profile is already in use (browser running).")
+    );
+    console.log(chalk3.dim(`  Profile: ${userDataDir}`));
+    console.log("");
+    console.log(
+      chalk3.yellow(
+        `No CDP answered on port ${port}, so this running browser cannot be controlled.`
+      )
+    );
+    console.log("");
+    console.log("Either:");
+    console.log(
+      `  \u2022 Point at the port where CDP is listening:  prompt-exporter chromium start --port <PORT>`
+    );
+    console.log(
+      "  \u2022 Or quit Chromium and start it with CDP:     prompt-exporter chromium start"
+    );
+    console.log("");
+    process.exitCode = 1;
+    return;
+  }
+  const args = [
+    `--remote-debugging-port=${port}`,
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check"
+  ];
+  if (options.headless) {
+    args.push("--headless=new");
+  }
+  args.push(url);
+  if (options.print) {
+    console.log(chalk3.dim(`Browser: ${browser}`));
+    console.log(chalk3.dim(`Args: ${args.join(" ")}`));
+  }
+  console.log(chalk3.bold("Starting Chromium with remote debugging\u2026"));
+  console.log(chalk3.dim(`  CDP:     http://127.0.0.1:${port}`));
+  console.log(
+    chalk3.dim(
+      `  Profile: ${userDataDir}` + (mode === "system" ? " (system \u2014 your normal login)" : mode === "isolated" ? " (isolated)" : " (custom)")
+    )
+  );
+  console.log("");
+  printNextSteps();
+  const child = spawn(browser, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  console.log(chalk3.green(`Chromium started (pid ${child.pid ?? "unknown"}).`));
+}
+
+// src/cli/commands/list.ts
+import chalk4 from "chalk";
+import ora2 from "ora";
+async function listCommand(options) {
+  const { token, delay, verbose, json, project, cdpPort } = options;
+  const spinner = ora2("Connecting...").start();
+  const { client } = await createChatGptClient({ token, verbose, cdpPort });
+  const storage = new StorageService(getDefaultDataDir());
+  const service = new BackupService(client, storage);
+  try {
+    await client.initialize();
+    let conversations;
+    if (project) {
+      spinner.text = "Resolving project...";
+      const { gizmoId, name } = await service.resolveProjectId(project);
+      spinner.text = `Fetching conversations from project "${name}"...`;
+      let lastReported = 0;
+      conversations = await service.listProjectConversations(gizmoId, {
+        delay,
+        onListProgress: (fetched, total) => {
+          if (fetched !== lastReported) {
+            spinner.text = `Fetching conversations from "${name}"... ${fetched}`;
+            lastReported = fetched;
+          }
+        }
+      });
+      spinner.succeed(`Found ${conversations.length} conversations in project "${name}"`);
+    } else {
+      spinner.text = "Fetching conversations...";
+      let lastReported = 0;
+      conversations = await service.listConversations({
+        delay,
+        onListProgress: (fetched, total) => {
+          if (fetched !== lastReported) {
+            spinner.text = `Fetching conversations... ${fetched}/${total}`;
+            lastReported = fetched;
+          }
+        }
+      });
+      spinner.succeed(`Found ${conversations.length} conversations`);
+    }
+    if (json) {
+      console.log(JSON.stringify(conversations, null, 2));
+    } else {
+      console.log();
+      for (const conv of conversations) {
+        const title = conv.title ?? chalk4.dim("(untitled)");
+        const date = conv.update_time ? new Date(
+          typeof conv.update_time === "number" ? conv.update_time * 1e3 : conv.update_time
+        ).toLocaleDateString() : "unknown date";
+        console.log(`${chalk4.cyan(conv.id)} ${title} ${chalk4.dim(`[${date}]`)}`);
+      }
+      console.log();
+      console.log(chalk4.green(`Total: ${conversations.length} conversations`));
+    }
+  } catch (error) {
+    spinner.fail("Failed to list conversations");
+    if (error instanceof Error) {
+      if (error.name === "AuthenticationError") {
+        console.error(chalk4.red(`
+Authentication failed: ${error.message}`));
+        console.error(
+          chalk4.yellow(
+            "\nKeep Chromium CDP logged in to chatgpt.com, then retry:"
+          )
+        );
+        console.error("  prompt-exporter chromium start");
+        console.error("  prompt-exporter list");
+      } else {
+        console.error(chalk4.red(`
+Error: ${error.message}`));
+      }
+    }
+    process.exit(1);
+  } finally {
+    await client.close();
+  }
+}
+
+// src/cli/commands/projects.ts
+import chalk5 from "chalk";
+import ora3 from "ora";
+async function projectsCommand(options) {
+  const { token, verbose, json, cdpPort } = options;
+  const spinner = ora3("Connecting...").start();
+  const { client } = await createChatGptClient({ token, verbose, cdpPort });
+  const storage = new StorageService(getDefaultDataDir());
+  const service = new BackupService(client, storage);
+  try {
+    await client.initialize();
+    spinner.text = "Fetching projects...";
+    const projects = await service.listProjects();
+    spinner.succeed(`Found ${projects.length} projects`);
+    if (json) {
+      const output = projects.map((p) => ({
+        id: p.gizmo.id,
+        name: p.gizmo.display.name,
+        num_interactions: p.gizmo.num_interactions,
+        last_interacted_at: p.gizmo.last_interacted_at,
+        is_archived: p.gizmo.is_archived
+      }));
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      console.log();
+      for (const project of projects) {
+        const gizmo = project.gizmo;
+        const name = gizmo.display.name;
+        const id = gizmo.id;
+        const lastInteracted = gizmo.last_interacted_at ? new Date(gizmo.last_interacted_at).toLocaleDateString() : "never";
+        console.log(
+          `${chalk5.cyan(id)} ${chalk5.bold(name)} ${chalk5.dim(`[last: ${lastInteracted}]`)}`
+        );
+      }
+      console.log();
+      console.log(chalk5.green(`Total: ${projects.length} projects`));
+    }
+  } catch (error) {
+    spinner.fail("Failed to list projects");
+    if (error instanceof Error) {
+      console.error(chalk5.red(`
+Error: ${error.message}`));
+      if (error.name === "AuthenticationError") {
+        console.error(chalk5.yellow("\nKeep Chromium CDP logged in, then retry:"));
+        console.error("  prompt-exporter chromium start");
+        console.error("  prompt-exporter projects");
+      }
+    }
+    process.exit(1);
+  } finally {
+    await client.close();
+  }
+}
+
+// src/cli/commands/token.ts
+import { spawn as spawn2 } from "child_process";
+import chalk6 from "chalk";
+
+// src/utils/cdp-session.ts
+var SESSION_URL = "https://chatgpt.com/api/auth/session";
+var APP_URL = "https://chatgpt.com/";
+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();
+  }
+}
+function normalizeProbe(raw) {
+  if (!raw || typeof raw !== "object") {
+    return {
+      accessToken: null,
+      loggedIn: false,
+      anonymousBannerOnly: false,
+      keys: [],
+      error: "empty session payload"
+    };
+  }
+  const obj = raw;
+  const keys = Object.keys(obj);
+  const token = typeof obj.accessToken === "string" ? obj.accessToken : typeof obj.access_token === "string" ? obj.access_token : null;
+  const validToken = token && token.startsWith("eyJ") ? token : null;
+  const anonymousBannerOnly = !validToken && keys.length === 1 && keys[0] === "WARNING_BANNER";
+  return {
+    accessToken: validToken,
+    loggedIn: Boolean(validToken),
+    anonymousBannerOnly,
+    keys
+  };
+}
+async function probeSessionViaCdp(webSocketDebuggerUrl) {
+  try {
+    return await withCdpSocket(webSocketDebuggerUrl, async (send) => {
+      await send("Runtime.enable");
+      const result = await send("Runtime.evaluate", {
+        expression: `(() => {
+          const tryParse = (text) => {
+            if (!text || typeof text !== 'string') return null;
+            const trimmed = text.trim();
+            try { return JSON.parse(trimmed); } catch {}
+            // Pretty-printed / viewer noise: pull accessToken via regex
+            const m = trimmed.match(/"accessToken"\\s*:\\s*"(eyJ[^"]+)"/);
+            if (m) return { accessToken: m[1], __via: 'regex' };
+            return null;
+          };
+
+          const candidates = [];
+          if (document.body && document.body.innerText) candidates.push(document.body.innerText);
+          if (document.body && document.body.textContent) candidates.push(document.body.textContent);
+          const pre = document.querySelector('pre');
+          if (pre && pre.textContent) candidates.push(pre.textContent);
+          // Chrome JSON viewer / plain document
+          const html = document.documentElement ? document.documentElement.innerText : '';
+          if (html) candidates.push(html);
+
+          for (const c of candidates) {
+            const parsed = tryParse(c);
+            if (parsed && parsed.accessToken) return Promise.resolve(parsed);
+          }
+
+          return fetch('/api/auth/session', {
+            credentials: 'include',
+            headers: { Accept: 'application/json' },
+            cache: 'no-store',
+          })
+            .then(async (r) => {
+              const text = await r.text();
+              const parsed = tryParse(text);
+              if (parsed) return parsed;
+              try { return JSON.parse(text); } catch {
+                return { __error: 'unparseable session response', __preview: text.slice(0, 120) };
+              }
+            })
+            .catch((e) => ({ __error: String(e) }));
+        })()`,
+        awaitPromise: true,
+        returnByValue: true
+      });
+      const value = result.result?.value;
+      if (value && typeof value === "object" && "__error" in value) {
+        return {
+          accessToken: null,
+          loggedIn: false,
+          anonymousBannerOnly: false,
+          keys: [],
+          error: String(value.__error)
+        };
+      }
+      return normalizeProbe(value);
+    });
+  } catch (error) {
+    return {
+      accessToken: null,
+      loggedIn: false,
+      anonymousBannerOnly: false,
+      keys: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function ensureChatGptAppTab(port) {
+  const targets = await listCdpTargets(port);
+  const pages = targets.filter((t) => t.type === "page" || t.type === "tab");
+  const existing = pages.find(
+    (t) => t.url === APP_URL || t.url.startsWith("https://chatgpt.com/?") || t.url.startsWith("https://chatgpt.com/c/") || t.url.startsWith("https://chatgpt.com/g/")
+  );
+  if (existing?.webSocketDebuggerUrl) {
+    await activateCdpTarget(port, existing.id);
+    return existing;
+  }
+  if (existing) {
+    await activateCdpTarget(port, existing.id);
+    return existing;
+  }
+  return openCdpTab(port, APP_URL);
+}
+async function prepareSessionTarget(port) {
+  const { target, reused } = await ensureChatGptSessionTab(port, SESSION_URL);
+  const refreshed = (await listCdpTargets(port)).find((t) => t.id === target.id) ?? target;
+  let wsUrl = refreshed.webSocketDebuggerUrl;
+  if (!wsUrl) {
+    return {
+      target: refreshed,
+      reused,
+      probe: {
+        accessToken: null,
+        loggedIn: false,
+        anonymousBannerOnly: false,
+        keys: [],
+        error: "No DevTools WebSocket for tab"
+      }
+    };
+  }
+  let probe = await probeSessionViaCdp(wsUrl);
+  if (probe.loggedIn) {
+    return { target: refreshed, reused, probe };
+  }
+  if (!refreshed.url.startsWith(SESSION_URL)) {
+    await cdpNavigate(wsUrl, SESSION_URL);
+    const afterNav = (await listCdpTargets(port)).find((t) => t.id === refreshed.id) ?? refreshed;
+    wsUrl = afterNav.webSocketDebuggerUrl ?? wsUrl;
+    probe = await probeSessionViaCdp(wsUrl);
+    if (probe.loggedIn) {
+      return { target: afterNav, reused, probe };
+    }
+  }
+  await cdpNavigate(wsUrl, SESSION_URL);
+  const afterReload = (await listCdpTargets(port)).find((t) => t.id === refreshed.id) ?? refreshed;
+  wsUrl = afterReload.webSocketDebuggerUrl ?? wsUrl;
+  await new Promise((r) => setTimeout(r, 400));
+  probe = await probeSessionViaCdp(wsUrl);
+  return { target: afterReload, reused, probe };
+}
+async function waitForAccessToken(port, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 18e4;
+  const intervalMs = options.intervalMs ?? 2e3;
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const { probe } = await prepareSessionTarget(port);
+    options.onTick?.(probe);
+    if (probe.loggedIn && probe.accessToken) {
+      return probe;
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  const last = await prepareSessionTarget(port);
+  return last.probe;
+}
+
+// src/cli/commands/token.ts
+async function persistAndAnnounce(token, show) {
+  const file = await saveToken(token);
+  console.log(chalk6.green("Saved accessToken for sync."));
+  console.log(chalk6.dim(`  ${file}`));
+  console.log(chalk6.dim(`  preview: ${token.slice(0, 16)}\u2026 (${token.length} chars)`));
+  console.log("");
+  if (show) {
+    console.log(`  export PROMPT_EXPORTER_CHATGPT_TOKEN="${token}"`);
+    console.log("");
+  }
+  console.log("You can sync right away (no manual export needed):");
+  console.log(chalk6.cyan("  prompt-exporter sync"));
+}
+function printManualSteps() {
+  console.log("Steps:");
+  console.log("  1. Ensure CDP Chromium shows https://chatgpt.com/api/auth/session JSON");
+  console.log("  2. Re-run: prompt-exporter token");
+  console.log("  3. prompt-exporter sync");
+}
+async function tokenCommand(options = {}) {
+  let port = options.port ?? DEFAULT_CDP_PORT;
+  const wait = options.wait ?? true;
+  const timeoutMs = options.timeoutMs ?? 18e4;
+  const show = options.show ?? false;
+  if (!await isCdpRunning(port)) {
+    const found = await discoverCdpPort(port);
+    if (found !== null) {
+      port = found;
+    }
+  }
+  if (!await isCdpRunning(port)) {
+    console.log(
+      chalk6.yellow(
+        `No CDP on port ${port}. Start one with: prompt-exporter chromium start`
+      )
+    );
+    console.log(chalk6.dim("Opening a separate Chromium window as fallback\u2026"));
+    console.log("");
+    const browser = await resolveBrowser();
+    console.log(`Open ${SESSION_URL}, then re-run prompt-exporter token`);
+    console.log("");
+    printManualSteps();
+    if (options.print) console.log(`Browser: ${browser}`);
+    const child = spawn2(browser, ["--new-window", SESSION_URL], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    return;
+  }
+  const info = await getCdpEndpointInfo(port);
+  console.log(chalk6.green(`Using existing Chromium CDP on port ${port}.`));
+  if (info?.Browser) {
+    console.log(chalk6.dim(`  Browser: ${info.Browser}`));
+  }
+  console.log(chalk6.dim(`  Token file: ${getTokenPath()}`));
+  console.log("");
+  try {
+    const { target, reused, probe } = await prepareSessionTarget(port);
+    console.log(
+      chalk6.dim(
+        `${reused ? "Reused" : "Opened"} tab: ${target.title || target.id}`
+      )
+    );
+    console.log(chalk6.dim(`  ${target.url || SESSION_URL}`));
+    console.log("");
+    if (probe.loggedIn && probe.accessToken) {
+      await persistAndAnnounce(probe.accessToken, show);
+      return;
+    }
+    if (probe.anonymousBannerOnly || !probe.loggedIn) {
+      console.log(
+        chalk6.yellow(
+          "No accessToken in the session tab yet (anonymous / not logged in)."
+        )
+      );
+      if (probe.keys.length) {
+        console.log(chalk6.dim(`  session keys: ${probe.keys.join(", ")}`));
+      }
+      if (probe.error) {
+        console.log(chalk6.dim(`  ${probe.error}`));
+      }
+      console.log("");
+      const appTab = await ensureChatGptAppTab(port);
+      console.log(chalk6.cyan(`Focused ChatGPT for login: ${APP_URL}`));
+      console.log(chalk6.dim(`  Tab: ${appTab.url || APP_URL}`));
+      console.log("");
+      if (!wait) {
+        printManualSteps();
+        return;
+      }
+      console.log(
+        chalk6.bold(
+          `Waiting up to ${Math.round(timeoutMs / 1e3)}s for login, then re-reading session\u2026`
+        )
+      );
+      console.log(chalk6.dim("Press Ctrl+C to cancel."));
+      console.log("");
+      const finalProbe = await waitForAccessToken(port, {
+        timeoutMs,
+        intervalMs: 2500,
+        onTick: (p) => {
+          if (p.loggedIn) return;
+          process.stdout.write(
+            chalk6.dim(
+              `  waiting\u2026 (${p.anonymousBannerOnly ? "banner-only" : p.keys.join(",") || "no token"})\r`
+            )
+          );
+        }
+      });
+      process.stdout.write("\n");
+      if (finalProbe.loggedIn && finalProbe.accessToken) {
+        await persistAndAnnounce(finalProbe.accessToken, show);
+        return;
+      }
+      console.log(chalk6.red("Timed out \u2014 accessToken not found."));
+      printManualSteps();
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk6.yellow("Could not read accessToken from the session page."));
+    if (probe.error) console.log(chalk6.dim(`  ${probe.error}`));
+    printManualSteps();
+    process.exitCode = 1;
+  } catch (error) {
+    console.error(
+      chalk6.red(
+        `CDP session failed: ${error instanceof Error ? error.message : error}`
+      )
+    );
+    printManualSteps();
+    process.exitCode = 1;
+  }
+}
+
+// src/sources/chatgpt/index.ts
+var chatgptSource = {
+  id: "chatgpt",
+  label: "ChatGPT",
+  description: "chatgpt.com conversation history via Chromium CDP",
+  defaultDataDir() {
+    return getSourceDataDir("chatgpt");
+  }
+};
+
+// src/sources/registry.ts
+var sources = [chatgptSource];
+function listSources() {
+  return sources.map(({ id, label, description }) => ({
+    id,
+    label,
+    description
+  }));
+}
+function getSource(id) {
+  const found = sources.find((s) => s.id === id);
+  if (!found) {
+    const known = sources.map((s) => s.id).join(", ");
+    throw new Error(`Unknown source "${id}". Available: ${known}`);
+  }
+  return found;
+}
+function resolveSourceId(raw) {
+  const id = raw?.trim() || "chatgpt";
+  getSource(id);
+  return id;
+}
+
+// src/cli/index.ts
+function parsePort(value) {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isFinite(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port: ${value}`);
+  }
+  return port;
+}
+function createCli() {
+  const program2 = new Command();
+  program2.name("prompt-exporter").description(
+    "Export and sync AI conversation prompts from multiple sources to local JSON + Markdown"
+  ).version("2.0.0").hook("preAction", async () => {
+    await ensureHomeLayout();
+  }).addHelpText(
+    "after",
+    [
+      "",
+      "Environment:",
+      "  PROMPT_EXPORTER_HOME           Override ~/.prompt-exporter",
+      "  PROMPT_EXPORTER_DATA            Parent of source dirs (default: home)",
+      "  PROMPT_EXPORTER_BROWSER         Chromium binary path",
+      "  PROMPT_EXPORTER_CDP_PORT        Preferred CDP port (auto-discovers 9222/9223/\u2026)",
+      "  PROMPT_EXPORTER_CHATGPT_TOKEN  Optional Bearer fallback for chatgpt source",
+      "",
+      "Typical flow:",
+      "  prompt-exporter chromium start",
+      "  prompt-exporter sync --source chatgpt",
+      "",
+      "Data: ~/.prompt-exporter/{source}/conversations/"
+    ].join("\n")
+  ).action(() => {
+    program2.help();
+  });
+  const resolveOptionalToken = async (options) => {
+    if (options.token?.trim()) return options.token.trim();
+    const sourceId = resolveSourceId(options.source);
+    if (sourceId === "chatgpt") {
+      if (process.env.PROMPT_EXPORTER_CHATGPT_TOKEN?.trim()) {
+        return process.env.PROMPT_EXPORTER_CHATGPT_TOKEN.trim();
+      }
+      if (process.env.CHATGPT_TOKEN?.trim()) {
+        return process.env.CHATGPT_TOKEN.trim();
+      }
+    }
+    return await loadSavedToken(sourceId) ?? void 0;
+  };
+  const resolveOutput = (options) => {
+    if (options.output?.trim()) return options.output.trim();
+    return getSource(resolveSourceId(options.source)).defaultDataDir();
+  };
+  const sourceOption = (cmd) => cmd.option(
+    "-s, --source <id>",
+    "Prompt source",
+    DEFAULT_SOURCE_ID
+  );
+  program2.command("sources").description("List available prompt sources").option("--json", "Output as JSON", false).action((options) => {
+    const rows = listSources();
+    if (options.json) {
+      console.log(JSON.stringify(rows, null, 2));
+      return;
+    }
+    console.log();
+    for (const s of rows) {
+      console.log(`  ${s.id.padEnd(12)} ${s.label} \u2014 ${s.description}`);
+    }
+    console.log();
+  });
+  const chromium = program2.command("chromium").description("Manage Chromium with remote debugging (CDP)");
+  chromium.command("start").description(
+    `Start Chromium with remote debugging (default port ${DEFAULT_CDP_PORT})`
+  ).option(
+    "--port <PORT>",
+    "Remote debugging (CDP) port",
+    parsePort,
+    DEFAULT_CDP_PORT
+  ).option(
+    "--isolated",
+    "Use a separate empty profile under ~/.prompt-exporter/chromium",
+    false
+  ).option(
+    "--user-data-dir <dir>",
+    "Chromium user-data-dir (default: system profile, e.g. ~/.config/chromium)"
+  ).option("--headless", "Run Chromium headless", false).option("--url <url>", "Initial URL", "https://chatgpt.com/").option("--force", "Start even if CDP is already running on the port", false).option("--print", "Print resolved browser path and args", false).addHelpText(
+    "after",
+    [
+      "",
+      "If Chromium is already running with CDP on this port, it is reused.",
+      "Otherwise starts Chromium with your system profile.",
+      "",
+      "Examples:",
+      "  prompt-exporter chromium start",
+      "  prompt-exporter chromium start --port 9222",
+      "  prompt-exporter chromium start --isolated"
+    ].join("\n")
+  ).action(async (options) => {
+    await chromiumStartCommand({
+      port: options.port,
+      headless: options.headless,
+      url: options.url,
+      print: options.print,
+      force: options.force,
+      isolated: options.isolated,
+      userDataDir: options.userDataDir
+    });
+  });
+  sourceOption(
+    program2.command("token").description("Get accessToken from the CDP Chromium session (chatgpt)").option(
+      "--port <PORT>",
+      "CDP port of an already-running Chromium",
+      parsePort,
+      DEFAULT_CDP_PORT
+    ).option(
+      "--no-wait",
+      "Do not wait for interactive login; exit immediately if not logged in"
+    ).option(
+      "--timeout <ms>",
+      "Login wait timeout in ms",
+      (v) => parseInt(v, 10),
+      18e4
+    ).option("--print", "Print resolved browser path", false).option(
+      "--show",
+      "Print full export PROMPT_EXPORTER_CHATGPT_TOKEN=... line",
+      false
+    ).action(async (options) => {
+      resolveSourceId(options.source);
+      await tokenCommand({
+        print: options.print,
+        port: options.port,
+        wait: options.wait !== false,
+        timeoutMs: options.timeout,
+        show: options.show
+      });
+    })
+  );
+  const runBackup = async (options) => {
+    const sourceId = resolveSourceId(options.source);
+    if (sourceId !== "chatgpt") {
+      throw new Error(
+        `Source "${sourceId}" is registered but sync is not implemented yet`
+      );
+    }
+    const token = await resolveOptionalToken(options);
+    await backupCommand({
+      token,
+      output: resolveOutput(options),
+      concurrency: options.concurrency,
+      delay: options.delay,
+      incremental: options.incremental,
+      downloadFiles: options.downloadFiles,
+      verbose: options.verbose,
+      project: options.project,
+      cdpPort: options.port
+    });
+  };
+  const backupOpts = (cmd) => sourceOption(cmd).option(
+    "-t, --token <token>",
+    "Optional Bearer fallback; not needed with CDP"
+  ).option(
+    "--port <PORT>",
+    "Preferred Chromium CDP port (auto-discovers if idle)",
+    parsePort
+  ).option(
+    "-o, --output <dir>",
+    "Source output directory (default: ~/.prompt-exporter/{source})"
+  ).option(
+    "--concurrency <n>",
+    "Parallel downloads / CDP tabs (default 3, max 6)",
+    (v) => parseInt(v, 10),
+    3
+  ).option(
+    "--delay <ms>",
+    "Min gap between starting requests in ms",
+    (v) => parseInt(v, 10),
+    200
+  ).option(
+    "--no-incremental",
+    "Re-download all conversations (default: skip unchanged)"
+  ).option("--download-files", "Download file attachments and images", false).option(
+    "--project <name-or-id>",
+    "Only backup conversations from a specific project"
+  ).option("-v, --verbose", "Verbose logging", false);
+  backupOpts(
+    program2.command("sync").description(
+      `Sync conversations (default: ${getSourceDataDir(DEFAULT_SOURCE_ID)})`
+    ).addHelpText(
+      "after",
+      [
+        "",
+        "Examples:",
+        "  prompt-exporter sync",
+        "  prompt-exporter sync --source chatgpt",
+        "  prompt-exporter sync --download-files",
+        "  prompt-exporter sync --no-incremental"
+      ].join("\n")
+    ).action(async (options) => {
+      await runBackup(options);
+    })
+  );
+  backupOpts(
+    program2.command("backup").description("Alias for sync").action(async (options) => {
+      await runBackup(options);
+    })
+  );
+  sourceOption(
+    program2.command("list").description("List conversations without downloading").option("-t, --token <token>", "Optional Bearer fallback").option(
+      "--port <PORT>",
+      "Preferred Chromium CDP port (auto-discovers if idle)",
+      parsePort
+    ).option(
+      "--delay <ms>",
+      "Delay between requests in ms",
+      (v) => parseInt(v, 10),
+      500
+    ).option(
+      "--project <name-or-id>",
+      "List conversations from a specific project"
+    ).option("-v, --verbose", "Verbose logging", false).option("--json", "Output as JSON", false).action(async (options) => {
+      const sourceId = resolveSourceId(options.source);
+      if (sourceId !== "chatgpt") {
+        throw new Error(`Source "${sourceId}" list not implemented yet`);
+      }
+      const token = await resolveOptionalToken(options);
+      await listCommand({
+        token,
+        delay: options.delay,
+        verbose: options.verbose,
+        json: options.json,
+        project: options.project,
+        cdpPort: options.port
+      });
+    })
+  );
+  sourceOption(
+    program2.command("projects").description("List all projects").option("-t, --token <token>", "Optional Bearer fallback").option(
+      "--port <PORT>",
+      "Preferred Chromium CDP port (auto-discovers if idle)",
+      parsePort
+    ).option("-v, --verbose", "Verbose logging", false).option("--json", "Output as JSON", false).action(async (options) => {
+      const sourceId = resolveSourceId(options.source);
+      if (sourceId !== "chatgpt") {
+        throw new Error(`Source "${sourceId}" projects not implemented yet`);
+      }
+      const token = await resolveOptionalToken(options);
+      await projectsCommand({
+        token,
+        verbose: options.verbose,
+        json: options.json,
+        cdpPort: options.port
+      });
+    })
+  );
+  return program2;
+}
+
+// src/index.ts
+process.on("SIGINT", () => process.exit(130));
+var program = createCli();
+program.parse();