perplexity-user-mcp 0.8.36

package/dist/profiles.d.ts

@@ -0,0 +1,41 @@
+interface ProfileMeta {
+  name: string;
+  displayName: string;
+  createdAt: string;
+  loginMode?: string;
+  tier?: string;
+  lastLogin?: string;
+}
+
+interface ProfilePaths {
+  dir: string;
+  meta: string;
+  vault: string;
+  vaultPlain: string;
+  browserData: string;
+  modelsCache: string;
+  history: string;
+  attachments: string;
+  researches: string;
+  reinit: string;
+}
+
+declare function getConfigDir(): string;
+declare function getProfilesDir(): string;
+declare function getProfilePaths(name: string): ProfilePaths;
+declare function validateName(name: string): string | null;
+declare function createProfile(name: string, opts?: { displayName?: string; loginMode?: string }): ProfileMeta;
+declare function listProfiles(): ProfileMeta[];
+declare function getProfile(name: string): ProfileMeta | null;
+declare function deleteProfile(name: string): void;
+declare function getActiveName(): string | null;
+declare function getActive(): ProfileMeta | null;
+declare function setActive(name: string): void;
+declare function suggestNextDefaultName(): string;
+declare function renameProfile(oldName: string, newName: string): void;
+declare function recordLoginSuccess(
+  name: string,
+  opts: { tier: string; loginMode: string; lastLogin: string }
+): ProfileMeta;
+
+export { type ProfileMeta, type ProfilePaths, createProfile, deleteProfile, getActive, getActiveName, getConfigDir, getProfile, getProfilePaths, getProfilesDir, listProfiles, recordLoginSuccess, renameProfile, setActive, suggestNextDefaultName, validateName };

package/dist/profiles.mjs

@@ -0,0 +1,33 @@
+import {
+  createProfile,
+  deleteProfile,
+  getActive,
+  getActiveName,
+  getConfigDir,
+  getProfile,
+  getProfilePaths,
+  getProfilesDir,
+  listProfiles,
+  recordLoginSuccess,
+  renameProfile,
+  setActive,
+  suggestNextDefaultName,
+  validateName
+} from "./chunk-XKSWCEGI.mjs";
+import "./chunk-4UEJOM6W.mjs";
+export {
+  createProfile,
+  deleteProfile,
+  getActive,
+  getActiveName,
+  getConfigDir,
+  getProfile,
+  getProfilePaths,
+  getProfilesDir,
+  listProfiles,
+  recordLoginSuccess,
+  renameProfile,
+  setActive,
+  suggestNextDefaultName,
+  validateName
+};

package/dist/redact.d.ts

@@ -0,0 +1,159 @@
+// Security-critical: scrubs sensitive patterns from strings before logging
+// or before sending to external destinations (GitHub issue reports, debug
+// exports). Pattern list ordered from most-specific to least-specific to
+// avoid accidental re-matching by a more general rule.
+
+// Scope: this module is called on OUR OWN trusted log/debug data (logger
+// output, doctor reports, cookies). It is NOT a user-input sanitizer.
+// Deliberate trade-offs in the current pattern set:
+//   - Emails are matched post-URL-decode only (raw %40 encoded forms pass through)
+//   - Unix home paths assume no whitespace in usernames
+//   - Windows home paths only cover C:\Users\... (UNC paths pass through)
+//   - Long-token redaction (≥20 base64/hex chars) may over-redact legitimate
+//     long URLs or JSON values — accepted trade-off for safety over debuggability
+// If any of these assumptions changes (e.g., we start redacting user-supplied
+// payloads), the pattern set must be revisited.
+
+/**
+ * Canonical secret-shape regex list. Distinct from the legacy PATTERNS array
+ * below because every match emits a kind-tagged `<redacted:<kind>>` placeholder
+ * so the redactor's output is unambiguous for audit / test / grep-gate
+ * purposes. Applied BEFORE the legacy PATTERNS inside redactString so specific
+ * shapes win over the generic long-token catchall.
+ */
+const SECRET_PATTERNS = Object.freeze([
+  // OAuth / local prefixes come FIRST so a value like `"bearer":"pplx_at_…"`
+  // gets the specific oauth-access tag instead of the generic daemon-bearer
+  // one from the bearer-json catchall below.
+  { name: "oauth-access",         kind: "oauth-access",       re: /pplx_at_[A-Za-z0-9_\-]{10,}/g },
+  { name: "oauth-refresh",        kind: "oauth-refresh",      re: /pplx_rt_[A-Za-z0-9_\-]{10,}/g },
+  { name: "oauth-code",           kind: "oauth-code",         re: /pplx_ac_[A-Za-z0-9_\-]{10,}/g },
+  { name: "local-bearer",         kind: "local-bearer",       re: /pplx_local_[a-z0-9-]+_[A-Za-z0-9_\-]{10,}/g },
+  { name: "daemon-bearer-json",   kind: "daemon-bearer",      re: /"bearerToken"\s*:\s*"[A-Za-z0-9_\-]{30,}"/g },
+  // Matches the `"bearer":"..."` shape used by daemon:bearer:reveal:response
+  // so reveal-payload logs stay leak-free. Value is only required to be
+  // 20+ safe-identifier chars — covers both raw daemon bearers and future
+  // short-lived tokens.
+  { name: "bearer-json",          kind: "daemon-bearer",      re: /"bearer"\s*:\s*"[A-Za-z0-9_\-]{20,}"/g },
+  { name: "authorization-header", kind: "bearer-header",      re: /[Aa]uthorization\s*:\s*Bearer\s+[A-Za-z0-9_\-\.]{20,}/g },
+  { name: "ngrok-authtoken",      kind: "ngrok-authtoken",    re: /"authtoken"\s*:\s*"\d+[A-Za-z0-9]{20,}"/g },
+  { name: "jwt",                  kind: "jwt",                re: /eyJ[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+\.[A-Za-z0-9_\-]+/g },
+  { name: "cf-clearance",         kind: "cf-clearance",       re: /cf_clearance=[^;\s]+/g },
+  { name: "perplexity-session",   kind: "perplexity-session", re: /__Secure-next-auth\.session-token=[^;\s]+/g },
+]);
+
+/**
+ * String-only secret redactor. Applies SECRET_PATTERNS and returns a string
+ * with kind-tagged placeholders. Does NOT apply the legacy PATTERNS
+ * (emails / userIds / paths / IPs / generic long-token); call `redact()` for
+ * the full composite behavior.
+ * @param {string} input
+ * @returns {string}
+ */
+function redactSecrets(input) {
+  if (typeof input !== "string") return input;
+  let out = input;
+  for (const { re, kind } of SECRET_PATTERNS) {
+    out = out.replace(re, (match) => {
+      if (match.startsWith('"bearerToken"')) return `"bearerToken":"<redacted:${kind}>"`;
+      if (match.startsWith('"bearer"')) return `"bearer":"<redacted:${kind}>"`;
+      if (/^[Aa]uthorization\s*:/i.test(match)) return match.replace(/Bearer\s+[A-Za-z0-9_\-\.]{20,}/, `Bearer <redacted:${kind}>`);
+      if (match.startsWith('"authtoken"')) return `"authtoken":"<redacted:${kind}>"`;
+      if (match.startsWith("cf_clearance=")) return `cf_clearance=<redacted:${kind}>`;
+      if (match.startsWith("__Secure-next-auth.session-token=")) return `__Secure-next-auth.session-token=<redacted:${kind}>`;
+      return `<redacted:${kind}>`;
+    });
+  }
+  return out;
+}
+
+const PATTERNS = [
+  // Emails: RFC 5322 subset. Must come before generic token rules because
+  // emails contain characters that other rules would catch.
+  {
+    re: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+    replace: "<email>",
+  },
+  // Perplexity user IDs: user_ followed by hex/alphanum (>=8 chars).
+  {
+    re: /\buser_[A-Fa-f0-9]{8,}\b/g,
+    replace: "<userId>",
+  },
+  // Home directory paths. Must replace before the "long opaque token" rule
+  // because long path segments would otherwise trip it.
+  {
+    re: /(\/Users\/|\/home\/)[^/\s]+/g,
+    replace: "<home>",
+  },
+  {
+    re: /([A-Z]:)\\Users\\[^\\]+/g,
+    replace: "<home>",
+  },
+  // IPv4
+  {
+    re: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
+    replace: "<ip>",
+  },
+  // IPv6. Three alternations cover: (1) full 8-group addresses, (2) :: compressed
+  // forms with at least one prefix group (e.g. 2001:db8::1, fe80::1), (3) leading-::
+  // forms like ::1 and ::. A function filter then requires hex letters (a-f/A-F) OR
+  // a double-colon so that pure-digit colon-separated strings like "23:59:59"
+  // (HH:MM:SS wall-clock) and ISO timestamps are left untouched.
+  {
+    re: /\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b|\b(?:[0-9a-fA-F]{1,4}:){1,7}:(?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4}){0,6})?\b|(?<!\w)::(?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4}){0,6})?(?!\w)/g,
+    replace: (match) => {
+      const hasHex = /[a-fA-F]/.test(match);
+      const hasDoubleColon = /::/.test(match);
+      return (hasHex || hasDoubleColon) ? "<ip>" : match;
+    },
+  },
+  // Long opaque tokens (base64 / hex, >=20 chars). Applied last so more
+  // specific rules win first. Captures key=value and replaces only the value.
+  {
+    re: /=([A-Za-z0-9+/=]{20,})/g,
+    replace: "=<redacted>",
+  },
+];
+
+/**
+ * Redact sensitive patterns from a string or object graph.
+ * For objects: every string-valued leaf is redacted recursively.
+ * Arrays are handled recursively too. Primitive non-strings are returned unchanged.
+ * @template T
+ * @param {T} value
+ * @param {WeakSet<object>} [_seen]
+ * @returns {T}
+ */
+function redact(value, _seen) {
+  if (value == null) return value;
+  if (typeof value === "string") return redactString(value);
+  if (typeof value !== "object") return value;
+
+  // Cycle detection for objects/arrays. We use a WeakSet threaded through the
+  // recursion so siblings don't falsely collide with each other.
+  const seen = _seen ?? new WeakSet();
+  if (seen.has(value)) return "<circular>";
+  seen.add(value);
+
+  if (Array.isArray(value)) return value.map((v) => redact(v, seen));
+
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = redact(v, seen);
+  return out;
+}
+
+function redactString(s) {
+  // SECRET_PATTERNS first: specific bearer / OAuth / JWT / ngrok / cookie
+  // shapes get tagged "<redacted:<kind>>" placeholders. Then the legacy
+  // PATTERNS handle everything else (emails / userIds / home paths / IPs /
+  // generic long-token catchall). Running secrets first prevents the generic
+  // `=(20+chars)` catchall from eating a bearer with a plain `<redacted>`
+  // label when we'd rather have `<redacted:oauth-access>`.
+  let out = redactSecrets(s);
+  for (const { re, replace } of PATTERNS) {
+    out = out.replace(re, replace);
+  }
+  return out;
+}
+
+export { SECRET_PATTERNS, redact, redactSecrets };

package/dist/redact.mjs

@@ -0,0 +1,11 @@
+import {
+  SECRET_PATTERNS,
+  redact,
+  redactSecrets
+} from "./chunk-HMKLWVXB.mjs";
+import "./chunk-4UEJOM6W.mjs";
+export {
+  SECRET_PATTERNS,
+  redact,
+  redactSecrets
+};

package/dist/refresh.d.ts

@@ -0,0 +1,118 @@
+import { PlaywrightCookie } from './config.js';
+import 'patchright';
+
+/**
+ * Live refresh of account info (models/config, ASI access, rate limits, experiments).
+ *
+ * Architecture — three pluggable tiers, tried in order:
+ *
+ *   1. got-scraping — pure JS HTTP client (Apify's got fork). Reorders TLS
+ *      extensions + HTTP/2 SETTINGS + header ordering to look Chrome-ish.
+ *      ~200ms round trip. Always available (shipped as a regular dep).
+ *
+ *   2. impit (optional) — Rust-backed JA3/JA4 impersonation via rustls-patched +
+ *      reqwest. Closer to real Chrome than got-scraping. Only attempted if the
+ *      user has installed it into ~/.perplexity-mcp/native-deps/ (Settings
+ *      → Speed Boost). ~300-500ms.
+ *
+ *   3. browser — headless Patchright. Guaranteed to work because Chromium
+ *      speaks the same TLS as whatever solved Turnstile at login time. ~3-5s.
+ *
+ * Each tier returns the same TierResult shape so the orchestrator can just
+ * walk them in order. A CF challenge (HTML response instead of JSON) counts
+ * as "try the next tier". Anything else (network error, 5xx, unparseable)
+ * also cascades.
+ */
+
+type RefreshTier = "got-scraping" | "impit" | "browser";
+interface RefreshResult {
+    ok: boolean;
+    source: "live" | "no-cookies" | "cf-challenge" | "failed";
+    tier: RefreshTier | null;
+    modelCount: number;
+    accountTier: "Max" | "Pro" | "Enterprise" | "Free" | "Unknown";
+    error?: string;
+    cachePath: string;
+    elapsedMs: number;
+    tierAttempts?: Array<{
+        tier: RefreshTier;
+        ok: boolean;
+        elapsedMs: number;
+        error?: string;
+    }>;
+}
+interface RefreshOptions {
+    log?: (line: string) => void;
+    timeoutMs?: number;
+    /** Force a particular tier for testing. Omit for normal cascade. */
+    forceTier?: RefreshTier;
+}
+/**
+ * Minimal shape of the `impit` module that we actually call.
+ * Full types aren't declared in our tsconfig because impit is NOT a build-time
+ * dependency — it's installed at runtime by the user via "Install Speed Boost".
+ */
+interface ImpitModule {
+    Impit: new (opts: {
+        browser: string;
+        ignoreTlsErrors?: boolean;
+        proxyUrl?: string;
+    }) => {
+        fetch(url: string, init?: {
+            method?: string;
+            body?: string | Uint8Array;
+            headers?: Record<string, string>;
+            signal?: AbortSignal;
+            redirect?: "follow" | "manual" | "error";
+        }): Promise<{
+            status: number;
+            headers: Headers | Record<string, string>;
+            text(): Promise<string>;
+            json(): Promise<unknown>;
+        }>;
+    };
+}
+/**
+ * Dynamically import impit from the user's native-deps directory.
+ * Returns null if impit isn't installed there.
+ *
+ * Note on createRequire: when this code is bundled into the extension host
+ * (CJS via tsup), `import.meta.url` is undefined, which makes
+ * `createRequire(import.meta.url)` throw — the previous implementation
+ * silently caught that and reported "impit not installed" even when the
+ * package was on disk. Rooting `createRequire` at the impit module's own
+ * absolute path works in both CJS- and ESM-bundled output (Node accepts a
+ * file path string per the docs) and resolves impit's peer native binding
+ * from native-deps/node_modules correctly.
+ */
+declare function loadImpit(): Promise<ImpitModule | null>;
+declare function isImpitAvailable(): boolean;
+/**
+ * Browser-free authenticated fetch via impit. Used as a fast path for REST
+ * endpoints that only need cookies + a Chrome-ish TLS fingerprint
+ * (e.g. /rest/thread/list_ask_threads). Callers should fall back to the
+ * browser path on any non-success outcome.
+ *
+ * Returns null when impit isn't installed/loadable or the request threw at
+ * the network level. Returns `{ challenged: true }` when the response body
+ * looks like a Cloudflare interstitial.
+ */
+declare function impitFetchJson(url: string, init: {
+    method?: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+} | undefined, cookies: PlaywrightCookie[], timeoutMs?: number): Promise<{
+    status: number;
+    data: unknown;
+    challenged?: boolean;
+} | null>;
+declare function refreshAccountInfo(opts?: RefreshOptions): Promise<RefreshResult>;
+declare function getModelsCacheInfo(): {
+    path: string;
+    exists: boolean;
+    mtime: Date | null;
+    ageHours: number | null;
+};
+declare function getImpitRuntimeDir(): string;
+
+export { type ImpitModule, type RefreshOptions, type RefreshResult, type RefreshTier, getImpitRuntimeDir, getModelsCacheInfo, impitFetchJson, isImpitAvailable, loadImpit, refreshAccountInfo };

package/dist/refresh.mjs

@@ -0,0 +1,21 @@
+import {
+  getImpitRuntimeDir,
+  getModelsCacheInfo,
+  impitFetchJson,
+  isImpitAvailable,
+  loadImpit,
+  refreshAccountInfo
+} from "./chunk-Z7DAACGZ.mjs";
+import "./chunk-LKJMLGFP.mjs";
+import "./chunk-TQLCLE4L.mjs";
+import "./chunk-MTDFKNXX.mjs";
+import "./chunk-XKSWCEGI.mjs";
+import "./chunk-4UEJOM6W.mjs";
+export {
+  getImpitRuntimeDir,
+  getModelsCacheInfo,
+  impitFetchJson,
+  isImpitAvailable,
+  loadImpit,
+  refreshAccountInfo
+};

package/dist/reinit-watcher.d.ts

@@ -0,0 +1,15 @@
+interface ReinitWatcher {
+  dispose(): void;
+}
+
+interface WatchReinitOptions {
+  debounceMs?: number;
+}
+
+declare function watchReinit(
+  profileName: string,
+  callback: () => void | Promise<void>,
+  opts?: WatchReinitOptions
+): ReinitWatcher;
+
+export { type ReinitWatcher, type WatchReinitOptions, watchReinit };

package/dist/reinit-watcher.mjs

@@ -0,0 +1,8 @@
+import {
+  watchReinit
+} from "./chunk-U3DGFLXZ.mjs";
+import "./chunk-XKSWCEGI.mjs";
+import "./chunk-4UEJOM6W.mjs";
+export {
+  watchReinit
+};

package/dist/session-metadata-B9aV_n5g.d.ts

@@ -0,0 +1,148 @@
+const API_VERSION_QUERY = "version=2.18&source=default";
+
+function buildRuntimeEndpoints(origin) {
+  const base = origin.replace(/\/+$/, "");
+  return {
+    session: `${base}/api/auth/session?${API_VERSION_QUERY}`,
+    csrf: `${base}/api/auth/csrf?${API_VERSION_QUERY}`,
+    signInEmail: `${base}/api/auth/signin/email?${API_VERSION_QUERY}`,
+    otpRedirectLink: `${base}/api/auth/otp-redirect-link`,
+    ssoDetails: `${base}/rest/enterprise/organization/login/details?${API_VERSION_QUERY}`,
+    models: `${base}/rest/models/config?config_schema=v1&${API_VERSION_QUERY}`,
+    asi: `${base}/rest/billing/asi-access-decision?${API_VERSION_QUERY}`,
+    rateLimits: `${base}/rest/rate-limit/status?${API_VERSION_QUERY}`,
+    experiments: `${base}/rest/experiments/attributes?${API_VERSION_QUERY}`,
+    userInfo: `${base}/rest/user/info?${API_VERSION_QUERY}`,
+  };
+}
+
+async function pageRequest(page, url, init = {}) {
+  return page.evaluate(async ({ url: target, init: requestInit }) => {
+    try {
+      const response = await fetch(target, {
+        credentials: "include",
+        ...requestInit,
+      });
+      const contentType = response.headers.get("content-type") ?? "";
+      let json = null;
+      let text = null;
+      try {
+        if (contentType.includes("json")) json = await response.json();
+        else text = (await response.text()).slice(0, 500);
+      } catch {}
+      return {
+        ok: response.ok,
+        status: response.status,
+        redirected: response.redirected,
+        url: response.url,
+        contentType,
+        json,
+        text,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        status: 0,
+        redirected: false,
+        url: target,
+        contentType: "",
+        json: null,
+        text: null,
+        error: error?.message ?? String(error),
+      };
+    }
+  }, { url, init });
+}
+
+async function pollSession(page, sessionUrl, { timeoutMs = 10_000, intervalMs = 500 } = {}) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const sessionResp = await pageRequest(page, sessionUrl);
+    if (sessionResp.ok && sessionResp.json?.user?.id) {
+      return sessionResp.json;
+    }
+    await page.waitForTimeout(intervalMs);
+  }
+  return null;
+}
+
+function deriveAccountFlags({ experiments, userInfo, asi }) {
+  const isEnterprise = userInfo?.is_enterprise === true || experiments?.server_is_enterprise === true;
+  const isMax = experiments?.server_is_max === true;
+  const canUseComputer = asi?.can_use_computer ?? false;
+  const isPro =
+    experiments?.server_is_pro === true ||
+    (canUseComputer && !isMax && !isEnterprise);
+
+  return { isPro, isMax, isEnterprise, canUseComputer };
+}
+
+function deriveTier(payload) {
+  const { isPro, isMax, isEnterprise } = deriveAccountFlags(payload);
+  if (isMax) return "Max";
+  if (isEnterprise) return "Enterprise";
+  if (isPro) return "Pro";
+  return "Authenticated";
+}
+
+async function collectSessionMetadata(page, origin, opts = {}) {
+  const endpoints = buildRuntimeEndpoints(origin);
+  const sessionData =
+    opts.sessionData ??
+    await pollSession(page, endpoints.session, { timeoutMs: opts.sessionTimeoutMs ?? 10_000 });
+
+  if (!sessionData?.user?.id) {
+    return {
+      sessionData: null,
+      models: null,
+      asi: null,
+      rateLimits: null,
+      experiments: null,
+      userInfo: null,
+      tier: "Authenticated",
+      cache: {
+        modelsConfig: null,
+        rateLimits: null,
+        isPro: false,
+        isMax: false,
+        isEnterprise: false,
+        canUseComputer: false,
+      },
+    };
+  }
+
+  const [modelsResp, asiResp, rateResp, expResp, userInfoResp] = await Promise.all([
+    pageRequest(page, endpoints.models),
+    pageRequest(page, endpoints.asi),
+    pageRequest(page, endpoints.rateLimits),
+    pageRequest(page, endpoints.experiments),
+    pageRequest(page, endpoints.userInfo),
+  ]);
+
+  const payload = {
+    experiments: expResp.ok ? expResp.json : null,
+    userInfo: userInfoResp.ok ? userInfoResp.json : null,
+    asi: asiResp.ok ? asiResp.json : null,
+  };
+  const flags = deriveAccountFlags(payload);
+
+  return {
+    sessionData,
+    models: modelsResp.ok ? modelsResp.json : null,
+    asi: asiResp.ok ? asiResp.json : null,
+    rateLimits: rateResp.ok ? rateResp.json : null,
+    experiments: expResp.ok ? expResp.json : null,
+    userInfo: userInfoResp.ok ? userInfoResp.json : null,
+    tier: deriveTier(payload),
+    cache: {
+      modelsConfig: modelsResp.ok ? modelsResp.json : null,
+      rateLimits: rateResp.ok ? rateResp.json : null,
+      isPro: flags.isPro,
+      isMax: flags.isMax,
+      isEnterprise: flags.isEnterprise,
+      canUseComputer: flags.canUseComputer,
+    },
+  };
+}
+
+export { buildRuntimeEndpoints as b, collectSessionMetadata as c, pageRequest as p };

package/dist/tty-prompt.d.ts

@@ -0,0 +1,44 @@
+import { createInterface } from 'node:readline';
+
+function promptSecret({ stdin = process.stdin, stderr = process.stderr, prompt = "> " } = {}) {
+  return new Promise((resolve) => {
+    stderr.write(prompt);
+    const rl = createInterface({ input: stdin, output: stderr, terminal: false });
+    rl.once("line", (line) => {
+      rl.close();
+      resolve(String(line).trim());
+    });
+  });
+}
+
+/**
+ * Minimal y/N confirmation prompt for destructive-ish CLI subcommands.
+ *
+ * - Prompt goes to stderr. Answer comes from stdin. Matches the existing
+ *   `promptSecret` shape so tests can inject fakes.
+ * - Accepts `y`, `Y`, `yes`, `YES`, `Yes` as confirmation. Everything else —
+ *   including empty input, EOF (Ctrl-D), and stdin close — is treated as a
+ *   decline. Returns `true` on confirm, `false` on decline.
+ * - Does NOT exit the process; the caller decides whether to exit 130.
+ */
+function promptYesNo({ stdin = process.stdin, stderr = process.stderr, prompt = "Continue? [y/N] " } = {}) {
+  return new Promise((resolve) => {
+    stderr.write(prompt);
+    const rl = createInterface({ input: stdin, output: stderr, terminal: false });
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      try { rl.close(); } catch { /* ignore */ }
+      resolve(value);
+    };
+    rl.once("line", (line) => {
+      const answer = String(line).trim().toLowerCase();
+      finish(answer === "y" || answer === "yes");
+    });
+    // EOF / stream close before a line arrives → decline.
+    rl.once("close", () => finish(false));
+  });
+}
+
+export { promptSecret, promptYesNo };

package/dist/tty-prompt.mjs

@@ -0,0 +1,39 @@
+import "./chunk-4UEJOM6W.mjs";
+
+// src/tty-prompt.js
+import { createInterface } from "readline";
+function promptSecret({ stdin = process.stdin, stderr = process.stderr, prompt = "> " } = {}) {
+  return new Promise((resolve) => {
+    stderr.write(prompt);
+    const rl = createInterface({ input: stdin, output: stderr, terminal: false });
+    rl.once("line", (line) => {
+      rl.close();
+      resolve(String(line).trim());
+    });
+  });
+}
+function promptYesNo({ stdin = process.stdin, stderr = process.stderr, prompt = "Continue? [y/N] " } = {}) {
+  return new Promise((resolve) => {
+    stderr.write(prompt);
+    const rl = createInterface({ input: stdin, output: stderr, terminal: false });
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      try {
+        rl.close();
+      } catch {
+      }
+      resolve(value);
+    };
+    rl.once("line", (line) => {
+      const answer = String(line).trim().toLowerCase();
+      finish(answer === "y" || answer === "yes");
+    });
+    rl.once("close", () => finish(false));
+  });
+}
+export {
+  promptSecret,
+  promptYesNo
+};

package/dist/vault.d-BtRSLZiM.d.ts

@@ -0,0 +1,8 @@
+declare class Vault {
+  get(profile: string, key: string): Promise<string | null>;
+  set(profile: string, key: string, value: string): Promise<void>;
+  delete(profile: string, key: string): Promise<void>;
+  deleteAll(profile: string): Promise<void>;
+}
+
+export { Vault };