@remnic/connector-x 9.69.64

package/dist/chunk-JR2ZNAYD.js

@@ -0,0 +1,1482 @@
+// openclaw-engram: Local-first memory plugin
+
+// src/config.ts
+var X_SOURCE_KINDS = ["mcp", "corpusDir", "cli"];
+var X_MEMORY_MODES = ["suggest", "store"];
+var X_SYNC_SCHEDULES = ["hourly", "4x-daily", "3x-daily", "2x-daily", "daily", "weekly"];
+var X_DEFAULT_MCP_URL = "https://api.x.com/mcp";
+var X_DEFAULT_TOKEN_FILE = "~/.openclaw/secrets/x-tokens.json";
+var X_DEFAULT_STATE_DIR = "~/.remnic/x-connector";
+var X_DEFAULT_COST_PER_READ_USD = 0.01;
+var XConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "XConfigError";
+  }
+};
+function coerceXBool(value, field) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) return true;
+    if (["false", "0", "no", "off"].includes(normalized)) return false;
+  }
+  throw new XConfigError(`${field} must be a boolean (got ${JSON.stringify(value)})`);
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new XConfigError(`${field} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function optionalString(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  return requiredString(value, field);
+}
+function positiveInt(value, field, fallback) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new XConfigError(`${field} must be an integer >= 1 (got ${JSON.stringify(value)})`);
+  }
+  return value;
+}
+function nonNegativeNumber(value, field, fallback) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new XConfigError(`${field} must be a finite number >= 0 (got ${JSON.stringify(value)})`);
+  }
+  return value;
+}
+function parseBudget(raw, sourceId) {
+  const input = raw === void 0 || raw === null ? {} : objectOrThrow(raw, `sources[${sourceId}].budget`);
+  return {
+    maxPagesPerSync: positiveInt(input.maxPagesPerSync, `sources[${sourceId}].budget.maxPagesPerSync`, 2),
+    maxCostUsdPerMonth: nonNegativeNumber(
+      input.maxCostUsdPerMonth,
+      `sources[${sourceId}].budget.maxCostUsdPerMonth`,
+      1
+    ),
+    costPerReadUsd: nonNegativeNumber(
+      input.costPerReadUsd,
+      `sources[${sourceId}].budget.costPerReadUsd`,
+      X_DEFAULT_COST_PER_READ_USD
+    )
+  };
+}
+function objectOrThrow(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new XConfigError(`${field} must be an object`);
+  }
+  return value;
+}
+function parseMcpSource(raw) {
+  const id = requiredString(raw.id, "source.id");
+  const auth = objectOrThrow(raw.auth ?? {}, `sources[${id}].auth`);
+  return {
+    id,
+    kind: "mcp",
+    url: optionalString(raw.url, `sources[${id}].url`) ?? X_DEFAULT_MCP_URL,
+    tokenFile: optionalString(auth.tokenFile ?? raw.tokenFile, `sources[${id}].auth.tokenFile`) ?? X_DEFAULT_TOKEN_FILE,
+    bookmarksTool: optionalString(raw.bookmarksTool, `sources[${id}].bookmarksTool`) ?? "get_users_bookmarks",
+    timelineTool: optionalString(raw.timelineTool, `sources[${id}].timelineTool`) ?? "get_users_tweets",
+    maxResults: positiveInt(raw.maxResults, `sources[${id}].maxResults`, 20),
+    budget: parseBudget(raw.budget, id)
+  };
+}
+function stringArray(value, field) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new XConfigError(`${field} must be an array of strings`);
+  }
+  return value.map((entry, index) => requiredString(entry, `${field}[${index}]`));
+}
+function parseCorpusSource(raw) {
+  const id = requiredString(raw.id, "source.id");
+  return {
+    id,
+    kind: "corpusDir",
+    path: requiredString(raw.path, `sources[${id}].path`)
+  };
+}
+function parseCliSource(raw) {
+  const id = requiredString(raw.id, "source.id");
+  const bookmarksArgs = stringArray(raw.bookmarksArgs, `sources[${id}].bookmarksArgs`);
+  return {
+    id,
+    kind: "cli",
+    bin: optionalString(raw.bin, `sources[${id}].bin`) ?? "bird",
+    bookmarksArgs: bookmarksArgs.length > 0 ? bookmarksArgs : ["bookmarks", "--json"],
+    postsArgs: (() => {
+      const postsArgs = stringArray(raw.postsArgs, `sources[${id}].postsArgs`);
+      return postsArgs.length > 0 ? postsArgs : void 0;
+    })()
+  };
+}
+function parseXConnectorConfig(raw) {
+  const input = objectOrThrow(raw, "xConnector");
+  const enabled = coerceXBool(input.enabled ?? true, "xConnector.enabled");
+  const userId = optionalString(input.userId, "xConnector.userId");
+  if (userId !== void 0 && !/^\d+$/.test(userId)) {
+    throw new XConfigError("xConnector.userId must be the numeric X user id");
+  }
+  const sourcesRaw = input.sources;
+  if (!Array.isArray(sourcesRaw) || sourcesRaw.length === 0) {
+    throw new XConfigError("xConnector.sources must be a non-empty array");
+  }
+  const sources = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (let index = 0; index < sourcesRaw.length; index++) {
+    const entry = objectOrThrow(sourcesRaw[index], `sources[${index}]`);
+    const kind = requiredString(entry.kind, `sources[${index}].kind`);
+    if (!X_SOURCE_KINDS.includes(kind)) {
+      throw new XConfigError(
+        `sources[${index}].kind must be one of ${X_SOURCE_KINDS.join(", ")} (got ${JSON.stringify(kind)})`
+      );
+    }
+    const source = kind === "mcp" ? parseMcpSource(entry) : kind === "corpusDir" ? parseCorpusSource(entry) : parseCliSource(entry);
+    if (seenIds.has(source.id)) {
+      throw new XConfigError(`duplicate source id ${JSON.stringify(source.id)} in xConnector.sources`);
+    }
+    seenIds.add(source.id);
+    sources.push(source);
+  }
+  const sourcePriority = stringArray(input.sourcePriority, "xConnector.sourcePriority");
+  for (const id of sourcePriority) {
+    if (!seenIds.has(id)) {
+      throw new XConfigError(`xConnector.sourcePriority references unknown source id ${JSON.stringify(id)}`);
+    }
+  }
+  const orderedPriority = sourcePriority.length > 0 ? sourcePriority : sources.map((source) => source.id);
+  const memoryModeRaw = optionalString(input.memoryMode, "xConnector.memoryMode") ?? "suggest";
+  if (!X_MEMORY_MODES.includes(memoryModeRaw)) {
+    throw new XConfigError(
+      `xConnector.memoryMode must be one of ${X_MEMORY_MODES.join(", ")} (got ${JSON.stringify(memoryModeRaw)})`
+    );
+  }
+  const syncSchedule = optionalString(input.syncSchedule, "xConnector.syncSchedule") ?? "3x-daily";
+  if (!X_SYNC_SCHEDULES.includes(syncSchedule)) {
+    throw new XConfigError(
+      `xConnector.syncSchedule must be one of ${X_SYNC_SCHEDULES.join(", ")} (got ${JSON.stringify(syncSchedule)})`
+    );
+  }
+  return {
+    enabled,
+    userId,
+    sources,
+    sourcePriority: orderedPriority,
+    syncSchedule,
+    memoryMode: memoryModeRaw,
+    stateDir: optionalString(input.stateDir, "xConnector.stateDir") ?? X_DEFAULT_STATE_DIR
+  };
+}
+function resolveMcpClientCredentials(source, env = process.env) {
+  const clientId = env.REMNIC_X_CLIENT_ID ?? env.X_CLIENT_ID;
+  const clientSecret = env.REMNIC_X_CLIENT_SECRET ?? env.X_CLIENT_SECRET;
+  return {
+    clientId: typeof clientId === "string" && clientId.trim().length > 0 ? clientId.trim() : void 0,
+    clientSecret: typeof clientSecret === "string" && clientSecret.trim().length > 0 ? clientSecret.trim() : void 0,
+    tokenFile: source.tokenFile
+  };
+}
+function monthlyCostCapUsd(config) {
+  let cap = 0;
+  for (const source of config.sources) {
+    if (source.kind === "mcp") cap = Math.max(cap, source.budget.maxCostUsdPerMonth);
+  }
+  return cap;
+}
+
+// src/file-sink.ts
+import { mkdir, rename, writeFile } from "fs/promises";
+import path from "path";
+import { expandTildePath } from "@remnic/core";
+function createFileSink(options) {
+  const root = path.join(expandTildePath(options.stateDir), options.mode === "store" ? "records" : "suggestions");
+  const write = async (suggestion) => {
+    await mkdir(root, { recursive: true });
+    const safeName = suggestion.record.postId.replace(/[^0-9A-Za-z._-]/g, "_");
+    const target = path.join(root, `${safeName}.json`);
+    const tmp = `${target}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(suggestion, null, 2)}
+`, { mode: 384 });
+    await rename(tmp, target);
+  };
+  return {
+    submitSuggestion: write,
+    storeMemory: write
+  };
+}
+
+// src/guards.ts
+function isXObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/normalize.ts
+import { createHash } from "crypto";
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, entry) => {
+    if (isXObject(entry)) {
+      return Object.fromEntries(
+        Object.keys(entry).sort().map((key) => [key, entry[key]])
+      );
+    }
+    return entry;
+  });
+}
+function recordFingerprint(record) {
+  return createHash("sha256").update(
+    stableStringify({
+      postId: record.postId,
+      kind: record.kind,
+      text: record.text,
+      urls: [...record.urls].sort(),
+      authorUsername: record.author?.username ?? null
+    })
+  ).digest("hex");
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return void 0;
+}
+function asStringArray(value) {
+  if (typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  const urls = [];
+  for (const entry of value) {
+    if (typeof entry === "string" && entry.trim().length > 0) urls.push(entry.trim());
+    else if (isXObject(entry)) {
+      const expanded = firstString(entry.expanded_url, entry.url, entry.href);
+      if (expanded !== void 0) urls.push(expanded);
+    }
+  }
+  return urls;
+}
+function kindFrom(value, fallback) {
+  const raw = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (raw === "bookmark" || raw === "bookmarks") return "bookmark";
+  if (raw === "own_post" || raw === "post" || raw === "tweet" || raw === "own-post") {
+    return "own_post";
+  }
+  return fallback;
+}
+function normalizeMcpPayload(payload, kind, ownUsername) {
+  const container = isXObject(payload) ? payload : {};
+  const includesUsers = isXObject(container.includes) ? Array.isArray(container.includes.users) ? container.includes.users : [] : [];
+  const rows = Array.isArray(container.data) ? container.data : Array.isArray(payload) ? payload : isXObject(container.bookmarks) && Array.isArray(container.bookmarks.data) ? container.bookmarks.data : Array.isArray(container.bookmarks) ? container.bookmarks : [];
+  const records = [];
+  for (const row of rows) {
+    const record = normalizeEntry(row, kind, includesUsers, ownUsername);
+    if (record !== null) records.push(record);
+  }
+  return records;
+}
+function normalizeCorpusEntry(entry, fallbackKind, ownUsername) {
+  return normalizeEntry(entry, fallbackKind, [], ownUsername);
+}
+function normalizeEntry(entry, fallbackKind, includesUsers, ownUsername) {
+  if (!isXObject(entry)) return null;
+  const postId = firstString(entry.post_id, entry.id, entry.tweet_id, entry.postId);
+  const text = firstString(entry.text, entry.full_text, entry.content, entry.note) ?? "";
+  if (postId === void 0 || text.length === 0 && !hasUrls(entry)) return null;
+  const kind = kindFrom(entry.kind ?? entry.type, fallbackKind);
+  const authorRaw = isXObject(entry.author) ? entry.author : entry;
+  const authorId = firstString(entry.author_id, entry.authorId, authorRaw.id);
+  const authorUsername = firstString(authorRaw.username, authorRaw.handle, authorRaw.screen_name) ?? lookupIncludedUsername(includesUsers, authorId) ?? ownUsername;
+  const authorName = firstString(authorRaw.name, authorRaw.display_name);
+  const author = authorUsername !== void 0 || authorId !== void 0 || authorName !== void 0 ? {
+    ...authorId !== void 0 ? { id: authorId } : {},
+    ...authorUsername !== void 0 ? { username: authorUsername } : {},
+    ...authorName !== void 0 ? { name: authorName } : {}
+  } : void 0;
+  const urls = collectUrls(entry);
+  const createdAt = firstString(entry.created_at, entry.createdAt, entry.created_at_iso);
+  const bookmarkedAt = firstString(entry.bookmarked_at, entry.bookmarkedAt, entry.saved_at);
+  const mediaCount = countMedia(entry);
+  const enrichment = isXObject(entry.enrichment) ? entry.enrichment : void 0;
+  return {
+    postId,
+    kind,
+    ...author !== void 0 ? { author } : {},
+    ...createdAt !== void 0 ? { createdAt } : {},
+    ...bookmarkedAt !== void 0 ? { bookmarkedAt } : {},
+    text: trimTcoSuffix(text, entry),
+    urls,
+    mediaCount,
+    ...enrichment !== void 0 ? { enrichment } : {}
+  };
+}
+function hasUrls(entry) {
+  return collectUrls(entry).length > 0;
+}
+function collectUrls(entry) {
+  const urls = [...asStringArray(entry.urls), ...asStringArray(entry.url), ...asStringArray(entry.links)];
+  if (isXObject(entry.entities) && Array.isArray(entry.entities.urls)) {
+    urls.push(...asStringArray(entry.entities.urls));
+  }
+  return [...new Set(urls)];
+}
+function countMedia(entry) {
+  if (isXObject(entry.attachments) && Array.isArray(entry.attachments.media_keys)) {
+    return entry.attachments.media_keys.length;
+  }
+  if (Array.isArray(entry.media)) return entry.media.length;
+  if (isXObject(entry.media) && Array.isArray(entry.media.media_keys)) {
+    return entry.media.media_keys.length;
+  }
+  return 0;
+}
+function lookupIncludedUsername(includesUsers, authorId) {
+  if (authorId === void 0) return void 0;
+  for (const user of includesUsers) {
+    if (isXObject(user) && user.id === authorId) {
+      return firstString(user.username, user.screen_name);
+    }
+  }
+  return void 0;
+}
+function trimTcoSuffix(text, entry) {
+  const entities = isXObject(entry.entities) && Array.isArray(entry.entities.urls) ? entry.entities.urls : [];
+  for (const raw of entities) {
+    if (!isXObject(raw) || typeof raw.url !== "string") continue;
+    if (raw.url.includes("://t.co/") && text.endsWith(raw.url)) {
+      return text.slice(0, text.length - raw.url.length).trimEnd();
+    }
+  }
+  return text;
+}
+function postUrl(record) {
+  const username = record.author?.username;
+  return username !== void 0 ? `https://x.com/${username}/status/${record.postId}` : `https://x.com/i/status/${record.postId}`;
+}
+var QUOTE = '"';
+function suggestionForRecord(record) {
+  const quoted = `${QUOTE}${record.text.slice(0, 280)}${record.text.length > 280 ? "\u2026" : ""}${QUOTE}`;
+  const from = record.author?.username !== void 0 ? ` from @${record.author.username}` : "";
+  const firstUrl = record.urls[0];
+  const title = enrichmentTitle(record);
+  const isOwnPost = record.kind === "own_post";
+  const content = isOwnPost ? `Posted on X: ${quoted}${firstUrl !== void 0 ? ` ${firstUrl}` : ""}${title !== void 0 ? ` (${title})` : ""}` : `Bookmarked on X${from}: ${quoted}${firstUrl !== void 0 ? ` ${firstUrl}` : ""}${title !== void 0 ? ` (${title})` : ""}`;
+  return {
+    record,
+    tags: [isOwnPost ? "x/post" : "x/bookmark"],
+    category: isOwnPost ? "expression" : firstUrl !== void 0 ? "reference" : "interest",
+    ...record.author?.username !== void 0 ? { entityRef: `person-${record.author.username.toLowerCase()}` } : {},
+    confidence: isOwnPost ? 0.9 : 0.7,
+    postUrl: postUrl(record),
+    content
+  };
+}
+function enrichmentTitle(record) {
+  if (record.enrichment === void 0) return void 0;
+  const title = isXObject(record.enrichment) ? record.enrichment.title : void 0;
+  return typeof title === "string" && title.trim().length > 0 ? title.trim() : void 0;
+}
+
+// src/mcp-client.ts
+import { setTimeout as sleepMs } from "timers/promises";
+import {
+  ConnectorApiError,
+  describeNetworkError,
+  retryingFetch,
+  stripTrailingSlashes
+} from "@remnic/core/http-retry";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_RETRIES = 2;
+var MAX_RETRY_DELAY_MS = 8e3;
+var X_MCP_PROTOCOL_VERSION = "2025-06-18";
+var X_MCP_DEFAULT_URL = "https://api.x.com/mcp";
+var XMcpError = class extends ConnectorApiError {
+  constructor(message, status) {
+    super(message, status);
+    this.name = "XMcpError";
+  }
+};
+var XCreditsDepletedError = class extends Error {
+  constructor() {
+    super("X API credits depleted \u2014 skipping this sync cycle");
+    this.name = "XCreditsDepletedError";
+  }
+};
+function parseSseData(body) {
+  const values = [];
+  for (const line of body.split(/\r?\n/)) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice("data:".length).trim();
+    if (payload.length === 0) continue;
+    try {
+      values.push(JSON.parse(payload));
+    } catch {
+    }
+  }
+  return values;
+}
+function looksLikeCreditsDepleted(text) {
+  return text.includes("credits depleted") || text.includes('"status":402');
+}
+function toolResultTexts(payload) {
+  const content = Array.isArray(payload.content) ? payload.content : [];
+  const texts = [];
+  for (const block of content) {
+    if (isXObject(block) && block.type === "text" && typeof block.text === "string") {
+      texts.push(block.text);
+    }
+  }
+  return texts;
+}
+var XMcpClient = class {
+  url;
+  tokenProvider;
+  fetchImpl;
+  timeoutMs;
+  sleep;
+  protocolVersion;
+  clientName;
+  clientVersion;
+  sessionId = null;
+  nextMessageId = 1;
+  constructor(options) {
+    if (typeof options.tokenProvider !== "function") {
+      throw new XMcpError("XMcpClient requires a tokenProvider function");
+    }
+    this.url = stripTrailingSlashes(options.url ?? X_MCP_DEFAULT_URL);
+    this.tokenProvider = options.tokenProvider;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.sleep = options.sleep ?? sleepMs;
+    this.protocolVersion = options.protocolVersion ?? X_MCP_PROTOCOL_VERSION;
+    this.clientName = options.clientName ?? "remnic-connector-x";
+    this.clientVersion = options.clientVersion ?? "1.0.0";
+  }
+  /**
+   * Calls an MCP tool. Re-initializes once when the server rejects the
+   * session id (e.g. expired session), then retries the call.
+   */
+  async callTool(name, args, signal) {
+    return this.withSessionRetry(async () => {
+      const { result } = await this.rpcMessage(
+        {
+          jsonrpc: "2.0",
+          id: this.allocateId(),
+          method: "tools/call",
+          params: { name, arguments: args }
+        },
+        signal,
+        true
+      );
+      if (!isXObject(result)) {
+        throw new XMcpError(`tool ${name} returned a non-object result`);
+      }
+      const texts = toolResultTexts(result);
+      const isError = result.isError === true;
+      if (isError && looksLikeCreditsDepleted(texts.join("\n"))) {
+        throw new XCreditsDepletedError();
+      }
+      return { isError, texts, raw: result };
+    });
+  }
+  /** Best-effort session shutdown (MCP `DELETE`). */
+  async close() {
+    if (this.sessionId === null) return;
+    const sessionId = this.sessionId;
+    this.sessionId = null;
+    try {
+      await this.fetchImpl(this.url, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${await this.tokenProvider()}`,
+          "Mcp-Session-Id": sessionId
+        }
+      });
+    } catch {
+    }
+  }
+  async withSessionRetry(operation) {
+    await this.ensureSession();
+    try {
+      return await operation();
+    } catch (err) {
+      if (err instanceof XMcpError && err.status === 404) {
+        this.sessionId = null;
+        await this.ensureSession();
+        return operation();
+      }
+      throw err;
+    }
+  }
+  async ensureSession(signal) {
+    if (this.sessionId !== null) return;
+    const initialized = await this.rpcMessage(
+      {
+        jsonrpc: "2.0",
+        id: this.allocateId(),
+        method: "initialize",
+        params: {
+          protocolVersion: this.protocolVersion,
+          capabilities: {},
+          clientInfo: { name: this.clientName, version: this.clientVersion }
+        }
+      },
+      signal,
+      true
+    );
+    const sessionId = initialized.headers?.get("mcp-session-id");
+    if (typeof sessionId === "string" && sessionId.length > 0) {
+      this.sessionId = sessionId;
+    }
+    await this.rpcMessage({ jsonrpc: "2.0", method: "notifications/initialized" }, signal, false);
+  }
+  allocateId() {
+    const id = this.nextMessageId;
+    this.nextMessageId += 1;
+    return id;
+  }
+  async rpcMessage(message, signal, expectBody) {
+    const response = await retryingFetch(this.url, {
+      buildInit: async () => {
+        const headers = {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          Authorization: `Bearer ${await this.tokenProvider()}`
+        };
+        if (this.sessionId !== null) headers["Mcp-Session-Id"] = this.sessionId;
+        return {
+          method: "POST",
+          headers,
+          body: JSON.stringify(message)
+        };
+      },
+      fetchImpl: this.fetchImpl,
+      sleep: this.sleep,
+      signal,
+      timeoutMs: this.timeoutMs,
+      maxRetries: MAX_RETRIES,
+      maxRetryDelayMs: MAX_RETRY_DELAY_MS,
+      backoffBaseMs: 500,
+      networkError: (err, attempts) => new XMcpError(`X MCP request failed after ${attempts} attempts: ${describeNetworkError(err)}`),
+      retryableError: (retryable) => new XMcpError(`X MCP responded ${retryable.status}`, retryable.status)
+    });
+    if (response.status === 402) throw new XCreditsDepletedError();
+    if (response.status === 401) {
+      throw new XMcpError(
+        "X MCP rejected the bearer token (401) \u2014 the OAuth2 token or refresh chain is broken; re-authorize",
+        401
+      );
+    }
+    if (response.status === 404 && this.sessionId !== null) {
+      throw new XMcpError("X MCP session expired", 404);
+    }
+    if (!response.ok) {
+      throw new XMcpError(`X MCP responded ${response.status}`, response.status);
+    }
+    if (!expectBody || response.status === 202) {
+      return { result: null, headers: response.headers };
+    }
+    const body = await response.text();
+    return {
+      result: this.decodeBody(body, response.headers, message.id),
+      headers: response.headers
+    };
+  }
+  decodeBody(body, headers, messageId) {
+    const contentType = headers.get("content-type") ?? "";
+    let messages;
+    if (contentType.includes("text/event-stream")) {
+      messages = parseSseData(body);
+    } else {
+      try {
+        messages = [JSON.parse(body)];
+      } catch {
+        throw new XMcpError("X MCP returned a non-JSON body");
+      }
+    }
+    const match = messages.find((entry) => isXObject(entry) && entry.id === messageId && entry.error === void 0);
+    if (match === void 0) {
+      const errorEntry = messages.find(
+        (entry) => isXObject(entry) && entry.id === messageId && entry.error !== void 0
+      );
+      if (errorEntry !== void 0 && isXObject(errorEntry)) {
+        const rpcError = errorEntry.error;
+        const detail = isXObject(rpcError) && typeof rpcError.message === "string" ? `${String(rpcError.code)}: ${rpcError.message}` : "unknown JSON-RPC error";
+        if (looksLikeCreditsDepleted(detail)) throw new XCreditsDepletedError();
+        throw new XMcpError(`X MCP tool call failed: ${detail}`);
+      }
+      throw new XMcpError("X MCP response carried no message for this request id");
+    }
+    if (isXObject(match) && "result" in match) return match.result;
+    return match;
+  }
+};
+
+// src/token-store.ts
+import { open, readFile, rename as rename2, stat, unlink, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+import { setTimeout as sleepMs2 } from "timers/promises";
+var X_TOKEN_REFRESH_URL = "https://api.x.com/2/oauth2/token";
+var EXPIRY_MARGIN_MS = 6e4;
+var DEFAULT_LOCK_STALE_MS = 6e4;
+var DEFAULT_LOCK_WAIT_MS = 15e3;
+var LOCK_POLL_MS = 200;
+var XTokenError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "XTokenError";
+  }
+};
+var XRefreshChainBrokenError = class extends XTokenError {
+  constructor(detail) {
+    super(
+      `X OAuth2 refresh failed (${detail}). The refresh chain was rotated by another refresher or the grant was revoked. Ensure only one refresher owns the chain, then re-authorize to write a fresh token file.`
+    );
+    this.name = "XRefreshChainBrokenError";
+  }
+};
+var LockUnavailableError = class extends Error {
+};
+var XTokenStore = class {
+  tokenFile;
+  clientId;
+  clientSecret;
+  refreshUrl;
+  fetchImpl;
+  now;
+  sleep;
+  lockStaleMs;
+  lockWaitMs;
+  cached = null;
+  constructor(options) {
+    if (typeof options.tokenFile !== "string" || options.tokenFile.length === 0) {
+      throw new XTokenError("XTokenStore requires tokenFile");
+    }
+    for (const [field, value] of [
+      ["clientId", options.clientId],
+      ["clientSecret", options.clientSecret]
+    ]) {
+      if (typeof value !== "string" || value.trim().length === 0) {
+        throw new XTokenError(
+          `XTokenStore requires ${field} (pre-registered confidential client; set xConnector source auth or the REMNIC_X_CLIENT_ID/REMNIC_X_CLIENT_SECRET env vars)`
+        );
+      }
+    }
+    this.tokenFile = options.tokenFile;
+    this.clientId = options.clientId.trim();
+    this.clientSecret = options.clientSecret.trim();
+    this.refreshUrl = options.refreshUrl ?? X_TOKEN_REFRESH_URL;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.now = options.now ?? (() => Date.now());
+    this.lockStaleMs = options.lockStaleMs ?? DEFAULT_LOCK_STALE_MS;
+    this.lockWaitMs = options.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS;
+    this.sleep = options.sleep ?? sleepMs2;
+  }
+  /** Returns a valid access token, refreshing under the lock when expired. */
+  async getAccessToken() {
+    return (await this.getValidPair()).accessToken;
+  }
+  async getValidPair() {
+    const current = this.cached ?? await this.readTokenFile();
+    if (current !== null && current.expiresAt - EXPIRY_MARGIN_MS > this.now()) {
+      this.cached = current;
+      return current;
+    }
+    const refreshed = await this.refreshWithLock();
+    this.cached = refreshed;
+    return refreshed;
+  }
+  /**
+   * Refreshes the token pair under the file lock. When another owner
+   * holds the lock, waits for it, then adopts the pair it wrote.
+   */
+  async refresh() {
+    const pair = await this.refreshWithLock();
+    this.cached = pair;
+    return pair;
+  }
+  async refreshWithLock() {
+    let lock = null;
+    try {
+      lock = await this.acquireLock();
+    } catch (err) {
+      if (err instanceof LockUnavailableError) {
+        return this.waitForOtherOwner();
+      }
+      throw err;
+    }
+    try {
+      const underLock = await this.readTokenFile();
+      if (underLock !== null && underLock.expiresAt - EXPIRY_MARGIN_MS > this.now()) {
+        return underLock;
+      }
+      const refreshToken = underLock?.refreshToken ?? (() => {
+        throw new XTokenError(
+          `X token file ${this.tokenFile} is missing or carries no refresh_token \u2014 run the OAuth2 user-code flow once to seed it`
+        );
+      })();
+      const rotated = await this.requestRefresh(refreshToken);
+      await this.writeTokenFile(rotated);
+      return rotated;
+    } finally {
+      await lock.release();
+    }
+  }
+  async waitForOtherOwner() {
+    const deadline = this.now() + this.lockWaitMs;
+    while (this.now() < deadline) {
+      await this.sleep(LOCK_POLL_MS);
+      const pair = await this.readTokenFile();
+      if (pair !== null && pair.expiresAt - EXPIRY_MARGIN_MS > this.now()) {
+        return pair;
+      }
+    }
+    throw new XTokenError(
+      `another refresher has held ${this.tokenFile}.lock for over ${Math.round(this.lockWaitMs / 1e3)}s \u2014 investigate the competing owner`
+    );
+  }
+  async acquireLock() {
+    const lockPath = `${this.tokenFile}.lock`;
+    const deadline = this.now() + this.lockWaitMs;
+    for (; ; ) {
+      try {
+        const handle = await open(lockPath, "wx");
+        await handle.write(`${process.pid}
+`);
+        await handle.close();
+        return {
+          release: async () => {
+            try {
+              await unlink(lockPath);
+            } catch {
+            }
+          }
+        };
+      } catch (err) {
+        const code = err.code;
+        if (code !== "EEXIST") throw err;
+        if (await this.stealStaleLock(lockPath)) continue;
+        if (this.now() >= deadline) throw new LockUnavailableError("lock wait timeout");
+        await this.sleep(LOCK_POLL_MS);
+      }
+    }
+  }
+  /** Steals the lock when its mtime is older than lockStaleMs. */
+  async stealStaleLock(lockPath) {
+    let mtimeMs;
+    try {
+      mtimeMs = (await stat(lockPath)).mtimeMs;
+    } catch {
+      return true;
+    }
+    if (this.now() - mtimeMs < this.lockStaleMs) return false;
+    try {
+      await unlink(lockPath);
+    } catch {
+    }
+    return true;
+  }
+  async requestRefresh(refreshToken) {
+    const body = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: this.clientId
+    }).toString();
+    let response;
+    try {
+      response = await this.fetchImpl(this.refreshUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64")}`
+        },
+        body
+      });
+    } catch (err) {
+      throw new XTokenError(`X OAuth2 refresh request failed: ${err instanceof Error ? err.name : "network error"}`);
+    }
+    if (response.status === 400 || response.status === 401 || response.status === 403) {
+      throw new XRefreshChainBrokenError(`HTTP ${response.status}`);
+    }
+    if (!response.ok) {
+      throw new XTokenError(`X OAuth2 refresh responded HTTP ${response.status}`);
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new XTokenError("X OAuth2 refresh returned a non-JSON body");
+    }
+    if (!isTokenResponse(payload)) {
+      throw new XTokenError("X OAuth2 refresh returned an unexpected payload shape");
+    }
+    return {
+      accessToken: payload.access_token,
+      // X rotates refresh tokens; keep the old one when the response omits it.
+      refreshToken: typeof payload.refresh_token === "string" ? payload.refresh_token : refreshToken,
+      expiresAt: this.now() + payload.expires_in * 1e3
+    };
+  }
+  async readTokenFile() {
+    let raw;
+    try {
+      raw = await readFile(this.tokenFile, "utf8");
+    } catch {
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new XTokenError(`X token file ${this.tokenFile} is not valid JSON`);
+    }
+    if (!isXObject(parsed)) return null;
+    const accessToken = firstString2(parsed.access_token, parsed.accessToken);
+    if (accessToken === void 0) {
+      throw new XTokenError(`X token file ${this.tokenFile} carries no access token`);
+    }
+    const refreshToken = firstString2(parsed.refresh_token, parsed.refreshToken) ?? "";
+    const expiresAtRaw = parsed.expires_at ?? parsed.expiresAt;
+    const expiresAt = typeof expiresAtRaw === "number" && Number.isFinite(expiresAtRaw) ? expiresAtRaw : (
+      // Files without expiry force one refresh on first use.
+      0
+    );
+    return { accessToken, refreshToken, expiresAt };
+  }
+  /** Atomic 0600 write; preserves unknown top-level fields from the prior file. */
+  async writeTokenFile(pair) {
+    let previous = {};
+    try {
+      const priorRaw = JSON.parse(await readFile(this.tokenFile, "utf8"));
+      if (isXObject(priorRaw)) previous = priorRaw;
+    } catch {
+      previous = {};
+    }
+    const next = {
+      ...previous,
+      access_token: pair.accessToken,
+      refresh_token: pair.refreshToken,
+      expires_at: pair.expiresAt
+    };
+    const dir = path2.dirname(this.tokenFile);
+    const tmpPath = path2.join(dir, `.${path2.basename(this.tokenFile)}.${process.pid}.${Date.now()}.tmp`);
+    await writeFile2(tmpPath, `${JSON.stringify(next, null, 2)}
+`, { mode: 384 });
+    try {
+      await rename2(tmpPath, this.tokenFile);
+    } catch (err) {
+      try {
+        await unlink(tmpPath);
+      } catch {
+      }
+      throw new XTokenError(
+        `failed to persist rotated X tokens to ${this.tokenFile}: ${err instanceof Error ? err.name : "write error"}`
+      );
+    }
+  }
+};
+function firstString2(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return void 0;
+}
+function isTokenResponse(value) {
+  return isXObject(value) && typeof value.access_token === "string";
+}
+
+// src/sources.ts
+import { execFile } from "child_process";
+import { lstat, readFile as readFile2, readdir, realpath, stat as stat2 } from "fs/promises";
+import path3 from "path";
+import { promisify } from "util";
+import { expandTildePath as expandTildePath2 } from "@remnic/core";
+var execFileAsync = promisify(execFile);
+var XBudgetTracker = class {
+  constructor(budget, monthSpendUsd) {
+    this.budget = budget;
+    this.monthSpendUsd = monthSpendUsd;
+    this.maxPages = budget.maxPagesPerSync;
+  }
+  budget;
+  monthSpendUsd;
+  pagesUsed = 0;
+  reads = 0;
+  maxPages;
+  canRead() {
+    if (this.pagesUsed >= this.budget.maxPagesPerSync) {
+      return { ok: false, reason: "page-cap", detail: `${this.budget.maxPagesPerSync} pages/sync` };
+    }
+    const projected = this.monthSpendUsd + (this.reads + 1) * this.budget.costPerReadUsd;
+    if (projected > this.budget.maxCostUsdPerMonth + 1e-9) {
+      return {
+        ok: false,
+        reason: "monthly-cost-cap",
+        detail: `$${projected.toFixed(2)} projected vs $${this.budget.maxCostUsdPerMonth.toFixed(2)} cap`
+      };
+    }
+    return { ok: true };
+  }
+  noteRead() {
+    this.reads += 1;
+  }
+};
+var unlimitedBudget = {
+  pagesUsed: 0,
+  maxPages: Number.POSITIVE_INFINITY,
+  canRead: () => ({ ok: true }),
+  noteRead: () => {
+  }
+};
+function createXSource(config, deps = {}) {
+  if (config.kind === "mcp") return createMcpSource(config, deps);
+  if (config.kind === "corpusDir") return createCorpusSource(config);
+  return createCliSource(config, deps);
+}
+function createMcpSource(config, deps) {
+  const credentials = resolveMcpClientCredentials(config, deps.env ?? process.env);
+  let client = null;
+  const getClient = () => {
+    if (client === null) {
+      if (credentials.clientId === void 0 || credentials.clientSecret === void 0) {
+        throw new XMcpError(
+          `source ${config.id}: OAuth2 client credentials missing \u2014 set auth on the source or REMNIC_X_CLIENT_ID/REMNIC_X_CLIENT_SECRET`
+        );
+      }
+      const store = new XTokenStore({
+        tokenFile: expandTildePath2(credentials.tokenFile),
+        clientId: credentials.clientId,
+        clientSecret: credentials.clientSecret,
+        ...deps.fetchImpl !== void 0 ? { fetchImpl: deps.fetchImpl } : {},
+        ...deps.sleep !== void 0 ? { sleep: deps.sleep } : {},
+        ...deps.now !== void 0 ? { now: deps.now } : {}
+      });
+      client = new XMcpClient({
+        url: config.url,
+        tokenProvider: () => store.getAccessToken(),
+        ...deps.fetchImpl !== void 0 ? { fetchImpl: deps.fetchImpl } : {},
+        ...deps.sleep !== void 0 ? { sleep: deps.sleep } : {}
+      });
+    }
+    return client;
+  };
+  return {
+    id: config.id,
+    kind: "mcp",
+    async fetch(ctx) {
+      const records = [];
+      let reads = 0;
+      let pages = 0;
+      let skipped;
+      try {
+        getClient();
+      } catch (err) {
+        return {
+          records,
+          reads,
+          pages,
+          skipped: {
+            reason: "auth-not-configured",
+            ...err instanceof Error ? { detail: err.message } : {}
+          }
+        };
+      }
+      const runKind = async (kind, toolName, args) => {
+        let nextToken;
+        for (; ; ) {
+          const gate = ctx.budget.canRead();
+          if (!gate.ok) {
+            skipped ??= {
+              reason: gate.reason,
+              ...gate.detail !== void 0 ? { detail: gate.detail } : {}
+            };
+            return;
+          }
+          const page = await getClient().callTool(toolName, {
+            ...args,
+            ...nextToken !== void 0 ? { pagination_token: nextToken } : {}
+          });
+          ctx.budget.noteRead();
+          reads += 1;
+          pages += 1;
+          ctx.budget.pagesUsed = pages;
+          const payload = parseToolJson(page.texts);
+          if (payload === null) {
+            skipped ??= { reason: "unexpected-payload", detail: `tool ${toolName}` };
+            return;
+          }
+          const pageRecords = normalizeMcpPayload(payload, kind);
+          records.push(...pageRecords);
+          nextToken = nextPageToken(payload);
+          if (nextToken === void 0 || pageRecords.length === 0) return;
+          if (pageRecords.every((record) => ctx.knownIds.has(record.postId))) return;
+        }
+      };
+      try {
+        await runKind("bookmark", config.bookmarksTool, { max_results: config.maxResults });
+        if (deps.userId !== void 0) {
+          await runKind("own_post", config.timelineTool, {
+            id: deps.userId,
+            max_results: config.maxResults
+          });
+        }
+      } catch (err) {
+        if (err instanceof XCreditsDepletedError) {
+          return { records, reads, pages, skipped: { reason: "credits-depleted" } };
+        }
+        throw err;
+      }
+      return { records, reads, pages, ...skipped !== void 0 ? { skipped } : {} };
+    }
+  };
+}
+function parseToolJson(texts) {
+  const candidates = [texts.join("\n"), ...texts];
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+function nextPageToken(payload) {
+  if (!isXObject(payload)) return void 0;
+  if (isXObject(payload.meta)) {
+    for (const key of ["next_token", "next_cursor", "nextToken"]) {
+      const value = payload.meta[key];
+      if (typeof value === "string" && value.length > 0) return value;
+    }
+  }
+  for (const key of ["next_token", "next_cursor", "nextToken"]) {
+    const value = payload[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
+}
+function createCorpusSource(config) {
+  return {
+    id: config.id,
+    kind: "corpusDir",
+    async fetch() {
+      const root = expandTildePath2(config.path);
+      let entries;
+      try {
+        const rootStat = await stat2(root);
+        if (!rootStat.isDirectory()) {
+          return { records: [], reads: 0, pages: 0, skipped: { reason: "corpus-dir-missing" } };
+        }
+        entries = (await readdir(root)).sort();
+      } catch {
+        return { records: [], reads: 0, pages: 0, skipped: { reason: "corpus-dir-missing" } };
+      }
+      const records = [];
+      let parseFailures = 0;
+      let skippedFiles = 0;
+      const rootReal = await realpath(root);
+      for (const name of entries) {
+        if (!name.endsWith(".json")) continue;
+        const filePath = path3.join(root, name);
+        try {
+          const info = await lstat(filePath);
+          if (info.isSymbolicLink()) {
+            const target = await realpath(filePath);
+            if (!(target === rootReal || target.startsWith(`${rootReal}${path3.sep}`))) {
+              skippedFiles += 1;
+              continue;
+            }
+          } else if (!info.isFile()) {
+            continue;
+          }
+          const parsed = JSON.parse(await readFile2(filePath, "utf8"));
+          for (const entry of asEntryList(parsed)) {
+            const record = normalizeCorpusEntry(entry, "bookmark");
+            if (record !== null) records.push(record);
+          }
+        } catch {
+          parseFailures += 1;
+        }
+      }
+      const degraded = records.length === 0 && (parseFailures > 0 || skippedFiles > 0) ? {
+        skipped: {
+          reason: "corpus-empty",
+          detail: `${parseFailures} unparseable, ${skippedFiles} out-of-root files skipped`
+        }
+      } : {};
+      return { records, reads: 0, pages: 1, ...degraded };
+    }
+  };
+}
+function asEntryList(parsed) {
+  if (Array.isArray(parsed)) return parsed;
+  if (isXObject(parsed) && Array.isArray(parsed.data)) return parsed.data;
+  return [parsed];
+}
+function createCliSource(config, deps) {
+  const exec = deps.execImpl ?? defaultExec;
+  return {
+    id: config.id,
+    kind: "cli",
+    async fetch() {
+      const records = [];
+      const commands = [
+        { args: config.bookmarksArgs, kind: "bookmark" },
+        ...config.postsArgs !== void 0 ? [{ args: config.postsArgs, kind: "own_post" }] : []
+      ];
+      let skipped;
+      for (const command of commands) {
+        let stdout;
+        try {
+          ({ stdout } = await exec(config.bin, command.args));
+        } catch (err) {
+          const code = err.code;
+          skipped = {
+            reason: code === "ENOENT" ? "cli-not-installed" : "cli-failed",
+            detail: code === "ENOENT" ? config.bin : exitDetail(err)
+          };
+          continue;
+        }
+        const parsed = parseStdout(stdout);
+        if (parsed === null) {
+          skipped = {
+            reason: "cli-output-unparseable",
+            detail: `${config.bin} ${command.args.join(" ")}`
+          };
+          continue;
+        }
+        for (const entry of asEntryList(parsed)) {
+          const record = normalizeCorpusEntry(entry, command.kind);
+          if (record !== null) records.push(record);
+        }
+      }
+      return { records, reads: 0, pages: commands.length, ...skipped !== void 0 ? { skipped } : {} };
+    }
+  };
+}
+function exitDetail(err) {
+  if (isXObject(err) && typeof err.code === "number") return `exit ${err.code}`;
+  return "non-zero exit";
+}
+function parseStdout(stdout) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+}
+async function defaultExec(bin, args) {
+  const { stdout, stderr } = await execFileAsync(bin, args, {
+    timeout: 6e4,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return { stdout, stderr };
+}
+
+// src/sync.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir2, readFile as readFile3, rename as rename3, stat as stat3, writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
+import { expandTildePath as expandTildePath3 } from "@remnic/core";
+var SEEN_CAP = 2e4;
+function freshState() {
+  return { version: 1, seen: {}, lastSyncAt: {}, lastNewCount: {}, costLedger: {} };
+}
+function monthKeyOf(nowMs) {
+  return new Date(nowMs).toISOString().slice(0, 7);
+}
+function resolveStateDir(config) {
+  return expandTildePath3(config.stateDir);
+}
+function stringRecord(raw) {
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") out[key] = value;
+  }
+  return out;
+}
+async function loadState(stateDir) {
+  const statePath = path4.join(stateDir, "state.json");
+  let raw;
+  try {
+    raw = await readFile3(statePath, "utf8");
+  } catch {
+    return { state: freshState() };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isXObject(parsed) || !isXObject(parsed.seen)) throw new Error("bad shape");
+    const costLedger = {};
+    if (isXObject(parsed.costLedger)) {
+      for (const [key, value] of Object.entries(parsed.costLedger)) {
+        if (typeof value === "number" && Number.isFinite(value)) costLedger[key] = value;
+      }
+    }
+    const seen = {};
+    for (const [postId, entry] of Object.entries(parsed.seen)) {
+      if (isXObject(entry) && typeof entry.fingerprint === "string") {
+        seen[postId] = {
+          fingerprint: entry.fingerprint,
+          firstSeenAt: typeof entry.firstSeenAt === "string" ? entry.firstSeenAt : "",
+          lastSeenAt: typeof entry.lastSeenAt === "string" ? entry.lastSeenAt : "",
+          kind: typeof entry.kind === "string" ? entry.kind : ""
+        };
+      }
+    }
+    const lastNewCountRaw = isXObject(parsed.lastNewCount) ? parsed.lastNewCount : {};
+    const lastNewCount = {};
+    for (const [key, value] of Object.entries(lastNewCountRaw)) {
+      if (typeof value === "number" && Number.isFinite(value)) lastNewCount[key] = value;
+    }
+    return {
+      state: {
+        version: 1,
+        seen,
+        lastSyncAt: stringRecord(isXObject(parsed.lastSyncAt) ? parsed.lastSyncAt : {}),
+        lastNewCount,
+        costLedger
+      }
+    };
+  } catch {
+    const quarantine = `${statePath}.corrupt`;
+    try {
+      await rename3(statePath, quarantine);
+    } catch {
+    }
+    return {
+      state: freshState(),
+      warning: `state.json was unreadable and has been quarantined at ${quarantine}`
+    };
+  }
+}
+async function saveState(stateDir, state) {
+  const entries = Object.entries(state.seen);
+  if (entries.length > SEEN_CAP) {
+    entries.sort((a, b) => compareIso(a[1].firstSeenAt, b[1].firstSeenAt, a[0], b[0]));
+    for (const [postId] of entries.slice(0, entries.length - SEEN_CAP)) {
+      delete state.seen[postId];
+    }
+  }
+  const statePath = path4.join(stateDir, "state.json");
+  const tmpPath = `${statePath}.${process.pid}.tmp`;
+  await writeFile3(tmpPath, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+  await rename3(tmpPath, statePath);
+}
+function compareIso(a, b, idA, idB) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return idA < idB ? -1 : idA > idB ? 1 : 0;
+}
+function orderedSources(config) {
+  const byId = new Map(config.sources.map((source) => [source.id, source]));
+  const ordered = [];
+  for (const id of config.sourcePriority) {
+    const source = byId.get(id);
+    if (source !== void 0) ordered.push(source);
+  }
+  for (const source of config.sources) {
+    if (!config.sourcePriority.includes(source.id)) ordered.push(source);
+  }
+  return ordered;
+}
+async function writeRecordFile(stateDir, record) {
+  const recordsDir = path4.join(stateDir, "records");
+  await mkdir2(recordsDir, { recursive: true });
+  const safeName = record.postId.replace(/[^0-9A-Za-z._-]/g, "_");
+  const recordPath = path4.join(recordsDir, `${safeName}.json`);
+  const tmpPath = `${recordPath}.tmp`;
+  await writeFile3(tmpPath, `${JSON.stringify(record, null, 2)}
+`, { mode: 384 });
+  await rename3(tmpPath, recordPath);
+}
+async function runXSync(config, deps) {
+  const stateDir = resolveStateDir(config);
+  await mkdir2(path4.join(stateDir, "records"), { recursive: true });
+  const { state, warning } = await loadState(stateDir);
+  if (warning !== void 0) {
+    process.stderr.write(`[remnic-x] warning: ${warning}
+`);
+  }
+  const now = deps.now ?? (() => Date.now());
+  const startedMs = now();
+  const runId = randomUUID();
+  const monthKey = monthKeyOf(startedMs);
+  const knownIds = new Set(Object.keys(state.seen));
+  const summaries = [];
+  let suggestionsSubmitted = 0;
+  let memoriesStored = 0;
+  let sinkFailures = 0;
+  for (const sourceConfig of orderedSources(config)) {
+    const summary = {
+      sourceId: sourceConfig.id,
+      kind: sourceConfig.kind,
+      recordsNew: 0,
+      recordsKnown: 0,
+      reads: 0,
+      pages: 0
+    };
+    const source = createXSource(sourceConfig, { ...deps, userId: config.userId });
+    const budget = sourceConfig.kind === "mcp" ? new XBudgetTracker(sourceConfig.budget, state.costLedger[monthKey] ?? 0) : unlimitedBudget;
+    let outcome;
+    try {
+      outcome = await source.fetch({ knownIds, budget });
+    } catch (err) {
+      summary.error = err instanceof Error ? err.message : String(err);
+      summaries.push(summary);
+      continue;
+    }
+    summary.reads = outcome.reads;
+    summary.pages = outcome.pages;
+    summary.skipped = outcome.skipped;
+    for (const raw of outcome.records) {
+      const record = {
+        ...raw,
+        provenance: {
+          sourceId: sourceConfig.id,
+          sourceKind: sourceConfig.kind,
+          syncRunId: runId,
+          fetchedAt: new Date(startedMs).toISOString()
+        }
+      };
+      const fingerprint = recordFingerprint(record);
+      const seenEntry = state.seen[record.postId];
+      if (seenEntry !== void 0 && seenEntry.fingerprint === fingerprint) {
+        seenEntry.lastSeenAt = new Date(startedMs).toISOString();
+        summary.recordsKnown += 1;
+        continue;
+      }
+      knownIds.add(record.postId);
+      state.seen[record.postId] = {
+        fingerprint,
+        firstSeenAt: seenEntry !== void 0 && seenEntry.firstSeenAt.length > 0 ? seenEntry.firstSeenAt : new Date(startedMs).toISOString(),
+        lastSeenAt: new Date(startedMs).toISOString(),
+        kind: record.kind
+      };
+      summary.recordsNew += 1;
+      try {
+        await writeRecordFile(stateDir, record);
+      } catch (err) {
+        sinkFailures += 1;
+        summary.error = `record write failed: ${err instanceof Error ? err.name : "write error"}`;
+        continue;
+      }
+      try {
+        const suggestion = suggestionForRecord(record);
+        if (config.memoryMode === "store") {
+          await deps.sink.storeMemory(suggestion);
+          memoriesStored += 1;
+        } else {
+          await deps.sink.submitSuggestion(suggestion);
+          suggestionsSubmitted += 1;
+        }
+      } catch {
+        sinkFailures += 1;
+      }
+    }
+    if (sourceConfig.kind === "mcp" && outcome.reads > 0) {
+      state.costLedger[monthKey] = (state.costLedger[monthKey] ?? 0) + outcome.reads * sourceConfig.budget.costPerReadUsd;
+    }
+    state.lastSyncAt[sourceConfig.id] = new Date(startedMs).toISOString();
+    state.lastNewCount[sourceConfig.id] = summary.recordsNew;
+    summaries.push(summary);
+  }
+  const finishedMs = now();
+  await saveState(stateDir, state);
+  return {
+    runId,
+    startedAt: new Date(startedMs).toISOString(),
+    finishedAt: new Date(finishedMs).toISOString(),
+    memoryMode: config.memoryMode,
+    sources: summaries,
+    suggestionsSubmitted,
+    memoriesStored,
+    sinkFailures,
+    monthKey,
+    monthSpendUsd: state.costLedger[monthKey] ?? 0
+  };
+}
+async function getXStatus(config, deps = {}) {
+  const stateDir = resolveStateDir(config);
+  const { state } = await loadState(stateDir);
+  const monthKey = monthKeyOf(Date.now());
+  const sources = [];
+  for (let index = 0; index < config.sourcePriority.length; index++) {
+    const id = config.sourcePriority[index];
+    const sourceConfig = config.sources.find((entry) => entry.id === id);
+    if (sourceConfig === void 0) continue;
+    sources.push({
+      sourceId: id,
+      kind: sourceConfig.kind,
+      priority: index,
+      lastSyncAt: state.lastSyncAt[id] ?? null,
+      lastRecordsNew: state.lastNewCount[id] ?? 0,
+      ...await probeAvailability(sourceConfig, deps)
+    });
+  }
+  const lastSyncValues = Object.values(state.lastSyncAt).sort();
+  return {
+    enabled: config.enabled,
+    memoryMode: config.memoryMode,
+    syncSchedule: config.syncSchedule,
+    sources,
+    seenCount: Object.keys(state.seen).length,
+    monthKey,
+    monthSpendUsd: state.costLedger[monthKey] ?? 0,
+    monthlyCostCapUsd: monthlyCostCapUsd(config),
+    lastSyncAt: lastSyncValues.length > 0 ? lastSyncValues[lastSyncValues.length - 1] : null
+  };
+}
+async function probeAvailability(sourceConfig, deps) {
+  if (sourceConfig.kind === "corpusDir") {
+    const dir = expandTildePath3(sourceConfig.path);
+    try {
+      const info = await stat3(dir);
+      return info.isDirectory() ? { available: true } : { available: false, availabilityDetail: `${sourceConfig.path} is not a directory` };
+    } catch {
+      return { available: false, availabilityDetail: `${sourceConfig.path} not found` };
+    }
+  }
+  if (sourceConfig.kind === "cli") {
+    return { available: true, availabilityDetail: `assumed present (${sourceConfig.bin})` };
+  }
+  const credentials = resolveMcpClientCredentials(sourceConfig, deps.env ?? process.env);
+  return credentials.clientId !== void 0 && credentials.clientSecret !== void 0 ? { available: true } : { available: false, availabilityDetail: "OAuth2 client credentials missing" };
+}
+
+export {
+  X_SOURCE_KINDS,
+  X_MEMORY_MODES,
+  X_SYNC_SCHEDULES,
+  X_DEFAULT_MCP_URL,
+  X_DEFAULT_TOKEN_FILE,
+  X_DEFAULT_STATE_DIR,
+  X_DEFAULT_COST_PER_READ_USD,
+  XConfigError,
+  coerceXBool,
+  parseXConnectorConfig,
+  resolveMcpClientCredentials,
+  monthlyCostCapUsd,
+  createFileSink,
+  isXObject,
+  stableStringify,
+  recordFingerprint,
+  normalizeMcpPayload,
+  normalizeCorpusEntry,
+  suggestionForRecord,
+  X_MCP_PROTOCOL_VERSION,
+  X_MCP_DEFAULT_URL,
+  XMcpError,
+  XCreditsDepletedError,
+  parseSseData,
+  looksLikeCreditsDepleted,
+  toolResultTexts,
+  XMcpClient,
+  X_TOKEN_REFRESH_URL,
+  XTokenError,
+  XRefreshChainBrokenError,
+  XTokenStore,
+  XBudgetTracker,
+  unlimitedBudget,
+  createXSource,
+  runXSync,
+  getXStatus
+};
+//# sourceMappingURL=chunk-JR2ZNAYD.js.map