x-relay-mcp 1.0.0 → 1.1.0

package/dist/{cli-DZkaLoUg.d.ts → cli-DO7p1WNQ.d.ts}

@@ -206,11 +206,15 @@ interface Engine {
     userTweets(handle: string, opts?: UserTweetsOpts): Promise<TweetPage>;
     bookmarks(opts?: PageOpts): Promise<TweetPage>;
     thread(id: string): Promise<ThreadResult>;
+    /** The authenticated user's own @handle (from the session), or null. Memoized. */
+    me(): Promise<string | null>;
 }
 interface EngineDeps {
     /** Cookies for auth. Omit to auto-extract from the local browser (getCookies). */
     cookies?: Cookies;
     fetchImpl?: typeof fetch;
+    /** Backoff between cold-start retries. Injectable (tests pass a no-op). */
+    sleep?: (ms: number) => Promise<void>;
     /** Injectable transport (tests). Defaults to a real client over the X API. */
     client?: EngineClient;
     /** Injectable transaction provider (tests). Defaults to the xctid generator. */

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export { o as ParsedArgs, m as dispatch, p as parseArgs, r as run } from './cli-DZkaLoUg.js';
+export { o as ParsedArgs, m as dispatch, p as parseArgs, r as run } from './cli-DO7p1WNQ.js';

package/dist/cli.js

@@ -192,15 +192,15 @@ function syncBookmarks(engine, opts = {}) {
     opts
   );
 }
-function syncPosts(engine, handle, opts = {}) {
+async function syncPosts(engine, handle, opts = {}) {
   const file = loadCache("posts", opts.dir);
-  if (handle) file.handle = handle;
-  const h = file.handle;
+  const h = handle ?? file.handle ?? await engine.me() ?? void 0;
   if (!h) {
-    return Promise.reject(
-      new Error("posts sync needs your handle once: `xrelay sync posts --handle <you>`")
+    throw new Error(
+      "couldn't determine your handle \u2014 pass `--handle <you>` (auto-detect needs a valid session)"
     );
   }
+  file.handle = h;
   return syncInto(
     file,
     (limit, stopAtId) => engine.userTweets(h, { limit, ...stopAtId !== void 0 ? { stopAtId } : {} }),
@@ -1465,6 +1465,8 @@ function idLte(a, b) {
     return a.length === b.length ? a <= b : a.length < b.length;
   }
 }
+var MAX_NOTFOUND_RETRIES = 2;
+var RETRY_BACKOFF_MS = 400;
 function createTransactionProvider(fetchImpl) {
   let ctPromise;
   const init = async () => ClientTransaction.create(await handleXMigration(fetchImpl));
@@ -1514,28 +1516,56 @@ async function paginate(fetchPage, limit, stopAtId) {
   return out;
 }
 function createEngine(deps) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const txn = deps.transaction ? { provider: deps.transaction, refresh: async () => {
   } } : createTransactionProvider(deps.fetchImpl);
+  let cookiesCache = deps.cookies;
+  const resolveCookies = () => {
+    if (cookiesCache === void 0) cookiesCache = getCookies();
+    return cookiesCache;
+  };
   const client = deps.client ?? createClient({
-    cookies: deps.cookies ?? getCookies(),
+    cookies: resolveCookies(),
     transaction: txn.provider,
     ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
   });
-  async function call(op, request, retried = false) {
+  async function call(op, request, attempt = 0) {
     const res = await client.get(op, request);
     if (res.ok) return res.value;
-    if (res.error.code === "NOT_FOUND" && !retried) {
+    if (res.error.code === "NOT_FOUND" && attempt < MAX_NOTFOUND_RETRIES) {
       await txn.refresh();
-      return call(op, request, true);
+      await sleep(RETRY_BACKOFF_MS * (attempt + 1));
+      return call(op, request, attempt + 1);
     }
     throw new EngineError(res.error.code, res.error.message, res.error.status);
   }
+  let mePromise;
+  async function fetchMe() {
+    const path = "/1.1/account/settings.json";
+    try {
+      const txid = await txn.provider("GET", path);
+      const res = await fetchImpl(`https://api.x.com${path}`, {
+        headers: buildHeaders({ cookies: resolveCookies(), transactionId: txid })
+      });
+      if (!res.ok) return null;
+      const data = await res.json();
+      return data.screen_name ?? null;
+    } catch {
+      return null;
+    }
+  }
+  const me = () => {
+    if (mePromise === void 0) mePromise = fetchMe();
+    return mePromise;
+  };
   async function getUser(handle) {
     const value = await call("UserByScreenName", userByScreenNameRequest({ screenName: handle }));
     const result = findDict(value, "result", true)[0];
     return parseUserResult(result);
   }
   return {
+    me,
     async search(query, opts) {
       const product = opts?.product ?? "Top";
       const limit = opts?.limit ?? DEFAULT_LIMIT2;
@@ -1677,15 +1707,14 @@ function runBookmarks(engine, opts = {}) {
 }
 function runMyPosts(engine, opts = {}) {
   if (opts.live) {
-    if (!opts.handle) {
-      return Promise.resolve(err("my-posts", "INVALID_INPUT", "--live needs --handle <you>"));
-    }
-    return guard(
-      "my-posts",
-      () => engine.userTweets(opts.handle, {
+    return guard("my-posts", async () => {
+      const handle = opts.handle ?? await engine.me();
+      if (!handle)
+        throw new EngineError("INVALID_INPUT", "could not determine your handle \u2014 pass --handle");
+      return engine.userTweets(handle, {
         ...opts.limit !== void 0 ? { limit: opts.limit } : {}
-      })
-    );
+      });
+    });
   }
   return guard("my-posts", async () => {
     let added;
@@ -1707,7 +1736,7 @@ function viewCache(source, opts, added) {
   if (file.syncedAt !== void 0) view.syncedAt = file.syncedAt;
   if (added !== void 0) view.added = added;
   if (total === 0) {
-    view.hint = `cache is empty \u2014 run \`xrelay sync ${source}${source === "posts" ? " --handle <you>" : ""}\` first (or pass --live).`;
+    view.hint = `cache is empty \u2014 run \`xrelay sync ${source}\` first (or pass --live).`;
   }
   return view;
 }