xbird-mcp 0.1.0

package/docs/listing.md

@@ -0,0 +1,42 @@
+# xbird Listing Guide
+
+Where to list xbird for discovery by AI agents and developers.
+
+## 1. x402.org/ecosystem
+
+Main x402 agent catalog. Submit via the website form.
+
+- URL: https://x402.org/ecosystem
+- Include: agent card URL, description, pricing tiers
+- Category: "Data API" / "Social Media"
+
+## 2. x402scan.com
+
+On-chain agent explorer with metrics (revenue, requests, uptime).
+
+- Auto-indexes agents registered via ERC-8004 Identity Registry
+- After running `bun run register`, xbird should appear automatically
+- Verify at: https://x402scan.com/agent/{agentId}
+
+## 3. x402.eco
+
+SDK registry for agent integration.
+
+- URL: https://x402.eco
+- Submit package/agent for inclusion in SDK discovery
+
+## 4. GitHub topic
+
+Add the `x402` topic to the xbird GitHub repository:
+
+1. Go to repo Settings > Topics
+2. Add: `x402`, `erc-8004`, `twitter-api`, `micropayments`
+
+## Checklist
+
+- [ ] Deploy to Railway (`railway up`)
+- [ ] Register on-chain (`bun run register`)
+- [ ] Submit to x402.org/ecosystem
+- [ ] Verify on x402scan.com
+- [ ] Submit to x402.eco
+- [ ] Add GitHub topics

package/docs/mcp-setup.md

@@ -0,0 +1,146 @@
+# xbird MCP Server Setup
+
+xbird MCP server runs locally on your machine, executing Twitter API requests from your residential IP while paying per-operation via x402 protocol.
+
+## Prerequisites
+
+- [Bun](https://bun.sh) runtime
+- Twitter account cookies (`auth_token` and `ct0`)
+- USDC wallet private key (Base network) for x402 payments
+
+## Getting Twitter Cookies
+
+1. Open Twitter/X in your browser
+2. Open DevTools → Application → Cookies → `https://x.com`
+3. Copy `auth_token` and `ct0` values
+
+## Configuration
+
+### Claude Code
+
+Add to `~/.claude.json` or project `.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "xbird": {
+      "command": "bunx",
+      "args": ["xbird-mcp"],
+      "env": {
+        "XBIRD_AUTH_TOKEN": "your_auth_token",
+        "XBIRD_CT0": "your_ct0",
+        "XBIRD_PRIVATE_KEY": "0x_your_private_key"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to Cursor settings (MCP section):
+
+```json
+{
+  "mcpServers": {
+    "xbird": {
+      "command": "bunx",
+      "args": ["xbird-mcp"],
+      "env": {
+        "XBIRD_AUTH_TOKEN": "your_auth_token",
+        "XBIRD_CT0": "your_ct0",
+        "XBIRD_PRIVATE_KEY": "0x_your_private_key"
+      }
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to Windsurf MCP config:
+
+```json
+{
+  "mcpServers": {
+    "xbird": {
+      "command": "bunx",
+      "args": ["xbird-mcp"],
+      "env": {
+        "XBIRD_AUTH_TOKEN": "your_auth_token",
+        "XBIRD_CT0": "your_ct0",
+        "XBIRD_PRIVATE_KEY": "0x_your_private_key"
+      }
+    }
+  }
+}
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `XBIRD_AUTH_TOKEN` | Yes | Twitter `auth_token` cookie |
+| `XBIRD_CT0` | Yes | Twitter `ct0` cookie |
+| `XBIRD_PRIVATE_KEY` | Yes | Wallet private key for USDC payments (Base) |
+| `XBIRD_SERVER_URL` | No | Payment server URL (default: `https://xbirdapi.up.railway.app`) |
+
+## Available Tools (30)
+
+### Read ($0.001/call)
+- `get_tweet` — Get a tweet by ID
+- `get_thread` — Get a tweet thread
+- `get_replies` — Get replies to a tweet
+- `get_user` — Get user profile by handle
+- `get_user_about` — Get detailed user info
+- `get_current_user` — Get authenticated user
+- `get_home_timeline` — Get home timeline
+- `get_news` — Get trending topics
+- `get_lists` — Get owned lists
+- `get_list_timeline` — Get tweets from a list
+
+### Search ($0.005/call)
+- `search_tweets` — Search for tweets
+- `get_mentions` — Get mentions for a user
+
+### Bulk ($0.01/call)
+- `get_user_tweets` — Get user's tweets
+- `get_followers` — Get user's followers
+- `get_following` — Get user's following
+- `get_likes` — Get user's liked tweets
+- `get_bookmarks` — Get bookmarked tweets
+- `get_list_memberships` — Get list memberships
+
+### Write ($0.01/call)
+- `post_tweet` — Post a tweet
+- `reply_to_tweet` — Reply to a tweet
+- `post_thread` — Post a thread
+- `like_tweet` / `unlike_tweet` — Like/unlike
+- `retweet` / `unretweet` — Retweet/unretweet
+- `bookmark_tweet` / `unbookmark_tweet` — Bookmark/unbookmark
+- `follow_user` / `unfollow_user` — Follow/unfollow
+
+### Media ($0.05/call)
+- `upload_media` — Upload image/video for tweets
+
+## Manual Testing
+
+```bash
+# List available tools
+echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | bun src/mcp/server.ts
+
+# Run directly
+bun src/mcp/server.ts
+```
+
+## How It Works
+
+```
+AI Agent (Claude/Cursor)
+  ↓ MCP stdio
+xbird-mcp (local process)
+  ├─ Pay x402 → Railway /api/authorize/:tier
+  └─ Execute → Twitter API (local residential IP)
+```
+
+The Railway server acts as a payment gateway only — it verifies x402 payments but does not make Twitter requests. Twitter API calls happen locally from your machine, avoiding datacenter IP blocks.

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "xbird-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Twitter/X — 30 tools with x402 micropayments, runs locally from residential IP",
+  "module": "src/index.ts",
+  "type": "module",
+  "keywords": ["mcp", "twitter", "x", "x402", "ai", "agent", "claude", "cursor"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/checkra1neth/xbird"
+  },
+  "license": "MIT",
+  "bin": {
+    "xbird": "src/cli.ts",
+    "xbird-mcp": "src/mcp/server.ts"
+  },
+  "files": [
+    "src/**/*.ts",
+    "docs/",
+    "package.json",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "dev": "bun run src/cli.ts",
+    "build": "bun build --compile --minify src/cli.ts --outfile xbird",
+    "test": "bun test",
+    "check": "bun run --bun tsc --noEmit",
+    "server": "bun --hot src/server.ts",
+    "server:dev": "bun --watch src/server.ts",
+    "register": "bun run src/server/erc8004/register.ts",
+    "mcp": "bun src/mcp/server.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@x402/fetch": "^2.3.0",
+    "typescript": "^5.9.0"
+  },
+  "dependencies": {
+    "@coinbase/cdp-sdk": "^1.44.0",
+    "@steipete/sweet-cookie": "^0.1.0",
+    "@x402/core": "^2.3.0",
+    "@x402/evm": "^2.3.0",
+    "@x402/hono": "^2.3.0",
+    "commander": "^14.0.3",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "hono": "^4.11.9",
+    "kleur": "^4.1.5",
+    "viem": "^2.45.2"
+  }
+}

package/src/cli/context.ts

@@ -0,0 +1,80 @@
+import type { Command } from "commander";
+import type { OutputFormat, CLIContext, ExtendedBrowserName } from "../lib/types.ts";
+import { resolveCredentials } from "../lib/auth.ts";
+import { loadConfig } from "../lib/config.ts";
+import { mapBrowserName } from "../lib/cookies.ts";
+import { setEmojiEnabled } from "../formatters/common.ts";
+import { setQuoteDepth } from "../formatters/tweet.ts";
+import { error, warn } from "./output.ts";
+import kleur from "kleur";
+
+export async function createContext(cmd: Command): Promise<CLIContext> {
+  const opts = cmd.optsWithGlobals();
+  const config = await loadConfig();
+
+  // --- Format: CLI flags > env > config > default ---
+  const envFormat = process.env.XBIRD_FORMAT as OutputFormat | undefined;
+  const format: OutputFormat = opts.jsonFull
+    ? "json-full"
+    : opts.json
+      ? "json"
+      : opts.plain
+        ? "plain"
+        : envFormat ?? config.format ?? "human";
+
+  // --- No color: CLI --no-color > NO_COLOR env > config > default ---
+  const noColor = opts.color === false
+    || process.env.NO_COLOR !== undefined
+    || config.noColor === true;
+
+  // --- No emoji: CLI --no-emoji > env > config > default ---
+  // Commander.js: --no-emoji sets opts.emoji = false (not opts.noEmoji = true)
+  const noEmoji = opts.emoji === false
+    || process.env.XBIRD_NO_EMOJI !== undefined
+    || config.noEmoji === true;
+
+  // --- Quote depth: CLI > env > config > default ---
+  const envQuoteDepth = process.env.XBIRD_QUOTE_DEPTH;
+  const quoteDepth = opts.quoteDepth !== undefined
+    ? Number(opts.quoteDepth)
+    : envQuoteDepth !== undefined
+      ? Number(envQuoteDepth)
+      : config.quoteDepth ?? 1;
+
+  // --- Timeout: CLI > env > config > default ---
+  const envTimeout = process.env.XBIRD_TIMEOUT;
+  const timeoutMs = opts.timeout !== undefined
+    ? Number(opts.timeout)
+    : envTimeout !== undefined
+      ? Number(envTimeout)
+      : config.timeout ?? 30_000;
+
+  // --- Cookie source: CLI > env > config ---
+  const envCookieSource = process.env.XBIRD_COOKIE_SOURCE as ExtendedBrowserName | undefined;
+  const cookieSource: ExtendedBrowserName | undefined =
+    opts.cookieSource ?? envCookieSource ?? config.cookieSource;
+
+  // Apply settings
+  kleur.enabled = !noColor;
+  setEmojiEnabled(!noEmoji);
+  setQuoteDepth(quoteDepth);
+
+  // Resolve browser mapping for Arc/Brave
+  const mapping = mapBrowserName(cookieSource);
+  const { credentials, warnings } = await resolveCredentials({
+    authToken: opts.authToken ?? config.authToken,
+    ct0: opts.ct0 ?? config.ct0,
+    cookieSource: mapping?.browserName,
+    chromeProfile: mapping?.chromeProfile,
+  });
+
+  for (const w of warnings) {
+    if (format !== "json") warn(w);
+  }
+
+  if (!credentials) {
+    error("Could not resolve Twitter credentials. See warnings above.");
+  }
+
+  return { credentials: credentials!, format, noColor, noEmoji, quoteDepth, timeoutMs };
+}

package/src/cli/output.ts

@@ -0,0 +1,33 @@
+import type { OutputFormat } from "../lib/types.ts";
+
+export function output(data: unknown, format: OutputFormat, humanFormatter?: (data: unknown) => string): void {
+  if (format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (format === "plain") {
+    if (typeof data === "string") {
+      console.log(data);
+    } else {
+      console.log(JSON.stringify(data));
+    }
+    return;
+  }
+  // human format
+  if (humanFormatter) {
+    console.log(humanFormatter(data));
+  } else if (typeof data === "string") {
+    console.log(data);
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+export function error(message: string): void {
+  console.error(`Error: ${message}`);
+  process.exit(1);
+}
+
+export function warn(message: string): void {
+  console.error(`Warning: ${message}`);
+}

package/src/cli/program.ts

@@ -0,0 +1,63 @@
+import { Command } from "commander";
+
+// Commands will be imported and registered here
+import { registerWhoami } from "../commands/whoami.ts";
+import { registerCheck } from "../commands/check.ts";
+import { registerRead } from "../commands/read.ts";
+import { registerTweet } from "../commands/tweet.ts";
+import { registerSearch } from "../commands/search.ts";
+import { registerHome } from "../commands/home.ts";
+import { registerMentions } from "../commands/mentions.ts";
+import { registerUser } from "../commands/user.ts";
+import { registerEngagement } from "../commands/engagement.ts";
+import { registerBookmark } from "../commands/bookmark.ts";
+import { registerFollow } from "../commands/follow.ts";
+import { registerLists } from "../commands/lists.ts";
+import { registerNews } from "../commands/news.ts";
+import { registerUserTweets } from "../commands/user-tweets.ts";
+import { registerBookmarksList } from "../commands/bookmarks-list.ts";
+import { registerLikes } from "../commands/likes.ts";
+import { registerFollowers } from "../commands/followers.ts";
+import { registerReplies } from "../commands/replies.ts";
+import { registerAbout } from "../commands/about.ts";
+
+export function createProgram(): Command {
+  const program = new Command();
+
+  program
+    .name("xbird")
+    .description("Personal Twitter/X CLI")
+    .version("0.1.0")
+    .option("--auth-token <token>", "Twitter auth_token cookie")
+    .option("--ct0 <token>", "Twitter ct0 cookie")
+    .option("--cookie-source <browser>", "Browser for cookie extraction (safari/chrome/firefox/arc/brave)")
+    .option("--json", "Output as JSON")
+    .option("--json-full", "Full JSON output with raw data")
+    .option("--plain", "Output as plain text")
+    .option("--no-color", "Disable colored output")
+    .option("--no-emoji", "Replace emojis with text alternatives")
+    .option("--quote-depth <n>", "Depth for rendering quoted tweets (0-3, default: 1)")
+    .option("--timeout <ms>", "Request timeout in milliseconds (default: 30000)");
+
+  registerWhoami(program);
+  registerCheck(program);
+  registerRead(program);
+  registerTweet(program);
+  registerSearch(program);
+  registerHome(program);
+  registerMentions(program);
+  registerUser(program);
+  registerEngagement(program);
+  registerBookmark(program);
+  registerFollow(program);
+  registerLists(program);
+  registerNews(program);
+  registerUserTweets(program);
+  registerBookmarksList(program);
+  registerLikes(program);
+  registerFollowers(program);
+  registerReplies(program);
+  registerAbout(program);
+
+  return program;
+}

package/src/cli.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+import { createProgram } from "./cli/program.ts";
+
+const program = createProgram();
+program.parseAsync(process.argv).catch((err: Error) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/src/commands/about.ts

@@ -0,0 +1,30 @@
+import type { Command } from "commander";
+import { createContext } from "../cli/context.ts";
+import { XClient } from "../lib/client-full.ts";
+import { output, error } from "../cli/output.ts";
+import { normalizeHandle } from "../lib/utils.ts";
+
+export function registerAbout(program: Command): void {
+  program
+    .command("about <handle>")
+    .description("Show account origin/metadata")
+    .action(async function (this: Command, handle: string) {
+      const ctx = await createContext(this);
+      const client = new XClient(ctx.credentials, ctx.timeoutMs);
+      const screenName = normalizeHandle(handle);
+      const result = await client.getAbout(screenName);
+      if (!result.success) error(result.error ?? "Failed to load account info");
+
+      if (ctx.format === "json" || ctx.format === "json-full") {
+        output(result.about, "json");
+      } else {
+        const a = result.about;
+        if (a?.accountBasedIn) console.log(`Based in: ${a.accountBasedIn}`);
+        if (a?.createdAt) console.log(`Created: ${a.createdAt}`);
+        if (a?.source) console.log(`Source: ${a.source}`);
+        if (!a?.accountBasedIn && !a?.createdAt && !a?.source) {
+          console.log("No about info available.");
+        }
+      }
+    });
+}

package/src/commands/bookmark.ts

@@ -0,0 +1,40 @@
+import type { Command } from "commander";
+import { createContext } from "../cli/context.ts";
+import { XClient } from "../lib/client-full.ts";
+import { output, error } from "../cli/output.ts";
+import { extractTweetId } from "../lib/utils.ts";
+import { emoji, green } from "../formatters/common.ts";
+
+export function registerBookmark(program: Command): void {
+  program
+    .command("bookmark <id>")
+    .description("Bookmark a tweet")
+    .action(async function (this: Command, id: string) {
+      const ctx = await createContext(this);
+      const client = new XClient(ctx.credentials, ctx.timeoutMs);
+      const tweetId = extractTweetId(id);
+      const result = await client.bookmark(tweetId);
+      if (!result.success) error(result.error ?? "Failed to bookmark");
+      if (ctx.format === "json") {
+        output({ success: true, action: "bookmark", tweetId }, ctx.format);
+      } else {
+        console.log(`${green(emoji("✓"))} Bookmarked tweet ${tweetId}`);
+      }
+    });
+
+  program
+    .command("unbookmark <id>")
+    .description("Remove a bookmark")
+    .action(async function (this: Command, id: string) {
+      const ctx = await createContext(this);
+      const client = new XClient(ctx.credentials, ctx.timeoutMs);
+      const tweetId = extractTweetId(id);
+      const result = await client.unbookmark(tweetId);
+      if (!result.success) error(result.error ?? "Failed to unbookmark");
+      if (ctx.format === "json") {
+        output({ success: true, action: "unbookmark", tweetId }, ctx.format);
+      } else {
+        console.log(`${green(emoji("✓"))} Removed bookmark ${tweetId}`);
+      }
+    });
+}

package/src/commands/bookmarks-list.ts

@@ -0,0 +1,108 @@
+import type { Command } from "commander";
+import { createContext } from "../cli/context.ts";
+import { XClient } from "../lib/client-full.ts";
+import { output, error } from "../cli/output.ts";
+import { formatTweet } from "../formatters/tweet.ts";
+import { autoPaginate } from "../lib/paginate.ts";
+import type { Tweet } from "../lib/types.ts";
+
+export function registerBookmarksList(program: Command): void {
+  program
+    .command("bookmarks")
+    .description("Show your bookmarked tweets")
+    .option("-n, --count <number>", "Number of bookmarks", "20")
+    .option("--cursor <cursor>", "Pagination cursor")
+    .option("--folder-id <id>", "Bookmark folder ID")
+    .option("--all", "Fetch all pages")
+    .option("--max-pages <n>", "Max pages to fetch")
+    .option("--delay <ms>", "Delay between pages in ms")
+    .option("--expand-root-only", "No thread expansion, just show the tweet")
+    .option("--author-chain", "For each bookmark, show only tweets by same author in thread")
+    .option("--author-only", "Filter all results to only bookmarked author's tweets")
+    .option("--full-chain-only", "Show full thread chain for each bookmark")
+    .option("--sort-chronological", "Sort all output by createdAt ascending")
+    .action(async function (this: Command) {
+      const ctx = await createContext(this);
+      const client = new XClient(ctx.credentials, ctx.timeoutMs);
+      const opts = this.opts();
+      const count = parseInt(opts.count, 10);
+
+      let tweets: Tweet[];
+      let cursor: string | undefined;
+
+      if (opts.all || opts.maxPages) {
+        const result = await autoPaginate<Tweet>(
+          async (c?) => {
+            const r = await client.getBookmarks(count, c, opts.folderId);
+            return { items: r.tweets, cursor: r.cursor };
+          },
+          {
+            all: opts.all,
+            maxPages: opts.maxPages ? parseInt(opts.maxPages, 10) : undefined,
+            delay: opts.delay ? parseInt(opts.delay, 10) : undefined,
+          }
+        );
+        tweets = result.items;
+        cursor = result.cursor;
+      } else {
+        const result = await client.getBookmarks(count, opts.cursor, opts.folderId);
+        if (!result.success) error(result.error ?? "Failed to load bookmarks");
+        tweets = result.tweets;
+        cursor = result.cursor;
+      }
+
+      // Thread expansion flags (client-side filtering)
+      if (opts.fullChainOnly) {
+        const expanded: Tweet[] = [];
+        for (const tweet of tweets) {
+          const thread = await client.getThread(tweet.id);
+          if (thread.success) {
+            expanded.push(...thread.tweets);
+          } else {
+            expanded.push(tweet);
+          }
+        }
+        tweets = expanded;
+      } else if (opts.authorChain) {
+        const expanded: Tweet[] = [];
+        for (const tweet of tweets) {
+          const thread = await client.getThread(tweet.id);
+          if (thread.success) {
+            const authorTweets = thread.tweets.filter(t => t.authorId === tweet.authorId);
+            expanded.push(...authorTweets);
+          } else {
+            expanded.push(tweet);
+          }
+        }
+        tweets = expanded;
+      } else if (opts.authorOnly) {
+        // Collect unique author IDs from bookmarked tweets
+        const authorIds = new Set(tweets.map(t => t.authorId));
+        tweets = tweets.filter(t => authorIds.has(t.authorId));
+      }
+      // expand-root-only: no expansion needed, tweets are already root-only
+
+      // Deduplicate by tweet ID
+      const seen = new Set<string>();
+      tweets = tweets.filter(t => {
+        if (seen.has(t.id)) return false;
+        seen.add(t.id);
+        return true;
+      });
+
+      if (opts.sortChronological) {
+        tweets.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      }
+
+      if (ctx.format === "json" || ctx.format === "json-full") {
+        output({ tweets, cursor }, "json");
+      } else {
+        for (const tweet of tweets) {
+          console.log(formatTweet(tweet));
+          console.log("---");
+        }
+        if (tweets.length === 0) console.log("No bookmarks found.");
+        if (cursor && !opts.all) console.log(`\nNext cursor: ${cursor}`);
+      }
+    });
+}

package/src/commands/check.ts

@@ -0,0 +1,27 @@
+import type { Command } from "commander";
+import { createContext } from "../cli/context.ts";
+import { output } from "../cli/output.ts";
+import { bold, dim, emoji, green } from "../formatters/common.ts";
+
+export function registerCheck(program: Command): void {
+  program
+    .command("check")
+    .description("Check credential source")
+    .action(async function (this: Command) {
+      const ctx = await createContext(this);
+      const info = {
+        source: ctx.credentials.source,
+        browser: ctx.credentials.browser,
+        authTokenPrefix: ctx.credentials.authToken.slice(0, 8) + "...",
+        ct0Prefix: ctx.credentials.ct0.slice(0, 8) + "...",
+      };
+      if (ctx.format === "json") {
+        output(info, ctx.format);
+      } else {
+        console.log(`${green(emoji("✓"))} Credentials found`);
+        console.log(`  Source: ${bold(ctx.credentials.source)}${ctx.credentials.browser ? ` (${ctx.credentials.browser})` : ""}`);
+        console.log(`  auth_token: ${dim(info.authTokenPrefix)}`);
+        console.log(`  ct0: ${dim(info.ct0Prefix)}`);
+      }
+    });
+}

package/src/commands/engagement.ts

@@ -0,0 +1,31 @@
+import type { Command } from "commander";
+import { createContext } from "../cli/context.ts";
+import { XClient } from "../lib/client-full.ts";
+import { output, error } from "../cli/output.ts";
+import { extractTweetId } from "../lib/utils.ts";
+import { emoji, green } from "../formatters/common.ts";
+
+export function registerEngagement(program: Command): void {
+  for (const [cmd, method, label, desc] of [
+    ["like", "like", "Liked", "Like a tweet"],
+    ["unlike", "unlike", "Unliked", "Unlike a tweet"],
+    ["retweet", "retweet", "Retweeted", "Retweet a tweet"],
+    ["unretweet", "unretweet", "Unretweeted", "Unretweet a tweet"],
+  ] as const) {
+    program
+      .command(`${cmd} <id>`)
+      .description(desc)
+      .action(async function (this: Command, id: string) {
+        const ctx = await createContext(this);
+        const client = new XClient(ctx.credentials, ctx.timeoutMs);
+        const tweetId = extractTweetId(id);
+        const result = await (client as any)[method](tweetId);
+        if (!result.success) error(result.error ?? `Failed to ${cmd}`);
+        if (ctx.format === "json") {
+          output({ success: true, action: cmd, tweetId }, ctx.format);
+        } else {
+          console.log(`${green(emoji("✓"))} ${label} tweet ${tweetId}`);
+        }
+      });
+  }
+}