x-relay-mcp 1.2.0 → 1.3.0

package/.claude/skills/x-relay/SKILL.md

@@ -116,6 +116,8 @@ xrelay quoters <id|url> [--limit N]         # tweets quoting a tweet (reactions;
 xrelay trends [--woeid N] [--limit N]       # what's hot now (woeid 1 = worldwide, default)
 xrelay article <id|url>                     # a long-form X Article → Markdown
 xrelay media <id|url> [--out <dir>]         # a tweet's image/video URLs; --out downloads the files
+xrelay community <community-id> [--limit N] # a community's tweet feed (topical, moderated sub-network)
+xrelay community-info <community-id>        # community metadata: name, members, rules, topic, creator
 ```
 
 - **`retweeters`/`followers`/`following`** return `{ users:[<profile>...], nextCursor }` — the
@@ -127,6 +129,11 @@ xrelay media <id|url> [--out <dir>]         # a tweet's image/video URLs; --out
 - **`article`** returns `{ id, title, markdown, url }` — the full long-form read for a finalist.
 - **`media`** returns `{ tweetId, media:[{type,url,...}], files? }`; `--out <dir>` saves the actual
   image/video files (for OCR / transcription / multimodal analysis).
+- **`community`** returns the community's feed as a normal `{ tweets[], nextCursor }` — a focused,
+  on-topic corpus that's often higher-signal than open search for a niche. **`community-info`** returns
+  `{ name, description, memberCount, moderatorCount, rules[], topic, tags[], creator, url }`. Get the
+  `community-id` from a community URL (`x.com/i/communities/<id>`). Note: X exposes no stable endpoint for
+  a full member roster or within-community search, so those aren't provided — use the feed + `search`.
 
 ---
 
@@ -154,3 +161,28 @@ npm i -g x-relay-mcp
 ```
 Cookies are read automatically from your logged-in browser (macOS Keychain). The first run may show a one-time
 Keychain "Always Allow" prompt. Assumes a residential IP (run locally); datacenter IPs are blocked by X.
+
+### Account pool + proxy (optional — for heavy/sustained use)
+
+X rate-limits per account and blocks datacenter IPs. For deep sweeps, give the tool **several sessions, each
+behind its own residential proxy**; it transparently fails over to the next session when one hits a rate-limit
+(429) or its cookies expire — so a long research run survives a single account getting throttled. All optional;
+the default single-browser-session path needs none of this.
+
+```
+# Several accounts, each pinned to its own proxy (JSON array — the robust form):
+export XRELAY_ACCOUNTS='[
+  {"cookies":"auth_token=..; ct0=..","proxy":"http://user:pass@host1:port","label":"main"},
+  {"cookies":"auth_token=..; ct0=..","proxy":"socks5://user:pass@host2:port"}
+]'
+
+# Or a simpler newline list of cookie strings, with proxies round-robined onto them:
+export XRELAY_ACCOUNTS=$'auth_token=..; ct0=..\nauth_token=..; ct0=..'
+export XRELAY_PROXIES='http://host1:port, http://host2:port'
+
+# Single browser session, just routed through one proxy:
+export XRELAY_PROXY='http://user:pass@host:port'
+```
+
+Rotation triggers on `RATE_LIMITED` / `AUTH_FAILED` only; other errors fail fast. Pair an equal number of
+accounts and proxies for a clean 1:1 mapping. http(s) and socks proxies are both supported.

package/dist/{cli-B4ohNfa7.d.ts → cli-DDbxyp9v.d.ts}

@@ -115,6 +115,24 @@ type Article = {
     url: string;
     author?: Author;
 };
+/** An X Community's metadata (the `community-info` command). */
+type Community = {
+    id: string;
+    name: string;
+    description?: string;
+    memberCount?: number;
+    moderatorCount?: number;
+    /** ISO timestamp (X reports created_at as epoch ms). */
+    createdAt?: string;
+    /** The viewer's role in the community (Member / Moderator / Admin / NonMember). */
+    role?: string;
+    joinPolicy?: string;
+    topic?: string;
+    rules?: string[];
+    tags?: string[];
+    creator?: Author;
+    url: string;
+};
 
 /** The two load-bearing cookies, plus any others the jar carries. */
 type Cookies = {
@@ -197,6 +215,14 @@ declare const OPS: {
         readonly queryId: "Xl5pC_lBk_gcO2ItU39DQw";
         readonly operationName: "TweetResultByRestId";
     };
+    readonly CommunityByRestId: {
+        readonly queryId: "vLS7mhOqMLtGZdXqFP1DEg";
+        readonly operationName: "CommunityByRestId";
+    };
+    readonly CommunityTweetsTimeline: {
+        readonly queryId: "pXYASW5kVylF3YMrGJovLg";
+        readonly operationName: "CommunityTweetsTimeline";
+    };
 };
 type OpName = keyof typeof OPS;
 type Vars = Record<string, unknown>;
@@ -266,6 +292,8 @@ interface Engine {
     }): Promise<Trend[]>;
     article(tweetId: string): Promise<Article | null>;
     media(tweetId: string): Promise<MediaItem[]>;
+    community(communityId: string, opts?: PageOpts): Promise<TweetPage>;
+    communityInfo(communityId: string): Promise<Community | null>;
     /** The authenticated user's own @handle (from the session), or null. Memoized. */
     me(): Promise<string | null>;
 }
@@ -277,6 +305,8 @@ interface EngineDeps {
     sleep?: (ms: number) => Promise<void>;
     /** Injectable transport (tests). Defaults to a real client over the X API. */
     client?: EngineClient;
+    /** Injectable transport lanes (tests) — drives account-pool rotation. Overrides `client`. */
+    clients?: EngineClient[];
     /** Injectable transaction provider (tests). Defaults to the xctid generator. */
     transaction?: TransactionProvider;
 }
@@ -293,4 +323,4 @@ declare function parseArgs(argv: string[]): ParsedArgs;
 declare function dispatch(parsed: ParsedArgs, engine: Engine): Promise<Envelope<unknown>>;
 declare function run(argv: string[], engine?: Engine): Promise<number>;
 
-export { type Article as A, type Cookies as C, type Err as E, type MediaItem as M, type Ok as O, type PageOpts as P, type SearchResult as S, type Tweet as T, type UserPage as U, type Engine as a, type Envelope as b, type TweetPage as c, type SearchProduct as d, type ThreadResult as e, type Trend as f, type UserProfile as g, type Author as h, type EngineDeps as i, EngineError as j, type MediaKind as k, type Metrics as l, type SearchOpts as m, type SearchProduct$1 as n, type UserTweetsOpts as o, createEngine as p, dispatch as q, parseArgs as r, parseCookies as s, run as t, type ParsedArgs as u };
+export { type Article as A, type Cookies as C, type Err as E, type MediaItem as M, type Ok as O, type PageOpts as P, type SearchResult as S, type Tweet as T, type UserPage as U, type Engine as a, type Envelope as b, type TweetPage as c, type SearchProduct as d, type ThreadResult as e, type Trend as f, type UserProfile as g, type Author as h, type Community as i, type EngineDeps as j, EngineError as k, type MediaKind as l, type Metrics as m, type SearchOpts as n, type SearchProduct$1 as o, type UserTweetsOpts as p, createEngine as q, dispatch as r, parseArgs as s, parseCookies as t, run as u, type ParsedArgs as v };

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export { u as ParsedArgs, q as dispatch, r as parseArgs, t as run } from './cli-B4ohNfa7.js';
+export { v as ParsedArgs, r as dispatch, s as parseArgs, u as run } from './cli-DDbxyp9v.js';

package/dist/cli.js

@@ -106,6 +106,18 @@ var COMMANDS = [
     cost: "medium",
     summary: "A tweet's image/video assets (URLs); --out <dir> downloads the files.",
     usage: "xrelay media <id|url> [--out <dir>]"
+  },
+  {
+    name: "community",
+    cost: "medium",
+    summary: "A community's tweet feed (a topical, moderated sub-network).",
+    usage: "xrelay community <community-id> [--limit N]"
+  },
+  {
+    name: "community-info",
+    cost: "1 call",
+    summary: "Community metadata: name, description, member/mod counts, rules, topic, creator.",
+    usage: "xrelay community-info <community-id>"
   }
 ];
 var commandNames = COMMANDS.map((c) => c.name);
@@ -364,7 +376,12 @@ var OPS = {
   Retweeters: { queryId: "TZsWuSj7vGmncVnq7KWDUQ", operationName: "Retweeters" },
   Favoriters: { queryId: "LLkw5EcVutJL6y-2gkz22A", operationName: "Favoriters" },
   GenericTimelineById: { queryId: "_dGVIf1cY6xFanFNPsAzPQ", operationName: "GenericTimelineById" },
-  TweetResultByRestId: { queryId: "Xl5pC_lBk_gcO2ItU39DQw", operationName: "TweetResultByRestId" }
+  TweetResultByRestId: { queryId: "Xl5pC_lBk_gcO2ItU39DQw", operationName: "TweetResultByRestId" },
+  CommunityByRestId: { queryId: "vLS7mhOqMLtGZdXqFP1DEg", operationName: "CommunityByRestId" },
+  CommunityTweetsTimeline: {
+    queryId: "pXYASW5kVylF3YMrGJovLg",
+    operationName: "CommunityTweetsTimeline"
+  }
 };
 var FEATURES = {
   rweb_video_screen_enabled: false,
@@ -535,6 +552,24 @@ function tweetResultRequest(params) {
     fieldToggles: { withArticleRichContentState: true, withArticlePlainText: true }
   };
 }
+function communityRequest(params) {
+  const { communityId, kv, ft } = params;
+  return {
+    variables: { communityId, ...kv },
+    features: { ...FEATURES, ...ft }
+  };
+}
+function communityTweetsRequest(params) {
+  const { communityId, count = 20, cursor, rankingMode = "Relevance", kv, ft } = params;
+  const variables = withCursor(
+    { communityId, count, displayLocation: "Community", rankingMode, withCommunity: true },
+    cursor
+  );
+  return {
+    variables: { ...variables, ...kv },
+    features: { ...FEATURES, ...ft }
+  };
+}
 function stableStringify(value) {
   if (Array.isArray(value)) {
     return `[${value.map(stableStringify).join(",")}]`;
@@ -1394,6 +1429,118 @@ function articleAuthor(tweetResult) {
     return void 0;
   }
 }
+function authorFromProfile2(profile) {
+  const author = {
+    id: profile.id,
+    handle: profile.handle,
+    name: profile.name,
+    verified: profile.verified,
+    followers: profile.followers
+  };
+  if (profile.avatar !== void 0) author.avatar = profile.avatar;
+  return author;
+}
+function ruleNames(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const rule of raw) {
+    const name = isRecord2(rule) ? asString2(rule.name) : void 0;
+    if (name !== void 0) out.push(name);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function stringArray(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = raw.filter((v) => typeof v === "string");
+  return out.length > 0 ? out : void 0;
+}
+function communityCreator(result) {
+  const node = child2(result, "creator_results")?.result;
+  const profile = parseUserResult(node);
+  return profile ? authorFromProfile2(profile) : void 0;
+}
+function applyCommunityOptionals(community, result) {
+  const description = asString2(result.description);
+  if (description !== void 0) community.description = description;
+  const memberCount = asNumber2(result.member_count);
+  if (memberCount !== void 0) community.memberCount = memberCount;
+  const moderatorCount = asNumber2(result.moderator_count);
+  if (moderatorCount !== void 0) community.moderatorCount = moderatorCount;
+  const createdMs = asNumber2(result.created_at);
+  if (createdMs !== void 0) community.createdAt = new Date(createdMs).toISOString();
+  const role = asString2(result.role);
+  if (role !== void 0) community.role = role;
+  const joinPolicy = asString2(result.join_policy);
+  if (joinPolicy !== void 0) community.joinPolicy = joinPolicy;
+  const topic = asString2(child2(result, "primary_community_topic")?.topic_name);
+  if (topic !== void 0) community.topic = topic;
+  const rules = ruleNames(result.rules);
+  if (rules !== void 0) community.rules = rules;
+  const tags = stringArray(result.search_tags);
+  if (tags !== void 0) community.tags = tags;
+  const creator = communityCreator(result);
+  if (creator !== void 0) community.creator = creator;
+}
+function parseCommunity(json) {
+  const wrapper = findDict(json, "communityResults", true)[0];
+  const result = isRecord2(wrapper) ? wrapper.result : void 0;
+  if (!isRecord2(result)) return null;
+  const id = asString2(result.id_str) ?? asString2(result.rest_id);
+  const name = asString2(result.name);
+  if (id === void 0 || name === void 0) return null;
+  const community = { id, name, url: `https://x.com/i/communities/${id}` };
+  applyCommunityOptionals(community, result);
+  return community;
+}
+
+// src/engine/pool.ts
+function parseProxyList(raw) {
+  return raw.split(/[\n,]/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function specFromJsonItem(item, index) {
+  const cookieStr = typeof item === "string" ? item : String(item?.cookies ?? "");
+  const spec = {
+    cookies: parseCookies(cookieStr),
+    label: typeof item === "object" && item !== null && typeof item.label === "string" ? String(item.label) : `acct${index + 1}`
+  };
+  const proxy = typeof item === "object" && item !== null ? item.proxy : void 0;
+  if (typeof proxy === "string" && proxy.length > 0) spec.proxy = proxy;
+  return spec;
+}
+function parseAccounts(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return [];
+  if (trimmed.startsWith("[")) {
+    const parsed = JSON.parse(trimmed);
+    if (!Array.isArray(parsed)) throw new Error("XRELAY_ACCOUNTS JSON must be an array");
+    return parsed.map(specFromJsonItem);
+  }
+  return trimmed.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line, i) => ({ cookies: parseCookies(line), label: `acct${i + 1}` }));
+}
+function assignProxies(specs, proxies) {
+  if (proxies.length === 0) return specs;
+  return specs.map((spec, i) => {
+    if (spec.proxy !== void 0) return spec;
+    const proxy = proxies[i % proxies.length];
+    return proxy === void 0 ? spec : { ...spec, proxy };
+  });
+}
+function makeFetch(proxy, base) {
+  if (proxy === void 0 || proxy.length === 0) return base;
+  let dispatcher;
+  const getDispatcher = () => {
+    if (dispatcher === void 0) {
+      dispatcher = import("undici").then((m) => new m.ProxyAgent(proxy));
+    }
+    return dispatcher;
+  };
+  const proxied = async (input, init) => {
+    const d = await getDispatcher();
+    const widened = { ...init ?? {}, dispatcher: d };
+    return base(input, widened);
+  };
+  return proxied;
+}
 
 // src/engine/xctid/transaction.ts
 import { createHash } from "crypto";
@@ -1870,6 +2017,7 @@ function idLte(a, b) {
     return a.length === b.length ? a <= b : a.length < b.length;
   }
 }
+var ROTATE_CODES = /* @__PURE__ */ new Set(["RATE_LIMITED", "AUTH_FAILED"]);
 var MAX_NOTFOUND_RETRIES = 2;
 var RETRY_BACKOFF_MS = 400;
 function createTransactionProvider(fetchImpl) {
@@ -1948,37 +2096,72 @@ async function paginateUsers(fetchPage, limit) {
   return out;
 }
 function createEngine(deps) {
-  const fetchImpl = deps.fetchImpl ?? fetch;
+  const baseFetch = 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: resolveCookies(),
-    transaction: txn.provider,
-    ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
-  });
-  async function call(op, request, attempt = 0) {
-    const res = await client.get(op, request);
-    if (res.ok) return res.value;
+  function resolveSpecs() {
+    const accountsRaw = (process.env.XRELAY_ACCOUNTS ?? "").trim();
+    const proxies = parseProxyList(process.env.XRELAY_PROXIES ?? "");
+    let specs = accountsRaw.length > 0 ? parseAccounts(accountsRaw) : [];
+    if (specs.length === 0) {
+      const spec = { cookies: deps.cookies ?? getCookies(), label: "default" };
+      const singleProxy = (process.env.XRELAY_PROXY ?? "").trim();
+      if (singleProxy.length > 0) spec.proxy = singleProxy;
+      specs = [spec];
+    }
+    return assignProxies(specs, proxies);
+  }
+  function buildLanes() {
+    const injected = deps.clients ?? (deps.client ? [deps.client] : void 0);
+    const fallbackCookies = deps.cookies ?? { authToken: "", ct0: "" };
+    if (injected !== void 0) {
+      return injected.map((client) => ({ client, cookies: fallbackCookies, fetchImpl: baseFetch }));
+    }
+    return resolveSpecs().map((spec) => {
+      const fetchImpl = makeFetch(spec.proxy, baseFetch);
+      return {
+        client: createClient({ cookies: spec.cookies, transaction: txn.provider, fetchImpl }),
+        cookies: spec.cookies,
+        fetchImpl
+      };
+    });
+  }
+  const lanes = buildLanes();
+  let current = 0;
+  const activeLane = () => lanes[current] ?? lanes[0] ?? {};
+  async function callLane(lane, op, request, attempt = 0) {
+    const res = await lane.client.get(op, request);
+    if (res.ok) return res;
     if (res.error.code === "NOT_FOUND" && attempt < MAX_NOTFOUND_RETRIES) {
       await txn.refresh();
       await sleep(RETRY_BACKOFF_MS * (attempt + 1));
-      return call(op, request, attempt + 1);
+      return callLane(lane, op, request, attempt + 1);
     }
-    throw new EngineError(res.error.code, res.error.message, res.error.status);
+    return res;
+  }
+  async function call(op, request) {
+    let lastError = {
+      code: "FETCH_FAILED",
+      message: "no lanes available"
+    };
+    for (let laneTry = 0; laneTry < lanes.length; laneTry++) {
+      const res = await callLane(activeLane(), op, request);
+      if (res.ok) return res.value;
+      lastError = res.error;
+      if (!ROTATE_CODES.has(res.error.code)) break;
+      current = (current + 1) % lanes.length;
+    }
+    throw new EngineError(lastError.code, lastError.message, lastError.status);
   }
   let mePromise;
   async function fetchMe() {
     const path = "/1.1/account/settings.json";
     try {
+      const lane = activeLane();
       const txid = await txn.provider("GET", path);
-      const res = await fetchImpl(`https://api.x.com${path}`, {
-        headers: buildHeaders({ cookies: resolveCookies(), transactionId: txid })
+      const res = await lane.fetchImpl(`https://api.x.com${path}`, {
+        headers: buildHeaders({ cookies: lane.cookies, transactionId: txid })
       });
       if (!res.ok) return null;
       const data = await res.json();
@@ -2098,9 +2281,10 @@ function createEngine(deps) {
     async trends(opts) {
       const woeid = opts?.woeid ?? 1;
       const path = "/1.1/trends/place.json";
+      const lane = activeLane();
       const txid = await txn.provider("GET", path);
-      const res = await fetchImpl(`https://api.x.com${path}?id=${woeid}`, {
-        headers: buildHeaders({ cookies: resolveCookies(), transactionId: txid })
+      const res = await lane.fetchImpl(`https://api.x.com${path}?id=${woeid}`, {
+        headers: buildHeaders({ cookies: lane.cookies, transactionId: txid })
       });
       if (!res.ok) {
         throw new EngineError("FETCH_FAILED", `trends request failed (${res.status})`, res.status);
@@ -2126,6 +2310,24 @@ function createEngine(deps) {
       const value = await call("TweetResultByRestId", tweetResultRequest({ tweetId }));
       const result = findDict(value, "result", true)[0];
       return extractTweetMedia(result);
+    },
+    async community(communityId, opts) {
+      const limit = opts?.limit ?? DEFAULT_LIMIT2;
+      return paginate(
+        async (cursor) => {
+          const value = await call(
+            "CommunityTweetsTimeline",
+            communityTweetsRequest({ communityId, cursor })
+          );
+          return parseTimeline(value);
+        },
+        limit,
+        opts?.stopAtId
+      );
+    },
+    async communityInfo(communityId) {
+      const value = await call("CommunityByRestId", communityRequest({ communityId }));
+      return parseCommunity(value);
     }
   };
   function usersByHandle(op, handle, limit) {
@@ -2251,6 +2453,20 @@ function runTrends(engine, opts = {}) {
     })
   );
 }
+function runCommunity(engine, communityId, limit) {
+  if (!communityId)
+    return Promise.resolve(err("community", "INVALID_INPUT", "missing community id"));
+  return guard("community", () => engine.community(communityId, lim(limit)));
+}
+function runCommunityInfo(engine, communityId) {
+  if (!communityId)
+    return Promise.resolve(err("community-info", "INVALID_INPUT", "missing community id"));
+  return guard("community-info", async () => {
+    const info = await engine.communityInfo(communityId);
+    if (!info) throw new EngineError("NOT_FOUND", "community not found");
+    return info;
+  });
+}
 function runArticle(engine, tweetId) {
   if (!tweetId) return Promise.resolve(err("article", "INVALID_INPUT", "missing tweet id/url"));
   return guard("article", async () => {
@@ -2509,6 +2725,40 @@ function buildSearchOpts(parsed) {
     ...parsed.flags.filter ? { filter: parsed.flags.filter } : {}
   };
 }
+function dispatchReadOps(parsed, engine, command, target) {
+  const limit = num(parsed, "limit");
+  switch (command) {
+    case "list":
+      return runList(engine, target, limit);
+    case "user-media":
+      return runUserMedia(engine, extractHandle(target) ?? target, limit);
+    case "followers":
+      return runFollowers(engine, extractHandle(target) ?? target, limit);
+    case "following":
+      return runFollowing(engine, extractHandle(target) ?? target, limit);
+    case "retweeters":
+      return runRetweeters(engine, extractTweetId(target) ?? target, limit);
+    case "likers":
+      return runLikers(engine, extractTweetId(target) ?? target, limit);
+    case "quoters":
+      return runQuoters(engine, extractTweetId(target) ?? target, limit);
+    case "trends":
+      return runTrends(engine, {
+        ...num(parsed, "woeid") !== void 0 ? { woeid: num(parsed, "woeid") } : {},
+        ...limit !== void 0 ? { limit } : {}
+      });
+    case "article":
+      return runArticle(engine, extractTweetId(target) ?? target);
+    case "media":
+      return runMedia(engine, extractTweetId(target) ?? target, first(parsed, "out"));
+    case "community":
+      return runCommunity(engine, target, limit);
+    case "community-info":
+      return runCommunityInfo(engine, target);
+    default:
+      return null;
+  }
+}
 async function dispatch(parsed, engine) {
   const { command } = parsed;
   const target = parsed.positionals[0] ?? "";
@@ -2541,31 +2791,8 @@ async function dispatch(parsed, engine) {
         ...num(parsed, "max") !== void 0 ? { max: num(parsed, "max") } : {}
       });
     }
-    case "list":
-      return runList(engine, target, num(parsed, "limit"));
-    case "user-media":
-      return runUserMedia(engine, extractHandle(target) ?? target, num(parsed, "limit"));
-    case "followers":
-      return runFollowers(engine, extractHandle(target) ?? target, num(parsed, "limit"));
-    case "following":
-      return runFollowing(engine, extractHandle(target) ?? target, num(parsed, "limit"));
-    case "retweeters":
-      return runRetweeters(engine, extractTweetId(target) ?? target, num(parsed, "limit"));
-    case "likers":
-      return runLikers(engine, extractTweetId(target) ?? target, num(parsed, "limit"));
-    case "quoters":
-      return runQuoters(engine, extractTweetId(target) ?? target, num(parsed, "limit"));
-    case "trends":
-      return runTrends(engine, {
-        ...num(parsed, "woeid") !== void 0 ? { woeid: num(parsed, "woeid") } : {},
-        ...num(parsed, "limit") !== void 0 ? { limit: num(parsed, "limit") } : {}
-      });
-    case "article":
-      return runArticle(engine, extractTweetId(target) ?? target);
-    case "media":
-      return runMedia(engine, extractTweetId(target) ?? target, first(parsed, "out"));
     default:
-      return err("cli", "UNKNOWN_COMMAND", `unknown command: ${command ?? "(none)"}`);
+      return dispatchReadOps(parsed, engine, command, target) ?? Promise.resolve(err("cli", "UNKNOWN_COMMAND", `unknown command: ${command ?? "(none)"}`));
   }
 }
 async function run(argv, engine) {