x-twitter-bot 1.0.0

package/README.md

@@ -0,0 +1,291 @@
+# x-bot
+
+Event-driven Twitter/X automation library for Node.js. Puppeteer + cookie-based auth.
+
+## Install
+
+```bash
+npm install x-twitter-bot
+```
+
+## Quick Start
+
+```js
+const TwitterBot = require("x-twitter-bot");
+
+const bot = new TwitterBot({
+  cookies: {
+    auth_token: "...",
+    ct0: "...",
+    twid: "...",
+    kdt: "...",
+    att: "...",
+  },
+  username: "your_username",
+  headless: true,
+});
+
+bot.on("browserLaunched", () => console.log("Browser launched"));
+
+bot.on("ready", async () => {
+  // 1. Post a tweet
+  try {
+    const tweet = await bot.postTweet("Hello world! 🤖");
+    console.log(tweet);
+  } catch (err) {
+    console.error(err.message); // e.g. "Whoops! You already said that."
+  }
+
+  // 2. Tweet stats + initial visible replies (no scroll)
+  const stats = await bot.getTweetStats("TWEET_ID");
+  console.log(stats.likes, stats.views, stats.initialReplies);
+
+  // 3. Comments with auto-scroll (up to 20)
+  const comments = await bot.getTweetComments("TWEET_ID", 20);
+  console.log(comments.collected, comments.scrollBlocked);
+
+  // 4. Sub-replies — pass a comment's tweetId (works recursively)
+  const sub = await bot.getTweetComments(comments.comments[0].tweetId, 5);
+
+  // 5. Search & like
+  await bot.searchAndLike("nodejs", 3);
+
+  await bot.close();
+});
+
+bot.on("loginRequired", () => { console.error("Cookies expired!"); bot.close(); });
+bot.on("tweetPosted", (d) => console.log("Posted:", d.text));
+bot.on("tweetFailed", (d) => console.error("Failed:", d.error));
+bot.on("error", (err) => { console.error(err.message); bot.close(); });
+bot.on("closed", () => console.log("Closed"));
+
+bot.init();
+```
+
+See [example.js](example.js) for a full runnable example.
+
+---
+
+## Constructor
+
+```js
+new TwitterBot(options)
+```
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `cookies` | `object` | **required** | Auth cookies (see below) |
+| `username` | `string` | `""` | Twitter username — used for building tweet URLs |
+| `headless` | `boolean` | `true` | Run browser in headless mode |
+| `timeout` | `number` | `60000` | Navigation timeout (ms) |
+
+### Required Cookies
+
+| Cookie | Description |
+|---|---|
+| `auth_token` | Session auth token |
+| `ct0` | CSRF token |
+| `twid` | Twitter user ID |
+| `kdt` | Key derivation token |
+| `att` | Access token |
+
+Optional: `guest_id`
+
+Get these from DevTools → Application → Cookies → `https://x.com`.
+
+---
+
+## Events
+
+| Event | Payload | Description |
+|---|---|---|
+| `browserLaunched` | – | Browser instance started |
+| `ready` | – | Authenticated and ready to use |
+| `loginRequired` | – | Cookies invalid/expired |
+| `tweetPosted` | `{ text, timestamp }` | Tweet posted successfully |
+| `tweetFailed` | `{ text, error }` | Tweet post failed |
+| `error` | `Error` | Unrecoverable error during init |
+| `closed` | – | Browser closed |
+
+### Flow
+
+```
+bot.init()
+    │
+    ├─ emit('browserLaunched')
+    │
+    ├─ cookies valid? ──YES──→ emit('ready')         ← call methods here
+    │                  └─NO──→ emit('loginRequired')
+    │
+    └─ exception ────────────→ emit('error', err)
+```
+
+---
+
+## Methods
+
+All methods require `ready` to have fired.
+
+---
+
+### `bot.init()`
+
+Launches browser, injects cookies, navigates to `/home`, verifies authentication.
+
+```js
+bot.init(); // triggers 'ready' or 'loginRequired'
+```
+
+---
+
+### `bot.postTweet(text)`
+
+Posts a tweet (max 280 chars). After clicking post, checks for X error toasts (e.g. duplicate tweet warning) before returning. Handles "Leave site?" dialogs automatically. Emits `tweetPosted` on success, `tweetFailed` on failure.
+
+```js
+const result = await bot.postTweet("Hello! 🚀");
+// { success: true, text: "Hello! 🚀", timestamp: "2026-02-21T12:00:00.000Z" }
+```
+
+Errors are thrown and also emitted via `tweetFailed`:
+- `"Whoops! You already said that."` — duplicate tweet
+- `"Tweet textarea not found"` — compose page failed to load
+- `"Post button not found"` — UI issue
+
+---
+
+### `bot.getTweetStats(tweetId)`
+
+Scrapes stats for a tweet **and** the initial visible replies already rendered on the page (no scrolling).
+
+```js
+const stats = await bot.getTweetStats("1893023456789");
+```
+
+**Response:**
+```js
+{
+  id: "1893023456789",
+  url: "https://x.com/username/status/1893023456789",
+  text: "Tweet content here",
+  likes: 42,
+  replies: 7,
+  reposts: 3,
+  views: 1500,
+  bookmarks: 2,
+  initialReplies: [
+    {
+      tweetId: "1893024000000",
+      username: "John Doe",
+      handle: "@johndoe",
+      text: "Great tweet!",
+      time: "2026-02-21T10:00:00.000Z",
+      likes: 5,
+      replies: 1,
+      reposts: 0
+    }
+  ]
+}
+```
+
+Each item in `initialReplies` includes a `tweetId` you can use with `getTweetComments()`.
+
+---
+
+### `bot.getTweetComments(tweetId, count?)`
+
+Scrapes comments with **automatic scrolling** until `count` is reached or scrolling is blocked.
+
+| Param | Type | Default | Description |
+|---|---|---|---|
+| `tweetId` | `string` | required | Tweet ID |
+| `count` | `number` | `20` | Max comments to collect |
+
+- Caps `count` to the actual reply count shown on the page
+- Stops and returns partial results if X blocks scrolling (rate limiting)
+
+```js
+const data = await bot.getTweetComments("1893023456789", 10);
+```
+
+**Response:**
+```js
+{
+  id: "1893023456789",
+  url: "https://x.com/username/status/1893023456789",
+  requested: 10,
+  actualReplyCount: 47,
+  collected: 10,
+  scrollBlocked: false,
+  comments: [
+    {
+      tweetId: "1893024000000",
+      username: "John Doe",
+      handle: "@johndoe",
+      text: "Nice!",
+      time: "2026-02-21T10:00:00.000Z",
+      likes: 3,
+      replies: 0,
+      reposts: 1
+    }
+  ]
+}
+```
+
+#### Sub-replies
+
+Every reply on X is itself a tweet. Pass any comment's `tweetId` back into `getTweetComments()` to fetch its replies:
+
+```js
+const comments = await bot.getTweetComments("1893023456789", 10);
+const subReplies = await bot.getTweetComments(comments.comments[0].tweetId, 5);
+```
+
+Works recursively — you can traverse entire conversation threads.
+
+---
+
+### `bot.searchAndLike(query, count?)`
+
+Searches for tweets matching a query and likes them. `count` defaults to `5`.
+
+```js
+const result = await bot.searchAndLike("nodejs", 5);
+// { query: "nodejs", liked: 5 }
+```
+
+---
+
+### `bot.close()`
+
+Closes the browser. Emits `closed`.
+
+```js
+await bot.close();
+```
+
+---
+
+## Project Structure
+
+```
+x-bot/
+├── index.js      ← TwitterBot class (library entry point)
+├── example.js    ← Full usage example
+├── package.json
+└── README.md
+```
+
+---
+
+## ⚠️ Disclaimer
+
+> **This project is NOT affiliated with, endorsed by, or associated with X (formerly Twitter) in any way.**
+
+- This is an **unofficial**, independently developed tool created strictly for **educational and research purposes**.
+- Using this library may result in your X/Twitter account being **temporarily or permanently suspended**. Automated interactions violate the [X Terms of Service](https://twitter.com/en/tos) and [X Automation Rules](https://help.twitter.com/en/rules-and-policies/x-automation).
+- The author(s) of this project **accept no responsibility** for any consequences arising from the use of this software, including but not limited to account bans, data loss, or legal action.
+- **You use this software entirely at your own risk.** By using it, you acknowledge that you are solely responsible for any outcomes.
+- This project is provided **"as is"** without warranty of any kind, express or implied.
+
+**If you don't fully understand the risks, do not use this library.**

package/index.js

@@ -0,0 +1,707 @@
+const puppeteer = require("puppeteer");
+const { EventEmitter } = require("events");
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const REQUIRED_COOKIES = ["auth_token", "ct0", "twid", "kdt", "att"];
+
+/**
+ * Events:
+ *   ready           – Bot authenticated and ready to use
+ *   loginRequired   – Cookies are invalid/expired, new cookies needed
+ *   browserLaunched – Browser instance started
+ *   error           – Unrecoverable error during init or operation
+ *   tweetPosted     – Tweet posted successfully   → { text, timestamp }
+ *   tweetFailed     – Tweet failed                → { text, error }
+ *   closed          – Browser closed
+ */
+class TwitterBot extends EventEmitter {
+  /**
+   * @param {object} options
+   * @param {object} options.cookies  – { auth_token, ct0, twid, kdt, att, guest_id? }
+   * @param {string} [options.username]  – Twitter username (for building tweet URLs)
+   * @param {boolean} [options.headless=true]
+   * @param {number}  [options.timeout=60000]
+   */
+  constructor(options = {}) {
+    super();
+
+    if (!options.cookies) throw new Error("cookies is required");
+
+    for (const name of REQUIRED_COOKIES) {
+      if (!options.cookies[name]) {
+        throw new Error(`Missing required cookie: ${name}`);
+      }
+    }
+
+    this.cookies = options.cookies;
+    this.username = options.username || "";
+    this.headless = options.headless !== undefined ? options.headless : true;
+    this.timeout = options.timeout || 60000;
+
+    this.browser = null;
+    this.page = null;
+    this.isReady = false;
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  INIT
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  async init() {
+    if (this.isReady) return this;
+
+    try {
+      // ── Launch browser ────────────────────────────────────────────────
+      this.browser = await puppeteer.launch({
+        headless: this.headless ? "new" : false,
+        args: [
+          "--no-sandbox",
+          "--disable-setuid-sandbox",
+          "--disable-blink-features=AutomationControlled",
+        ],
+        defaultViewport: { width: 1280, height: 720 },
+      });
+
+      this.page = await this.browser.newPage();
+
+      await this.page.setUserAgent(
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+      );
+
+      await this.page.evaluateOnNewDocument(() => {
+        Object.defineProperty(navigator, "webdriver", { get: () => undefined });
+      });
+
+      this.emit("browserLaunched");
+
+      // ── Set cookies & open x.com ──────────────────────────────────────
+      const cookieObjects = this._buildCookieObjects();
+      await this.page.setCookie(...cookieObjects);
+
+      await this.page.goto("https://x.com/home", {
+        waitUntil: "networkidle2",
+        timeout: this.timeout,
+      });
+
+      // ── Verify auth ──────────────────────────────────────────────────
+      await delay(1500);
+
+      const currentUrl = this.page.url();
+
+      if (currentUrl.includes("/login") || currentUrl.includes("/i/flow/login")) {
+        this.isReady = false;
+        this.emit("loginRequired");
+        return this;
+      }
+
+      // Double-check with DOM — look for logged-in sidebar
+      const hasProfile = await this._waitFor(
+        '[data-testid="AppTabBar_Profile_Link"], [data-testid="SideNav_AccountSwitcher_Button"]',
+        5000
+      );
+
+      if (!hasProfile) {
+        const recheckUrl = this.page.url();
+        if (recheckUrl.includes("/login") || recheckUrl.includes("/i/flow/login")) {
+          this.isReady = false;
+          this.emit("loginRequired");
+          return this;
+        }
+      }
+
+      this.isReady = true;
+      this.emit("ready");
+      return this;
+    } catch (err) {
+      this.emit("error", err);
+      return this;
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  ACTIONS
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  // ── Post a tweet ─────────────────────────────────────────────────────────
+
+  async postTweet(text) {
+    this._ensureReady();
+    if (!text) throw new Error("Tweet text is required");
+    if (text.length > 280) throw new Error("Tweet exceeds 280 characters");
+
+    try {
+      // Handle "Leave site?" / beforeunload dialogs automatically
+      this.page.once("dialog", async (dialog) => {
+        await dialog.accept();
+      });
+
+      await this.page.goto("https://x.com/compose/post", {
+        waitUntil: "networkidle2",
+        timeout: this.timeout,
+      });
+      await delay(1000);
+
+      const textarea = '[data-testid="tweetTextarea_0"]';
+      const found =
+        (await this._waitFor(textarea, 10000)) ||
+        (await this._waitFor('div[role="textbox"]', 5000));
+      if (!found) throw new Error("Tweet textarea not found");
+
+      await this.page.click(textarea);
+      await delay(200);
+      await this.page.type(textarea, text, { delay: 30 });
+      await delay(500);
+
+      const clicked = await this.page.evaluate(() => {
+        const btn =
+          document.querySelector('[data-testid="tweetButton"]') ||
+          document.querySelector('[data-testid="tweetButtonInline"]');
+        if (btn) {
+          btn.click();
+          return true;
+        }
+        return false;
+      });
+
+      if (!clicked) throw new Error("Post button not found");
+
+      // Wait for X to process
+      await delay(3000);
+
+      // Check for error toasts / warnings
+      const postStatus = await this.page.evaluate(() => {
+        // "Whoops! You already said that." or similar warning
+        const toast = document.querySelector('[role="status"]');
+        if (toast) {
+          const text = toast.innerText.trim();
+          if (text) return { error: text };
+        }
+        // Still on compose page → something went wrong
+        if (window.location.href.includes("/compose")) {
+          return { error: "Still on compose page" };
+        }
+        return { ok: true };
+      });
+
+      if (postStatus.error) {
+        // Dismiss the compose page safely
+        await this._dismissCompose();
+        throw new Error(postStatus.error);
+      }
+
+      // Tweet sent — recover page for next calls
+      await this._recoverPage();
+
+      const result = { success: true, text, timestamp: new Date().toISOString() };
+      this.emit("tweetPosted", result);
+      return result;
+    } catch (err) {
+      try { await this._recoverPage(); } catch { /* ignore */ }
+      this.emit("tweetFailed", { text, error: err.message });
+      throw err;
+    }
+  }
+
+  // ── Get tweet stats + initial visible replies ─────────────────────────────
+
+  async getTweetStats(tweetId) {
+    this._ensureReady();
+    if (!tweetId) throw new Error("Tweet ID is required");
+
+    const url = this._tweetUrl(tweetId);
+
+    await this.page.goto(url, {
+      waitUntil: "networkidle2",
+      timeout: this.timeout,
+    });
+    await delay(1500);
+
+    const data = await this.page.evaluate(() => {
+      const r = {
+        text: "",
+        likes: 0,
+        replies: 0,
+        reposts: 0,
+        views: 0,
+        bookmarks: 0,
+        initialReplies: [],
+      };
+
+      // ── Main tweet stats ──────────────────────────────────────────
+      const tweetText = document.querySelector('[data-testid="tweetText"]');
+      if (tweetText) r.text = tweetText.innerText;
+
+      const parse = (testId) => {
+        const el =
+          document.querySelector(`[data-testid="${testId}"]`) ||
+          document.querySelector(`[data-testid="un${testId}"]`);
+        if (el) {
+          const m = (el.getAttribute("aria-label") || "").match(/(\d+)/);
+          if (m) return parseInt(m[1]);
+        }
+        return 0;
+      };
+
+      r.replies = parse("reply");
+      r.reposts = parse("retweet");
+
+      r.likes = (() => {
+        const el =
+          document.querySelector('[data-testid="like"]') ||
+          document.querySelector('[data-testid="unlike"]');
+        if (el) {
+          const m = (el.getAttribute("aria-label") || "").match(/(\d+)/);
+          if (m) return parseInt(m[1]);
+        }
+        return 0;
+      })();
+
+      r.bookmarks = (() => {
+        const el =
+          document.querySelector('[data-testid="bookmark"]') ||
+          document.querySelector('[data-testid="removeBookmark"]');
+        if (el) {
+          const m = (el.getAttribute("aria-label") || "").match(/(\d+)/);
+          if (m) return parseInt(m[1]);
+        }
+        return 0;
+      })();
+
+      const allLinks = document.querySelectorAll("a[aria-label]");
+      for (const el of allLinks) {
+        const label = el.getAttribute("aria-label") || "";
+        if (/view/i.test(label) || /görüntülenme/i.test(label)) {
+          const m = label.match(/([\d,.]+)/);
+          if (m) {
+            r.views = parseInt(m[1].replace(/[,.]/g, ""));
+            break;
+          }
+        }
+      }
+
+      // ── Initial visible replies (no scroll) ──────────────────────
+      const cells = document.querySelectorAll('[data-testid="cellInnerDiv"]');
+      let foundMainTweet = false;
+
+      for (const cell of cells) {
+        const article = cell.querySelector('article[data-testid="tweet"]');
+        if (!article) continue;
+
+        if (!foundMainTweet) {
+          foundMainTweet = true;
+          continue;
+        }
+
+        const reply = { tweetId: null, username: "", handle: "", text: "", time: "", likes: 0, replies: 0, reposts: 0 };
+
+        // Extract tweet ID from permalink
+        const permalink = article.querySelector('a[href*="/status/"] time')?.closest("a");
+        if (permalink) {
+          const match = permalink.getAttribute("href").match(/\/status\/(\d+)/);
+          if (match) reply.tweetId = match[1];
+        }
+
+        const userNameEl = article.querySelector('[data-testid="User-Name"]');
+        if (userNameEl) {
+          const spans = userNameEl.querySelectorAll("a");
+          if (spans[0]) {
+            const nameSpan = spans[0].querySelector("span span");
+            if (nameSpan) reply.username = nameSpan.innerText;
+          }
+          if (spans[1]) {
+            const handleSpan = spans[1].querySelector("span");
+            if (handleSpan) reply.handle = handleSpan.innerText;
+          }
+        }
+
+        const timeEl = article.querySelector("time");
+        if (timeEl) reply.time = timeEl.getAttribute("datetime") || timeEl.innerText;
+
+        const textEl = article.querySelector('[data-testid="tweetText"]');
+        if (textEl) reply.text = textEl.innerText;
+
+        const parseBtn = (testId) => {
+          const el =
+            article.querySelector(`[data-testid="${testId}"]`) ||
+            article.querySelector(`[data-testid="un${testId}"]`);
+          if (el) {
+            const m = (el.getAttribute("aria-label") || "").match(/(\d+)/);
+            if (m) return parseInt(m[1]);
+          }
+          return 0;
+        };
+
+        reply.replies = parseBtn("reply");
+        reply.reposts = parseBtn("retweet");
+        reply.likes = (() => {
+          const el =
+            article.querySelector('[data-testid="like"]') ||
+            article.querySelector('[data-testid="unlike"]');
+          if (el) {
+            const m = (el.getAttribute("aria-label") || "").match(/(\d+)/);
+            if (m) return parseInt(m[1]);
+          }
+          return 0;
+        })();
+
+        r.initialReplies.push(reply);
+      }
+
+      return r;
+    });
+
+    return { id: tweetId, url, ...data };
+  }
+
+  // ── Get tweet comments (with scroll & count limit) ────────────────────────
+
+  async getTweetComments(tweetId, count = 20) {
+    this._ensureReady();
+    if (!tweetId) throw new Error("Tweet ID is required");
+
+    const url = this._tweetUrl(tweetId);
+
+    if (!this.page.url().includes(`/status/${tweetId}`)) {
+      await this.page.goto(url, {
+        waitUntil: "networkidle2",
+        timeout: this.timeout,
+      });
+    }
+    await delay(2000);
+
+    // Get actual reply count from the page to cap requested count
+    const actualReplyCount = await this.page.evaluate(() => {
+      const replyBtn = document.querySelector('[data-testid="reply"]');
+      if (replyBtn) {
+        const m = (replyBtn.getAttribute("aria-label") || "").match(/(\d+)/);
+        if (m) return parseInt(m[1]);
+      }
+      return 0;
+    });
+
+    const targetCount = Math.min(count, actualReplyCount || count);
+
+    const collectedMap = new Map(); // tweetId → comment (dedup)
+    let scrollBlocked = false;
+    let noNewDataRetries = 0;
+    const MAX_RETRIES = 5;
+
+    const scrapeVisibleComments = async () => {
+      return await this.page.evaluate(() => {
+        const results = [];
+        const cells = document.querySelectorAll('[data-testid="cellInnerDiv"]');
+        let foundMainTweet = false;
+
+        for (const cell of cells) {
+          const article = cell.querySelector('article[data-testid="tweet"]');
+          if (!article) continue;
+
+          if (!foundMainTweet) {
+            foundMainTweet = true;
+            continue;
+          }
+
+          const comment = {
+            tweetId: null,
+            username: "",
+            handle: "",
+            text: "",
+            time: "",
+            likes: 0,
+            replies: 0,
+            reposts: 0,
+          };
+
+          // Extract tweet ID from permalink
+          const permalink = article.querySelector('a[href*="/status/"] time')?.closest("a");
+          if (permalink) {
+            const match = permalink.getAttribute("href").match(/\/status\/(\d+)/);
+            if (match) comment.tweetId = match[1];
+          }
+
+          const userNameEl = article.querySelector('[data-testid="User-Name"]');
+          if (userNameEl) {
+            const spans = userNameEl.querySelectorAll("a");
+            if (spans[0]) {
+              const nameSpan = spans[0].querySelector("span span");
+              if (nameSpan) comment.username = nameSpan.innerText;
+            }
+            if (spans[1]) {
+              const handleSpan = spans[1].querySelector("span");
+              if (handleSpan) comment.handle = handleSpan.innerText;
+            }
+          }
+
+          const timeEl = article.querySelector("time");
+          if (timeEl) comment.time = timeEl.getAttribute("datetime") || timeEl.innerText;
+
+          const textEl = article.querySelector('[data-testid="tweetText"]');
+          if (textEl) comment.text = textEl.innerText;
+
+          const parseBtn = (testId) => {
+            const el =
+              article.querySelector(`[data-testid="${testId}"]`) ||
+              article.querySelector(`[data-testid="un${testId}"]`);
+            if (el) {
+              const m = (el.getAttribute("aria-label") || "").match(/(\d+)/);
+              if (m) return parseInt(m[1]);
+            }
+            return 0;
+          };
+
+          comment.replies = parseBtn("reply");
+          comment.reposts = parseBtn("retweet");
+          comment.likes = (() => {
+            const el =
+              article.querySelector('[data-testid="like"]') ||
+              article.querySelector('[data-testid="unlike"]');
+            if (el) {
+              const m = (el.getAttribute("aria-label") || "").match(/(\d+)/);
+              if (m) return parseInt(m[1]);
+            }
+            return 0;
+          })();
+
+          results.push(comment);
+        }
+
+        return results;
+      });
+    };
+
+    // ── Scroll loop ──────────────────────────────────────────────────
+    while (collectedMap.size < targetCount) {
+      const visible = await scrapeVisibleComments();
+
+      let newFound = 0;
+      for (const c of visible) {
+        const key = c.tweetId || `${c.handle}_${c.text}`;
+        if (!collectedMap.has(key)) {
+          collectedMap.set(key, c);
+          newFound++;
+        }
+        if (collectedMap.size >= targetCount) break;
+      }
+
+      if (collectedMap.size >= targetCount) break;
+
+      if (newFound === 0) {
+        noNewDataRetries++;
+        if (noNewDataRetries >= MAX_RETRIES) {
+          scrollBlocked = true;
+          break;
+        }
+      } else {
+        noNewDataRetries = 0;
+      }
+
+      // Scroll down
+      const prevHeight = await this.page.evaluate(() => document.body.scrollHeight);
+      await this.page.evaluate(() => window.scrollBy(0, 800));
+      await delay(1500);
+      const newHeight = await this.page.evaluate(() => document.body.scrollHeight);
+
+      // Detect if scroll is physically blocked (page height didn't change)
+      if (newHeight === prevHeight) {
+        noNewDataRetries++;
+        if (noNewDataRetries >= MAX_RETRIES) {
+          scrollBlocked = true;
+          break;
+        }
+        // Wait a bit longer before retrying
+        await delay(1000);
+      }
+    }
+
+    const comments = Array.from(collectedMap.values()).slice(0, targetCount);
+
+    return {
+      id: tweetId,
+      url,
+      requested: count,
+      actualReplyCount,
+      collected: comments.length,
+      scrollBlocked,
+      comments,
+    };
+  }
+
+  // ── Search & like tweets ─────────────────────────────────────────────────
+
+  async searchAndLike(query, count = 5) {
+    this._ensureReady();
+    if (!query) throw new Error("Search query is required");
+
+    await this.page.goto(
+      `https://x.com/search?q=${encodeURIComponent(query)}&src=typed_query&f=live`,
+      { waitUntil: "networkidle2", timeout: this.timeout }
+    );
+    await delay(1000);
+
+    const likeButtons = await this.page.$$('[data-testid="like"]');
+    const likesToDo = Math.min(count, likeButtons.length);
+    let liked = 0;
+
+    for (let i = 0; i < likesToDo; i++) {
+      try {
+        await likeButtons[i].click();
+        liked++;
+        await delay(1000 + Math.random() * 1000);
+      } catch {
+        /* skip */
+      }
+    }
+
+    return { query, liked };
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  LIFECYCLE
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  async close() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+      this.page = null;
+      this.isReady = false;
+      this.emit("closed");
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  INTERNALS
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  _ensureReady() {
+    if (!this.isReady) {
+      throw new Error("Bot not ready. Call .init() and wait for 'ready' event.");
+    }
+  }
+
+  _tweetUrl(tweetId) {
+    if (this.username) {
+      return `https://x.com/${this.username}/status/${tweetId}`;
+    }
+    return `https://x.com/i/status/${tweetId}`;
+  }
+
+  async _waitFor(selector, timeout = 10000) {
+    try {
+      await this.page.waitForSelector(selector, { timeout });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async _dismissCompose() {
+    // Try to close the compose modal/page without triggering beforeunload issues.
+    // Accept any "Leave site?" dialog that appears.
+    this.page.once("dialog", async (dialog) => {
+      await dialog.accept();
+    });
+
+    try {
+      // Try clicking the close button on the compose modal
+      const closed = await this.page.evaluate(() => {
+        const closeBtn = document.querySelector('[data-testid="app-bar-close"]');
+        if (closeBtn) { closeBtn.click(); return true; }
+        return false;
+      });
+      if (closed) {
+        await delay(500);
+        // There may be a "Discard" confirmation — click it
+        await this.page.evaluate(() => {
+          const btns = document.querySelectorAll('[role="button"]');
+          for (const btn of btns) {
+            const t = btn.innerText.toLowerCase();
+            if (t === "discard" || t === "at" || t === "vazgeç") {
+              btn.click();
+              return;
+            }
+          }
+        });
+        await delay(500);
+      }
+    } catch { /* page may be dead, that's ok */ }
+  }
+
+  async _recoverPage() {
+    // Accept any "Leave site?" beforeunload dialogs
+    this.page.once("dialog", async (dialog) => {
+      await dialog.accept();
+    });
+
+    try {
+      // Quick check — if we can read the URL, the page is alive
+      this.page.url();
+      await this.page.goto("https://x.com/home", {
+        waitUntil: "domcontentloaded",
+        timeout: this.timeout,
+      });
+    } catch {
+      // Page is dead — create a new tab
+      const pages = await this.browser.pages();
+      let recovered = false;
+      for (const p of pages) {
+        try {
+          p.url();
+          this.page = p;
+          this.page.once("dialog", async (d) => await d.accept());
+          await this.page.goto("https://x.com/home", {
+            waitUntil: "domcontentloaded",
+            timeout: this.timeout,
+          });
+          recovered = true;
+          break;
+        } catch { /* dead page, skip */ }
+      }
+
+      if (!recovered) {
+        this.page = await this.browser.newPage();
+        await this.page.setUserAgent(
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        );
+        await this.page.evaluateOnNewDocument(() => {
+          Object.defineProperty(navigator, "webdriver", { get: () => undefined });
+        });
+        const cookieObjects = this._buildCookieObjects();
+        await this.page.setCookie(...cookieObjects);
+        await this.page.goto("https://x.com/home", {
+          waitUntil: "domcontentloaded",
+          timeout: this.timeout,
+        });
+      }
+    }
+    await delay(1000);
+  }
+
+  _buildCookieObjects() {
+    return Object.entries(this.cookies).map(([name, value]) => {
+      const base = {
+        name,
+        value,
+        domain: ".x.com",
+        path: "/",
+        expires: Math.floor(Date.now() / 1000) + 365 * 24 * 60 * 60,
+        secure: true,
+        sameSite: "None",
+      };
+
+      if (name === "auth_token" || name === "kdt" || name === "att") {
+        base.httpOnly = true;
+      } else {
+        base.httpOnly = false;
+      }
+
+      if (name === "ct0") base.sameSite = "Lax";
+      if (name === "kdt") base.sameSite = "Strict";
+
+      return base;
+    });
+  }
+}
+
+module.exports = TwitterBot;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "x-twitter-bot",
+  "version": "1.0.0",
+  "description": "Twitter/X automation library powered by Puppeteer. Cookie-based auth, tweet, like, scrape stats & comments.",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "example": "node example.js"
+  },
+  "keywords": [
+    "twitter",
+    "x",
+    "bot",
+    "automation",
+    "puppeteer",
+    "scraper"
+  ],
+  "author": "alpersamur3",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alpersamur3/x-twitter-bot.git"
+  },
+  "homepage": "https://github.com/alpersamur3/x-twitter-bot#readme",
+  "dependencies": {
+    "puppeteer": "^21.11.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}