perplexity-user-mcp 0.8.42 → 0.8.47

package/dist/reinit-watcher.d.ts

@@ -1,26 +1,17 @@
-interface ReinitWatcher {
-  dispose(): void;
-}
-
-interface WatchReinitOptions {
-  debounceMs?: number;
-}
-
-declare function watchReinit(
-  profileName: string,
-  callback: () => void | Promise<void>,
-  opts?: WatchReinitOptions
-): ReinitWatcher;
-
+export function watchReinit(profileName: any, callback: any, opts?: {}): {
+    dispose(): void;
+};
 /**
- * Watch the `<configDir>/active` pointer file for profile switches and call
- * `callback` whenever it changes. Pass `configDir = undefined` to use the
- * resolved default config dir (PERPLEXITY_CONFIG_DIR or ~/.perplexity-mcp).
+ * Watch the `<configDir>/active` pointer file for profile switches.
+ *
+ * The per-profile `watchReinit` is bound to a single profile's `.reinit` file
+ * captured at daemon startup; if the user switches the active profile, that
+ * watcher will never see anything (the new profile's `.reinit` is in a
+ * different directory). This second watcher fires whenever `setActive()`
+ * rewrites the active-pointer atomically, letting the daemon call
+ * `client.reinit()` on profile switches AND rebind its per-profile watcher
+ * to the newly-active profile so subsequent login events propagate.
  */
-declare function watchActiveProfile(
-  configDir: string | undefined,
-  callback: () => void | Promise<void>,
-  opts?: WatchReinitOptions
-): ReinitWatcher;
-
-export { type ReinitWatcher, type WatchReinitOptions, watchActiveProfile, watchReinit };
+export function watchActiveProfile(configDirOverride: any, callback: any, opts?: {}): {
+    dispose(): void;
+};

package/dist/reinit-watcher.mjs

@@ -1,8 +1,8 @@
 import {
   watchActiveProfile,
   watchReinit
-} from "./chunk-WDIW33DA.mjs";
-import "./chunk-HJIXH6CL.mjs";
+} from "./chunk-3LUO5ATM.mjs";
+import "./chunk-E3GRJXXJ.mjs";
 import "./chunk-4UEJOM6W.mjs";
 export {
   watchActiveProfile,

package/dist/resources.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface AccountSnapshotProvider {
+    (): Record<string, unknown>;
+}
+export declare function registerResources(server: McpServer, getAccountSnapshot?: AccountSnapshotProvider): void;

package/dist/safe-write.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Atomically write `data` to `path` via a `${path}.tmp` staging file and
+ * `renameSync`. On Windows, Node's renameSync uses MoveFileExW with
+ * MOVEFILE_REPLACE_EXISTING, so the destination is replaced atomically with
+ * no rmSync window. On any failure, best-effort delete the `.tmp` file and
+ * re-throw the original error.
+ *
+ * The caller is responsible for `mkdirSync` of the parent directory and for
+ * any post-write `chmod` / permissions hardening; this helper only owns the
+ * write+rename pair.
+ *
+ * @param {string} path Final destination path.
+ * @param {string|Buffer|Uint8Array} data Bytes to write.
+ * @param {string|object} [opts] Encoding string or fs.writeFileSync options.
+ */
+export function safeAtomicWriteFileSync(path: string, data: string | Buffer | Uint8Array, opts?: string | object): void;

package/dist/session-metadata.d.ts

@@ -0,0 +1,45 @@
+export function buildRuntimeEndpoints(origin: any): {
+    session: string;
+    csrf: string;
+    signInEmail: string;
+    otpRedirectLink: string;
+    ssoDetails: string;
+    models: string;
+    asi: string;
+    rateLimits: string;
+    experiments: string;
+    userInfo: string;
+};
+export function pageRequest(page: any, url: any, init?: {}): Promise<any>;
+export function pollSession(page: any, sessionUrl: any, { timeoutMs, intervalMs }?: {
+    timeoutMs?: number | undefined;
+    intervalMs?: number | undefined;
+}): Promise<any>;
+export function deriveAccountFlags({ experiments, userInfo, asi }: {
+    experiments: any;
+    userInfo: any;
+    asi: any;
+}): {
+    isPro: any;
+    isMax: boolean;
+    isEnterprise: boolean;
+    canUseComputer: any;
+};
+export function deriveTier(payload: any): "Max" | "Pro" | "Enterprise" | "Authenticated";
+export function collectSessionMetadata(page: any, origin: any, opts?: {}): Promise<{
+    sessionData: any;
+    models: any;
+    asi: any;
+    rateLimits: any;
+    experiments: any;
+    userInfo: any;
+    tier: string;
+    cache: {
+        modelsConfig: any;
+        rateLimits: any;
+        isPro: any;
+        isMax: boolean;
+        isEnterprise: boolean;
+        canUseComputer: any;
+    };
+}>;

package/dist/tool-config.d.ts

@@ -0,0 +1,10 @@
+export type ToolProfile = "read-only" | "full" | "custom";
+interface ToolConfig {
+    profile: ToolProfile;
+    customEnabled?: string[];
+}
+export declare function loadToolConfig(): ToolConfig;
+export declare function getEnabledTools(config: ToolConfig): Set<string>;
+export declare function saveToolConfig(config: ToolConfig): void;
+export declare function watchToolConfig(onChange: (config: ToolConfig) => void): void;
+export {};

package/dist/tools.d.ts

@@ -0,0 +1,23 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { PerplexityClient } from "./client.js";
+type GetClient = () => Promise<PerplexityClient>;
+export interface ToolAuditEvent {
+    tool: string;
+    clientId: string;
+    source: "loopback" | "tunnel";
+    durationMs: number;
+    ok: boolean;
+    error?: string;
+}
+export interface ToolProgressEvent {
+    tool: string;
+    clientId: string;
+    source: "loopback" | "tunnel";
+    progress: Record<string, unknown>;
+}
+export interface ToolHooks {
+    onToolSettled?: (event: ToolAuditEvent) => void;
+    onToolProgress?: (event: ToolProgressEvent) => void;
+}
+export declare function registerTools(server: McpServer, getClient: GetClient, enabledTools?: Set<string>, hooks?: ToolHooks): void;
+export {};

package/dist/tty-prompt.d.ts

@@ -1,16 +1,12 @@
-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());
-    });
-  });
-}
-
+export function promptSecret({ stdin, stderr, prompt }?: {
+    stdin?: (NodeJS.ReadStream & {
+        fd: 0;
+    }) | undefined;
+    stderr?: (NodeJS.WriteStream & {
+        fd: 2;
+    }) | undefined;
+    prompt?: string | undefined;
+}): Promise<any>;
 /**
  * Minimal y/N confirmation prompt for destructive-ish CLI subcommands.
  *
@@ -21,24 +17,12 @@ function promptSecret({ stdin = process.stdin, stderr = process.stderr, prompt =
  *   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 };
+export function promptYesNo({ stdin, stderr, prompt }?: {
+    stdin?: (NodeJS.ReadStream & {
+        fd: 0;
+    }) | undefined;
+    stderr?: (NodeJS.WriteStream & {
+        fd: 2;
+    }) | undefined;
+    prompt?: string | undefined;
+}): Promise<any>;

package/dist/vault.d.ts

@@ -1,37 +1,117 @@
-declare function encryptBlob(plaintext: Buffer, key: Buffer): Buffer;
-declare function decryptBlob(blob: Buffer, key: Buffer): Buffer;
-declare function __resetKeyCache(): void;
-declare function getMasterKey(): Promise<Buffer>;
-
-/**
- * TEST SEAM — drop scrypt cost during tests by overriding the (logN, r, p)
- * parameters used at write time. Reads always use the params embedded in the
- * blob, regardless of any override.
- *
- * Cleared by `__resetKeyCache()` so tests do not leak state across files.
- * MUST NOT be called from production code paths. The decrypt-time floor
- * check (logN >= SCRYPT_LOGN_FLOOR) remains enforced unconditionally.
- */
-declare function __setKdfParamsForTest(params: { logN: number; r: number; p: number }): void;
-
-/**
- * Sibling of `getMasterKey()` introduced with the v2 vault format. Returns
- * the unseal context WITHOUT prematurely deriving the HKDF key — for v2
- * blobs, key derivation needs the salt embedded in each blob, so it can no
- * longer happen up front. Cached just like `_keyCache`; cleared by
+/**
+ * TEST SEAM — drop scrypt cost during tests by setting (logN, r, p).
+ * MUST NOT be called in production code paths. Cleared by `__resetKeyCache()`.
+ *
+ * Encrypt path uses the override when set (so tests can write blobs with
+ * logN=12 in ~5ms instead of logN=17 in ~300ms). Decrypt path always uses the
+ * params embedded in the blob, regardless of any override. The decrypt-time
+ * floor check (logN >= SCRYPT_LOGN_FLOOR) is enforced unconditionally.
+ *
+ * @param {{logN:number, r:number, p:number}} params
+ */
+export function __setKdfParamsForTest(params: {
+    logN: number;
+    r: number;
+    p: number;
+}): void;
+/**
+ * Encrypt `plaintext` with the supplied 32-byte `key` and emit a v3 blob.
+ * The embedded salt is fresh per call and the active KDF params are encoded
+ * into the header — but the KDF itself is NOT invoked here (caller passes a
+ * pre-derived 32-byte key). Public signature is stable; internal format
+ * always emits the latest version.
+ *
+ * @param {Buffer} plaintext
+ * @param {Buffer} key 32-byte AES-256-GCM key.
+ * @returns {Buffer}
+ */
+export function encryptBlob(plaintext: Buffer, key: Buffer): Buffer;
+/**
+ * Decrypt a vault blob using the supplied 32-byte key. Accepts v1, v2, and v3
+ * formats. The embedded salt + KDF params on v2/v3 are *unused* on this code
+ * path — the caller is presumed to already have a directly-usable key (e.g.
+ * from the OS keychain). For passphrase-derived keys, the higher-level read
+ * path derives the key from the embedded salt+params before calling here.
+ *
+ * @param {Buffer} blob
+ * @param {Buffer} key 32-byte AES-256-GCM key.
+ * @returns {Buffer}
+ */
+export function decryptBlob(blob: Buffer, key: Buffer): Buffer;
+/**
+ * Reset the in-memory caches (key, unseal material, and the test-seam KDF
+ * params override). Called on profile-state changes (account switch, login,
+ * logout) and from tests to ensure isolation.
+ */
+export function __resetKeyCache(): void;
+/**
+ * Probe the OS keychain for vault unseal capability. Returns whether keytar is
+ * available and whether a master key already exists. Caches the keytar
+ * availability check per-process so repeated probes do not trigger multiple
+ * macOS Keychain permission prompts (issue #6 bug 3). Respects
+ * PERPLEXITY_DISABLE_KEYCHAIN=1.
+ *
+ * @returns {Promise<{available: boolean, hasKey: boolean}>}
+ */
+export function probeKeychainState(): Promise<{
+    available: boolean;
+    hasKey: boolean;
+}>;
+/**
+ * Resolve the unseal context for the vault: either a 32-byte key from the OS
+ * keychain, or a passphrase string (env var / TTY / SecretStorage-injected).
+ * Cached in `_unsealMaterialCache` to mirror `_keyCache`'s UX trade-off — we
+ * do not re-prompt or re-hit the keychain on every vault op. Cleared by
  * `__resetKeyCache()`.
+ *
+ * Sibling of `getMasterKey()`. Key derivation is per-blob (the salt is read
+ * off each blob and, for v3, fed into scrypt with the embedded params), so
+ * unseal material can no longer be pre-derived to a single Buffer at unseal
+ * time for passphrase users.
+ *
+ * @returns {Promise<{kind:"key", key:Buffer}|{kind:"passphrase", passphrase:string}>}
+ */
+export function getUnsealMaterial(): Promise<{
+    kind: "key";
+    key: Buffer;
+} | {
+    kind: "passphrase";
+    passphrase: string;
+}>;
+/**
+ * Resolve EVERY available unseal material in preference order. Used by the
+ * vault read path so that when a vault.enc was written with one path
+ * (e.g. passphrase, when keychain wasn't yet wired) and the user later gains
+ * access to a different path (e.g. keytar starts working after a libsecret
+ * install or extension upgrade), reads transparently fall back instead of
+ * crashing with "Vault decrypt failed: wrong passphrase or corrupted
+ * ciphertext".
+ *
+ * Skips the TTY prompt — that's interactive and only meaningful as a primary
+ * unseal path, never as a silent fallback.
+ *
+ * @returns {Promise<Array<{kind:"key", key:Buffer}|{kind:"passphrase", passphrase:string}>>}
+ */
+export function getAllUnsealMaterials(): Promise<Array<{
+    kind: "key";
+    key: Buffer;
+} | {
+    kind: "passphrase";
+    passphrase: string;
+}>>;
+/**
+ * Return a 32-byte master key. SIGNATURE PRESERVED for back-compat; internal
+ * implementation now defers to `getUnsealMaterial()`. For passphrase users,
+ * this derives via HKDF + the legacy static salt — which is suitable as a
+ * default-derivation entry point but is NOT what the v2/v3 read/write paths
+ * use (they derive against the per-blob random salt, with v3 also stretching
+ * via scrypt). Prefer `getUnsealMaterial()` in new code that touches
+ * encrypted blobs.
  */
-type UnsealMaterial =
-  | { kind: "key"; key: Buffer }
-  | { kind: "passphrase"; passphrase: string };
-
-declare function getUnsealMaterial(): Promise<UnsealMaterial>;
-
-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 function getMasterKey(): Promise<any>;
+export class Vault {
+    get(profile: any, key: any): Promise<any>;
+    set(profile: any, key: any, value: any): Promise<void>;
+    delete(profile: any, key: any): Promise<void>;
+    deleteAll(profile: any): Promise<void>;
 }
-
-export { type UnsealMaterial, Vault, __resetKeyCache, __setKdfParamsForTest, decryptBlob, encryptBlob, getMasterKey, getUnsealMaterial };

package/dist/vault.mjs

@@ -6,10 +6,11 @@ import {
   encryptBlob,
   getAllUnsealMaterials,
   getMasterKey,
-  getUnsealMaterial
-} from "./chunk-S677V2JU.mjs";
+  getUnsealMaterial,
+  probeKeychainState
+} from "./chunk-C5I7KXHK.mjs";
 import "./chunk-MTDFKNXX.mjs";
-import "./chunk-HJIXH6CL.mjs";
+import "./chunk-E3GRJXXJ.mjs";
 import "./chunk-4UEJOM6W.mjs";
 export {
   Vault,
@@ -19,5 +20,6 @@ export {
   encryptBlob,
   getAllUnsealMaterials,
   getMasterKey,
-  getUnsealMaterial
+  getUnsealMaterial,
+  probeKeychainState
 };

package/dist/viewer-detect.d.ts

@@ -1,4 +1,2 @@
-declare function detectViewer(id: string): Promise<boolean>;
-declare function detectAllViewers(): Promise<Record<string, boolean>>;
-
-export { detectAllViewers, detectViewer };
+export function detectViewer(id: any): Promise<boolean>;
+export function detectAllViewers(): Promise<any>;

package/dist/viewers.d.ts

@@ -1,18 +1,13 @@
-import { ExternalViewer } from '@perplexity-user-mcp/shared';
-
-declare function listViewers(overrides?: ExternalViewer[]): ExternalViewer[];
-declare function loadViewerConfig(): ExternalViewer[];
-declare function saveViewerConfig(viewer: ExternalViewer): ExternalViewer;
-declare function substituteViewerTemplate(viewer: ExternalViewer, values: Record<string, string>): string;
-declare function ensureObsidianBridge(options: {
-  mdPath: string;
-  viewer: ExternalViewer;
-  profile?: string;
-}): string;
-declare function buildViewerUrl(options: {
-  viewer: ExternalViewer;
-  mdPath: string;
-  profile?: string;
-}): string;
-
-export { buildViewerUrl, ensureObsidianBridge, listViewers, loadViewerConfig, saveViewerConfig, substituteViewerTemplate };
+export function listViewers(overrides?: any[]): {
+    detected: boolean;
+    enabled: boolean;
+    id: string;
+    label: string;
+    urlTemplate: string;
+    needsVaultBridge: boolean;
+}[];
+export function loadViewerConfig(): any;
+export function saveViewerConfig(viewer: any): any;
+export function substituteViewerTemplate(viewer: any, values: any): any;
+export function ensureObsidianBridge(options: any): string;
+export function buildViewerUrl(options: any): any;

package/dist/viewers.mjs

@@ -2,7 +2,7 @@ import {
   getActiveName,
   getConfigDir,
   getProfilePaths
-} from "./chunk-HJIXH6CL.mjs";
+} from "./chunk-E3GRJXXJ.mjs";
 import "./chunk-4UEJOM6W.mjs";
 
 // src/viewers.js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perplexity-user-mcp",
-  "version": "0.8.42",
+  "version": "0.8.47",
   "mcpName": "io.github.Automations-Project/perplexity-user-mcp",
   "type": "module",
   "description": "Perplexity AI MCP server — browser automation for search, reasoning, research, and compute. Not affiliated with Perplexity AI, Inc.",
@@ -126,7 +126,7 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup --no-dts && tsc --allowJs --emitDeclarationOnly && node scripts/post-build-shebang.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "cd ../.. && npx vitest run packages/mcp-server/test",
     "test:coverage": "cd ../.. && npx vitest run --coverage packages/mcp-server/test"

package/dist/cloud-sync.d-Cqt6y18U.d.ts

@@ -1,42 +0,0 @@
-import { PerplexityClient } from './client.js';
-import './config.js';
-import 'patchright';
-
-interface CloudSyncProgressEvent {
-  phase: "starting" | "syncing" | "done" | "cancelled" | "error";
-  fetched?: number;
-  total?: number;
-  inserted?: number;
-  updated?: number;
-  skipped?: number;
-  error?: string;
-}
-
-interface CloudSyncOptions {
-  client?: PerplexityClient;
-  getClient?: () => Promise<PerplexityClient>;
-  onProgress?: (evt: CloudSyncProgressEvent) => void;
-  pageSize?: number;
-  signal?: AbortSignal;
-}
-
-interface CloudSyncResult {
-  fetched: number;
-  total: number;
-  inserted: number;
-  updated: number;
-  skipped: number;
-  cancelled: boolean;
-}
-
-declare function syncCloudHistory(opts?: CloudSyncOptions): Promise<CloudSyncResult>;
-
-declare function hydrateCloudHistoryEntry(
-  historyId: string,
-  opts?: {
-    client?: PerplexityClient;
-    getClient?: () => Promise<PerplexityClient>;
-  },
-): Promise<{ action: "skipped-local" | "skipped-hydrated" | "hydrated"; id?: string }>;
-
-export { type CloudSyncOptions, type CloudSyncProgressEvent, type CloudSyncResult, hydrateCloudHistoryEntry, syncCloudHistory };

package/dist/doctor.d-CXmUqOXX.d.ts

@@ -1,43 +0,0 @@
-type DoctorStatus = "pass" | "warn" | "fail" | "skip";
-
-type DoctorCategory =
-  | "runtime" | "config" | "profiles" | "vault" | "browser"
-  | "native-deps" | "network" | "ide" | "mcp" | "probe";
-
-interface DoctorCheck {
-  category: DoctorCategory;
-  name: string;
-  status: DoctorStatus;
-  message: string;
-  detail?: Record<string, unknown>;
-  hint?: string;
-}
-
-interface DoctorReport {
-  overall: DoctorStatus;
-  generatedAt: string;
-  durationMs: number;
-  activeProfile: string | null;
-  probeRan: boolean;
-  byCategory: Record<DoctorCategory, {
-    status: DoctorStatus;
-    checks: DoctorCheck[];
-  }>;
-}
-
-interface RunAllOpts {
-  configDir?: string;
-  profile?: string;
-  probe?: boolean;
-  allProfiles?: boolean;
-  ideStatuses?: Record<string, unknown>;
-  baseDir?: string;
-  injected?: Partial<Record<DoctorCategory, DoctorCheck[]>>;
-}
-
-declare const CATEGORIES: ReadonlyArray<DoctorCategory>;
-declare function exitCodeFor(report: { overall: DoctorStatus }): number;
-declare function runAll(opts?: RunAllOpts): Promise<DoctorReport>;
-declare function formatReportMarkdown(report: DoctorReport): string;
-
-export { CATEGORIES, type DoctorCategory, type DoctorCheck, type DoctorReport, type DoctorStatus, type RunAllOpts, exitCodeFor, formatReportMarkdown, runAll };

package/dist/history-store.d-BzjBF2m3.d.ts

@@ -1,65 +0,0 @@
-import { HistoryItem, HistoryEntryDetail } from '@perplexity-user-mcp/shared';
-
-interface HistoryStoreEntryInput extends Partial<HistoryItem> {
-  tool: string;
-  query: string;
-  body?: string;
-}
-
-interface RebuildIndexResult {
-  scanned: number;
-  recovered: number;
-  skipped: number;
-  items: Array<HistoryItem & { filename: string }>;
-}
-
-declare const HISTORY_LIMIT: number;
-declare function getHistoryDir(): string;
-declare function getAttachmentsRoot(): string;
-declare function getIndexPath(): string;
-declare function append(entry: HistoryStoreEntryInput): HistoryItem;
-declare function update(id: string, patch?: Partial<HistoryStoreEntryInput> & { body?: string }): HistoryItem | null;
-declare function list(options?: {
-  limit?: number;
-  status?: "completed" | "pending" | "failed";
-  tool?: string;
-  tools?: string[];
-  filter?: string;
-}): HistoryItem[];
-declare function get(id: string): HistoryEntryDetail | null;
-declare function deleteEntry(id: string): boolean;
-declare function pin(id: string, pinned: boolean): HistoryItem | null;
-declare function tag(id: string, tags: string[]): HistoryItem | null;
-declare function rebuildIndex(): RebuildIndexResult;
-declare function getMdPath(id: string): string | null;
-declare function getAttachmentsDir(id: string): string | null;
-declare function findPendingByThread(threadSlug: string): HistoryItem | null;
-declare function countAll(): number;
-declare function appendHistory(entry: HistoryStoreEntryInput): HistoryItem;
-declare function readHistory(limit?: number): HistoryItem[];
-
-interface CloudUpsertMeta {
-  backendUuid: string;
-  query?: string;
-  answerPreview?: string;
-  createdAt?: string;
-  threadUrl?: string;
-  threadSlug?: string | null;
-  readWriteToken?: string | null;
-  mode?: string | null;
-  model?: string | null;
-  sourceCount?: number;
-  status?: "completed" | "pending" | "failed";
-  tool?: string;
-  tier?: HistoryItem["tier"];
-  language?: string | null;
-}
-
-declare function findByBackendUuid(backendUuid: string | null | undefined): (HistoryItem & { filename: string }) | null;
-declare function upsertFromCloud(meta: CloudUpsertMeta): { action: "inserted" | "updated" | "skipped-local"; id: string };
-declare function hydrateCloudEntry(
-  id: string,
-  payload: { body?: string; sources?: HistoryItem["sources"]; attachments?: HistoryItem["attachments"]; answerPreview?: string; sourceCount?: number },
-): HistoryItem | null;
-
-export { type CloudUpsertMeta, HISTORY_LIMIT, type HistoryStoreEntryInput, type RebuildIndexResult, append, appendHistory, countAll, deleteEntry, findByBackendUuid, findPendingByThread, get, getAttachmentsDir, getAttachmentsRoot, getHistoryDir, getIndexPath, getMdPath, hydrateCloudEntry, list, pin, readHistory, rebuildIndex, tag, update, upsertFromCloud };