perplexity-user-mcp 0.8.36

package/dist/chunk-XKSWCEGI.mjs

@@ -0,0 +1,168 @@
+// src/profiles.js
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+var NAME_RE = /^[a-z0-9_-]{1,32}$/;
+function getConfigDir() {
+  return process.env.PERPLEXITY_CONFIG_DIR || join(homedir(), ".perplexity-mcp");
+}
+function getProfilesDir() {
+  return join(getConfigDir(), "profiles");
+}
+function getProfilePaths(name) {
+  const dir = join(getProfilesDir(), name);
+  return {
+    dir,
+    meta: join(dir, "meta.json"),
+    vault: join(dir, "vault.enc"),
+    vaultPlain: join(dir, "vault.json"),
+    browserData: join(dir, "browser-data"),
+    modelsCache: join(dir, "models-cache.json"),
+    history: join(dir, "history"),
+    attachments: join(dir, "attachments"),
+    researches: join(dir, "researches"),
+    reinit: join(dir, ".reinit")
+  };
+}
+function validateName(name) {
+  if (!name || typeof name !== "string") return "Profile name is required.";
+  if (name.length > 32) return "Profile name must be 32 characters or fewer.";
+  if (name !== name.toLowerCase()) return "Profile name must be lowercase.";
+  if (!NAME_RE.test(name)) {
+    return "Profile name must contain only lowercase letters, digits, hyphens, and underscores. Invalid characters detected.";
+  }
+  return null;
+}
+function readMeta(name) {
+  const p = getProfilePaths(name).meta;
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeMeta(name, meta) {
+  const paths = getProfilePaths(name);
+  if (!existsSync(paths.dir)) mkdirSync(paths.dir, { recursive: true });
+  writeFileSync(paths.meta + ".tmp", JSON.stringify(meta, null, 2) + "\n");
+  renameSync(paths.meta + ".tmp", paths.meta);
+}
+function createProfile(name, opts = {}) {
+  const err = validateName(name);
+  if (err) throw new Error(err);
+  const paths = getProfilePaths(name);
+  if (existsSync(paths.dir)) throw new Error(`Profile '${name}' already exists.`);
+  mkdirSync(paths.dir, { recursive: true });
+  const meta = {
+    name,
+    displayName: opts.displayName ?? name,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    loginMode: opts.loginMode ?? "manual"
+  };
+  writeMeta(name, meta);
+  return meta;
+}
+function listProfiles() {
+  const dir = getProfilesDir();
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => readMeta(d.name)).filter(Boolean);
+}
+function getProfile(name) {
+  return readMeta(name);
+}
+function deleteProfile(name) {
+  const wasActive = getActiveName() === name;
+  const dir = getProfilePaths(name).dir;
+  if (existsSync(dir)) rmSync(dir, { recursive: true, force: true });
+  if (wasActive) {
+    const remaining = listProfiles();
+    if (remaining.length > 0) {
+      setActive(remaining[0].name);
+    } else {
+      const activePath = getActivePointerPath();
+      if (existsSync(activePath)) rmSync(activePath, { force: true });
+    }
+  }
+  import("./vault.mjs").then((m) => {
+    m.__resetKeyCache();
+  }).catch(() => {
+  });
+}
+function getActivePointerPath() {
+  return join(getConfigDir(), "active");
+}
+function getActiveName() {
+  const p = getActivePointerPath();
+  if (!existsSync(p)) return null;
+  try {
+    const name = readFileSync(p, "utf8").trim();
+    return name || null;
+  } catch {
+    return null;
+  }
+}
+function getActive() {
+  const name = getActiveName();
+  if (!name) return null;
+  return getProfile(name);
+}
+function setActive(name) {
+  if (!getProfile(name)) throw new Error(`Profile '${name}' not found.`);
+  const cfg = getConfigDir();
+  if (!existsSync(cfg)) mkdirSync(cfg, { recursive: true });
+  const p = getActivePointerPath();
+  writeFileSync(p + ".tmp", name + "\n");
+  renameSync(p + ".tmp", p);
+  import("./vault.mjs").then((m) => {
+    m.__resetKeyCache();
+  }).catch(() => {
+  });
+}
+function suggestNextDefaultName() {
+  const names = listProfiles().map((p) => p.name);
+  let n = 1;
+  while (names.includes(`account-${n}`)) n++;
+  return `account-${n}`;
+}
+function renameProfile(oldName, newName) {
+  const err = validateName(newName);
+  if (err) throw new Error(err);
+  const oldPaths = getProfilePaths(oldName);
+  const newPaths = getProfilePaths(newName);
+  if (!existsSync(oldPaths.dir)) throw new Error(`Profile '${oldName}' not found.`);
+  if (existsSync(newPaths.dir)) throw new Error(`Profile '${newName}' already exists.`);
+  renameSync(oldPaths.dir, newPaths.dir);
+  const meta = readMeta(newName);
+  if (meta) {
+    meta.name = newName;
+    if (meta.displayName === oldName) meta.displayName = newName;
+    writeMeta(newName, meta);
+  }
+  if (getActiveName() === oldName) setActive(newName);
+}
+function recordLoginSuccess(name, { tier, loginMode, lastLogin }) {
+  const paths = getProfilePaths(name);
+  if (!existsSync(paths.dir)) mkdirSync(paths.dir, { recursive: true });
+  const current = readMeta(name) ?? { name, displayName: name, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const meta = { ...current, loginMode, tier, lastLogin };
+  writeMeta(name, meta);
+  return meta;
+}
+
+export {
+  getConfigDir,
+  getProfilesDir,
+  getProfilePaths,
+  validateName,
+  createProfile,
+  listProfiles,
+  getProfile,
+  deleteProfile,
+  getActiveName,
+  getActive,
+  setActive,
+  suggestNextDefaultName,
+  renameProfile,
+  recordLoginSuccess
+};

package/dist/chunk-Z7DAACGZ.mjs

@@ -0,0 +1,534 @@
+import {
+  ASI_ACCESS_ENDPOINT,
+  EXPERIMENTS_ENDPOINT,
+  MODELS_CONFIG_ENDPOINT,
+  PERPLEXITY_URL,
+  RATE_LIMIT_ENDPOINT,
+  USER_INFO_ENDPOINT,
+  findBrowser,
+  getOrCreateContext,
+  getSavedCookies,
+  resolveBrowserExecutable
+} from "./chunk-LKJMLGFP.mjs";
+import {
+  getActiveName,
+  getConfigDir,
+  getProfilePaths
+} from "./chunk-XKSWCEGI.mjs";
+
+// src/refresh.ts
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+function getActiveProfileName() {
+  return process.env.PERPLEXITY_PROFILE || getActiveName() || "default";
+}
+function getModelsCacheFile() {
+  return getProfilePaths(getActiveProfileName()).modelsCache;
+}
+function getLegacyCookiesFile() {
+  return join(getProfilePaths(getActiveProfileName()).dir, "cookies.json");
+}
+function getImpitRuntimeDirPath() {
+  return join(getConfigDir(), "native-deps");
+}
+var STEALTH_ARGS = [
+  "--disable-blink-features=AutomationControlled",
+  // NOTE: `--disable-web-security` was removed (2026-04-27 public-hardening
+  // audit). All in-page `fetch()` calls used by the cookie-refresh tier hit
+  // the same Perplexity origin, so CORS is not a factor; keeping the flag
+  // would needlessly weaken the browser's same-origin policy. The off-origin
+  // ASI download path lives in client.ts and now uses APIRequestContext.
+  //
+  // NOTE: `--disable-features=IsolateOrigins,site-per-process` and
+  // `--disable-site-isolation-trials` were removed (2026-04-27 public-
+  // hardening audit). They disable Chromium's Site Isolation process model,
+  // which is a renderer-architecture feature invisible to JavaScript on the
+  // page (no documented fingerprint surface — Patchright's
+  // `chromiumSwitches.js` does not include them). The cookie-refresh path
+  // never enumerates frames or cross-origin iframes, so the only effect of
+  // keeping them was a silent reduction in the browser's Spectre/UXSS
+  // defense-in-depth.
+  "--no-first-run",
+  "--no-default-browser-check",
+  "--disable-infobars",
+  "--disable-extensions",
+  "--disable-popup-blocking"
+];
+var USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36";
+var CHROME_CLIENT_HINTS = {
+  "sec-ch-ua": '"Not)A;Brand";v="8", "Chromium";v="138", "Google Chrome";v="138"',
+  "sec-ch-ua-mobile": "?0",
+  "sec-ch-ua-platform": '"Windows"',
+  "sec-ch-ua-platform-version": '"15.0.0"',
+  "sec-ch-ua-arch": '"x86"',
+  "sec-ch-ua-bitness": '"64"',
+  "sec-ch-ua-full-version": '"138.0.7204.184"',
+  "sec-ch-ua-full-version-list": '"Not)A;Brand";v="8.0.0.0", "Chromium";v="138.0.7204.184", "Google Chrome";v="138.0.7204.184"',
+  "sec-ch-ua-model": '""',
+  "sec-fetch-dest": "empty",
+  "sec-fetch-mode": "cors",
+  "sec-fetch-site": "same-origin",
+  "x-app-apiclient": "default",
+  "x-app-apiversion": "2.18",
+  "x-perplexity-request-try-number": "1",
+  "x-perplexity-request-reason": "use-preferred-search-models",
+  accept: "*/*",
+  "accept-language": "en-US,en;q=0.9",
+  referer: `${PERPLEXITY_URL}/`,
+  origin: PERPLEXITY_URL
+};
+function noopLog(_) {
+}
+function buildCookieHeader(cookies) {
+  return cookies.filter((c) => c.domain?.includes("perplexity.ai")).map((c) => `${c.name}=${c.value}`).join("; ");
+}
+function detectCfChallenge(body) {
+  if (!body) return false;
+  const head = body.slice(0, 2e3).toLowerCase();
+  return head.includes("just a moment") || head.includes("cf-mitigated") || head.includes("enable javascript and cookies to continue") || head.includes("<html") && head.includes("cloudflare");
+}
+async function tierGotScraping(cookies, log, timeoutMs) {
+  const started = Date.now();
+  let gotScraping;
+  try {
+    ({ gotScraping } = await import("got-scraping"));
+  } catch (err) {
+    return { ok: false, error: `got-scraping missing: ${err.message}`, elapsedMs: Date.now() - started };
+  }
+  const cookieHeader = buildCookieHeader(cookies);
+  const headers = {
+    cookie: cookieHeader,
+    "user-agent": USER_AGENT,
+    ...CHROME_CLIENT_HINTS
+  };
+  const fetchJson = async (url, name) => {
+    try {
+      const res = await gotScraping({
+        url,
+        headers,
+        timeout: { request: timeoutMs },
+        throwHttpErrors: false,
+        responseType: "text",
+        headerGeneratorOptions: {
+          browsers: [{ name: "chrome", minVersion: 130 }],
+          operatingSystems: ["windows"]
+        }
+      });
+      const body = typeof res.body === "string" ? res.body : String(res.body ?? "");
+      if (res.statusCode !== 200) {
+        log(`got-scraping: ${name} status=${res.statusCode}`);
+        if (detectCfChallenge(body)) return { __challenged: true };
+        return null;
+      }
+      const ct = res.headers["content-type"] ?? "";
+      if (!String(ct).includes("application/json")) {
+        log(`got-scraping: ${name} non-JSON content-type=${ct}`);
+        if (detectCfChallenge(body)) return { __challenged: true };
+        return null;
+      }
+      return JSON.parse(body);
+    } catch (err) {
+      log(`got-scraping: ${name} threw ${err.message}`);
+      return null;
+    }
+  };
+  const [models, asi, rateLimits, experiments, userInfo] = await Promise.all([
+    fetchJson(MODELS_CONFIG_ENDPOINT, "models/config"),
+    fetchJson(ASI_ACCESS_ENDPOINT, "asi-access"),
+    fetchJson(RATE_LIMIT_ENDPOINT, "rate-limit"),
+    fetchJson(EXPERIMENTS_ENDPOINT, "experiments"),
+    fetchJson(USER_INFO_ENDPOINT, "user/info")
+  ]);
+  const challenged = !!(models && models.__challenged);
+  if (challenged) {
+    return { ok: false, challenged: true, error: "CF challenge via got-scraping", elapsedMs: Date.now() - started };
+  }
+  if (!models) {
+    return { ok: false, error: "got-scraping: models/config fetch failed", elapsedMs: Date.now() - started };
+  }
+  return {
+    ok: true,
+    payload: {
+      models,
+      asi: asi && !asi.__challenged ? asi : null,
+      rateLimits: rateLimits && !rateLimits.__challenged ? rateLimits : null,
+      experiments: experiments && !experiments.__challenged ? experiments : null,
+      userInfo: userInfo && !userInfo.__challenged ? userInfo : null
+    },
+    elapsedMs: Date.now() - started
+  };
+}
+async function loadImpit() {
+  const candidates = [
+    join(getImpitRuntimeDirPath(), "node_modules", "impit", "index.wrapper.js"),
+    join(getImpitRuntimeDirPath(), "node_modules", "impit", "index.js"),
+    join(getImpitRuntimeDirPath(), "node_modules", "impit", "dist", "index.js")
+  ];
+  const failures = [];
+  for (const p of candidates) {
+    if (!existsSync(p)) continue;
+    try {
+      const { createRequire } = await import("module");
+      const req = createRequire(p);
+      return req(p);
+    } catch (err) {
+      failures.push(`${p}: ${err.message ?? err}`);
+    }
+  }
+  if (failures.length) {
+    try {
+      console.error(`[impit] load failed: ${failures.join(" | ")}`);
+    } catch {
+    }
+  }
+  return null;
+}
+function isImpitAvailable() {
+  const marker = join(getImpitRuntimeDirPath(), "node_modules", "impit", "package.json");
+  return existsSync(marker);
+}
+async function impitFetchJson(url, init = {}, cookies, timeoutMs = 15e3) {
+  const impitMod = await loadImpit();
+  if (!impitMod) return null;
+  let client;
+  try {
+    client = new impitMod.Impit({ browser: "chrome", ignoreTlsErrors: false });
+  } catch {
+    return null;
+  }
+  const hasBody = init.body !== void 0 && init.body !== null;
+  const headers = {
+    cookie: buildCookieHeader(cookies),
+    "user-agent": USER_AGENT,
+    ...CHROME_CLIENT_HINTS,
+    accept: "application/json, text/plain, */*",
+    ...hasBody ? { "content-type": "application/json" } : {},
+    ...init.headers ?? {}
+  };
+  try {
+    const ctrl = new AbortController();
+    const to = setTimeout(() => ctrl.abort(), timeoutMs);
+    const res = await client.fetch(url, {
+      method: init.method ?? "GET",
+      headers,
+      body: hasBody ? JSON.stringify(init.body) : void 0,
+      signal: ctrl.signal
+    });
+    clearTimeout(to);
+    const text = await res.text();
+    if (detectCfChallenge(text)) {
+      return { status: res.status, data: null, challenged: true };
+    }
+    let data = text;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+      }
+    }
+    return { status: res.status, data };
+  } catch {
+    return null;
+  }
+}
+async function tierImpit(cookies, log, timeoutMs) {
+  const started = Date.now();
+  const impitMod = await loadImpit();
+  if (!impitMod) {
+    return { ok: false, error: "impit not installed (optional speed boost)", elapsedMs: Date.now() - started };
+  }
+  let client;
+  try {
+    client = new impitMod.Impit({ browser: "chrome", ignoreTlsErrors: false });
+  } catch (err) {
+    return { ok: false, error: `impit init failed: ${err.message}`, elapsedMs: Date.now() - started };
+  }
+  const cookieHeader = buildCookieHeader(cookies);
+  const headers = {
+    cookie: cookieHeader,
+    "user-agent": USER_AGENT,
+    ...CHROME_CLIENT_HINTS
+  };
+  const fetchJson = async (url, name) => {
+    try {
+      const ctrl = new AbortController();
+      const to = setTimeout(() => ctrl.abort(), timeoutMs);
+      const res = await client.fetch(url, { headers, signal: ctrl.signal });
+      clearTimeout(to);
+      const body = await res.text();
+      if (res.status !== 200) {
+        log(`impit: ${name} status=${res.status}`);
+        if (detectCfChallenge(body)) return { __challenged: true };
+        return null;
+      }
+      const rhdrs = res.headers;
+      const ct = typeof rhdrs?.get === "function" ? rhdrs.get("content-type") ?? "" : rhdrs?.["content-type"] ?? "";
+      if (!String(ct).includes("application/json")) {
+        log(`impit: ${name} non-JSON content-type=${ct}`);
+        if (detectCfChallenge(body)) return { __challenged: true };
+        return null;
+      }
+      return JSON.parse(body);
+    } catch (err) {
+      log(`impit: ${name} threw ${err.message}`);
+      return null;
+    }
+  };
+  const [models, asi, rateLimits, experiments, userInfo] = await Promise.all([
+    fetchJson(MODELS_CONFIG_ENDPOINT, "models/config"),
+    fetchJson(ASI_ACCESS_ENDPOINT, "asi-access"),
+    fetchJson(RATE_LIMIT_ENDPOINT, "rate-limit"),
+    fetchJson(EXPERIMENTS_ENDPOINT, "experiments"),
+    fetchJson(USER_INFO_ENDPOINT, "user/info")
+  ]);
+  const challenged = !!(models && models.__challenged);
+  if (challenged) {
+    return { ok: false, challenged: true, error: "CF challenge via impit", elapsedMs: Date.now() - started };
+  }
+  if (!models) {
+    return { ok: false, error: "impit: models/config fetch failed", elapsedMs: Date.now() - started };
+  }
+  return {
+    ok: true,
+    payload: {
+      models,
+      asi: asi && !asi.__challenged ? asi : null,
+      rateLimits: rateLimits && !rateLimits.__challenged ? rateLimits : null,
+      experiments: experiments && !experiments.__challenged ? experiments : null,
+      userInfo: userInfo && !userInfo.__challenged ? userInfo : null
+    },
+    elapsedMs: Date.now() - started
+  };
+}
+async function tierBrowser(cookies, log, timeoutMs) {
+  const started = Date.now();
+  try {
+    await resolveBrowserExecutable();
+  } catch (err) {
+    return { ok: false, error: err.message, elapsedMs: Date.now() - started };
+  }
+  let chromium;
+  try {
+    chromium = (await import("patchright")).chromium;
+  } catch (err) {
+    return { ok: false, error: `patchright missing: ${err.message}`, elapsedMs: Date.now() - started };
+  }
+  const probe = findBrowser();
+  const label = probe ? `${probe.channel}${probe.path.toLowerCase().includes("brave") ? " (brave)" : ""}` : "bundled";
+  log(`browser: launching headless ${label}`);
+  const browser = await chromium.launch({
+    headless: true,
+    args: STEALTH_ARGS,
+    ...probe ? { executablePath: probe.path } : {},
+    ...probe && ["chrome", "msedge", "chromium"].includes(probe.channel) ? { channel: probe.channel } : {},
+    ignoreDefaultArgs: ["--enable-automation"]
+  });
+  try {
+    const context = await getOrCreateContext(browser, {
+      viewport: { width: 1920, height: 1080 },
+      userAgent: USER_AGENT
+    });
+    await context.addCookies(cookies);
+    const page = await context.newPage();
+    const navResp = await page.goto(PERPLEXITY_URL, { waitUntil: "domcontentloaded", timeout: timeoutMs }).catch((e) => {
+      log(`browser: goto failed ${e.message}`);
+      return null;
+    });
+    const status = navResp?.status() ?? 0;
+    const title = await page.title().catch(() => "");
+    log(`browser: navigation status=${status}, title="${title}"`);
+    if (title.includes("Just a moment") || title.toLowerCase().includes("cloudflare")) {
+      return { ok: false, challenged: true, error: "CF challenge via browser \u2014 cookies expired", elapsedMs: Date.now() - started };
+    }
+    const fetchJson = async (url, name) => {
+      try {
+        const result = await page.evaluate(async (u) => {
+          try {
+            const r = await fetch(u, { credentials: "include" });
+            const ct = r.headers.get("content-type") ?? "";
+            if (!r.ok || !ct.includes("application/json")) {
+              return { ok: false, status: r.status, contentType: ct };
+            }
+            return { ok: true, body: await r.json() };
+          } catch (e) {
+            return { ok: false, error: e?.message ?? String(e) };
+          }
+        }, url);
+        if (!result?.ok) {
+          log(`browser: ${name} non-OK status=${result?.status ?? "n/a"} ct=${result?.contentType ?? "n/a"} err=${result?.error ?? "n/a"}`);
+          return null;
+        }
+        return result.body;
+      } catch (err) {
+        log(`browser: ${name} evaluate threw: ${err.message}`);
+        return null;
+      }
+    };
+    const [models, asi, rateLimits, experiments, userInfo] = await Promise.all([
+      fetchJson(MODELS_CONFIG_ENDPOINT, "models/config"),
+      fetchJson(ASI_ACCESS_ENDPOINT, "asi-access"),
+      fetchJson(RATE_LIMIT_ENDPOINT, "rate-limit"),
+      fetchJson(EXPERIMENTS_ENDPOINT, "experiments"),
+      fetchJson(USER_INFO_ENDPOINT, "user/info")
+    ]);
+    if (!models) {
+      return { ok: false, error: "browser: models/config fetch failed inside page", elapsedMs: Date.now() - started };
+    }
+    log(
+      `browser: fetched \u2014 models=${Object.keys(models.models || {}).length}, asi=${!!asi}, rateLimits=${!!rateLimits}, experiments=${experiments ? Object.keys(experiments).length + " keys" : "null"}, userInfo=${userInfo ? JSON.stringify(userInfo) : "null"}`
+    );
+    const freshCookies = await context.cookies(PERPLEXITY_URL).then(
+      (arr) => arr.map((c) => ({
+        name: c.name,
+        value: c.value,
+        domain: c.domain,
+        path: c.path,
+        secure: c.secure,
+        httpOnly: c.httpOnly,
+        sameSite: c.sameSite
+      }))
+    ).catch(() => void 0);
+    return {
+      ok: true,
+      payload: { models, asi, rateLimits, experiments, userInfo, freshCookies },
+      elapsedMs: Date.now() - started
+    };
+  } finally {
+    await browser.close().catch(() => void 0);
+  }
+}
+async function refreshAccountInfo(opts = {}) {
+  const log = opts.log ?? noopLog;
+  const started = Date.now();
+  const timeoutMs = opts.timeoutMs ?? 25e3;
+  const modelsCacheFile = getModelsCacheFile();
+  const legacyCookiesFile = getLegacyCookiesFile();
+  const savedCookies = await getSavedCookies();
+  if (savedCookies.length === 0) {
+    return {
+      ok: false,
+      source: "no-cookies",
+      tier: null,
+      modelCount: 0,
+      accountTier: "Unknown",
+      error: "No saved cookies \u2014 run Perplexity: Login first.",
+      cachePath: modelsCacheFile,
+      elapsedMs: Date.now() - started
+    };
+  }
+  const attempts = [];
+  const tierMap = {
+    "got-scraping": tierGotScraping,
+    impit: tierImpit,
+    browser: tierBrowser
+  };
+  const pipeline = opts.forceTier ? [[opts.forceTier, tierMap[opts.forceTier]]] : (() => {
+    const chain = [["got-scraping", tierGotScraping]];
+    if (isImpitAvailable()) chain.push(["impit", tierImpit]);
+    chain.push(["browser", tierBrowser]);
+    return chain;
+  })();
+  let successful = null;
+  let lastChallenged = false;
+  for (const [name, fn] of pipeline) {
+    log(`refresh: attempting tier=${name}`);
+    const result2 = await fn(savedCookies, log, timeoutMs);
+    attempts.push({ tier: name, ok: result2.ok, elapsedMs: result2.elapsedMs, error: result2.error });
+    if (result2.ok) {
+      successful = { tier: name, result: result2 };
+      log(`refresh: tier=${name} succeeded in ${result2.elapsedMs}ms`);
+      break;
+    }
+    lastChallenged = lastChallenged || !!result2.challenged;
+    log(`refresh: tier=${name} failed in ${result2.elapsedMs}ms (${result2.error ?? "unknown"})`);
+  }
+  if (!successful) {
+    return {
+      ok: false,
+      source: lastChallenged ? "cf-challenge" : "failed",
+      tier: null,
+      modelCount: 0,
+      accountTier: "Unknown",
+      error: lastChallenged ? "All tiers hit Cloudflare challenge. Run Perplexity: Login to re-solve Turnstile." : "All refresh tiers failed. See logs.",
+      cachePath: modelsCacheFile,
+      elapsedMs: Date.now() - started,
+      tierAttempts: attempts
+    };
+  }
+  const { tier, result } = successful;
+  const payload = result.payload;
+  const existing = readExistingCache(modelsCacheFile);
+  const isEnterpriseFromUser = payload.userInfo?.is_enterprise === true;
+  const isEnterpriseFromExp = payload.experiments?.server_is_enterprise === true;
+  const isProFromExp = payload.experiments?.server_is_pro === true;
+  const isMaxFromExp = payload.experiments?.server_is_max === true;
+  const canUseComputer = payload.asi?.can_use_computer ?? existing?.canUseComputer ?? false;
+  const info = {
+    // If Computer mode is accessible but no experiments flag fires, infer Pro —
+    // Computer is gated to paid tiers, so the account is at least Pro.
+    isPro: isProFromExp || canUseComputer && !isMaxFromExp && !isEnterpriseFromUser && !isEnterpriseFromExp,
+    isMax: isMaxFromExp,
+    isEnterprise: isEnterpriseFromUser || isEnterpriseFromExp,
+    canUseComputer,
+    modelsConfig: payload.models,
+    rateLimits: payload.rateLimits ?? existing?.rateLimits ?? null
+  };
+  mkdirSync(dirname(modelsCacheFile), { recursive: true });
+  writeFileSync(modelsCacheFile, JSON.stringify(info, null, 2));
+  log(`refresh: wrote ${modelsCacheFile} (${Object.keys(payload.models.models || {}).length} models)`);
+  if (payload.freshCookies && payload.freshCookies.length > 0) {
+    try {
+      mkdirSync(dirname(legacyCookiesFile), { recursive: true });
+      writeFileSync(
+        legacyCookiesFile,
+        JSON.stringify({ allCookies: payload.freshCookies, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
+      );
+      log(`refresh: persisted ${payload.freshCookies.length} fresh cookies to ${legacyCookiesFile}`);
+    } catch (err) {
+      log(`refresh: could not persist fresh cookies (non-fatal): ${err.message}`);
+    }
+  }
+  return {
+    ok: true,
+    source: "live",
+    tier,
+    modelCount: Object.keys(payload.models.models || {}).length,
+    accountTier: deriveTier(info),
+    cachePath: modelsCacheFile,
+    elapsedMs: Date.now() - started,
+    tierAttempts: attempts
+  };
+}
+function deriveTier(info) {
+  if (info.isMax) return "Max";
+  if (info.isEnterprise) return "Enterprise";
+  if (info.isPro) return "Pro";
+  return "Free";
+}
+function readExistingCache(modelsCacheFile = getModelsCacheFile()) {
+  if (!existsSync(modelsCacheFile)) return null;
+  try {
+    return JSON.parse(readFileSync(modelsCacheFile, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function getModelsCacheInfo() {
+  const path = getModelsCacheFile();
+  const exists = existsSync(path);
+  const mtime = exists ? statSync(path).mtime : null;
+  const ageHours = mtime ? (Date.now() - mtime.getTime()) / 36e5 : null;
+  return { path, exists, mtime, ageHours };
+}
+function getImpitRuntimeDir() {
+  return getImpitRuntimeDirPath();
+}
+
+export {
+  loadImpit,
+  isImpitAvailable,
+  impitFetchJson,
+  refreshAccountInfo,
+  getModelsCacheInfo,
+  getImpitRuntimeDir
+};