@jackwener/opencli 1.0.0 → 1.0.3

package/src/clis/discord-app/channels.ts

@@ -14,28 +14,40 @@ export const channelsCommand = cli({
     const channels = await page.evaluate(`
       (function() {
         const results = [];
-        // Discord channel list items
-        const items = document.querySelectorAll('[data-list-item-id*="channels___"], [class*="containerDefault_"]');
-        
-        items.forEach((item, i) => {
-          const nameEl = item.querySelector('[class*="name_"], [class*="channelName"]');
-          const name = nameEl ? nameEl.textContent.trim() : (item.textContent || '').trim().substring(0, 50);
-          
-          if (!name || name.length < 1) return;
-          
-          // Detect channel type from icon or aria-label
-          const iconEl = item.querySelector('[class*="icon"]');
-          let type = 'Text';
-          if (iconEl) {
-            const cls = iconEl.className || '';
-            if (cls.includes('voice') || cls.includes('speaker')) type = 'Voice';
-            else if (cls.includes('forum')) type = 'Forum';
-            else if (cls.includes('announcement')) type = 'Announcement';
-          }
-          
-          results.push({ Index: i + 1, Channel: name, Type: type });
+
+        // Discord channel links: <a> tags with href like /channels/GUILD/CHANNEL
+        const links = document.querySelectorAll('a[href*="/channels/"][data-list-item-id^="channels___"]');
+
+        links.forEach(function(el) {
+          var label = el.getAttribute('aria-label') || '';
+          if (!label) return;
+
+          // Skip categories
+          if (/[（(]category[）)]/i.test(label)) return;
+
+          // Strip any leading status prefix before the first comma (e.g. "unread, ", locale-agnostic)
+          var commaIdx = label.search(/[,，]/);
+          var cleaned = commaIdx !== -1 ? label.slice(commaIdx + 1).trimStart() : label;
+
+          // Extract name and type from "name (type)" or "name（type）"
+          var m = cleaned.match(/^(.+?)\s*[（(](.+?)[）)]\s*$/);
+          // If no type annotation found, skip — real channels always have "(Type channel)" in aria-label
+          if (!m) return;
+          var name = m[1].trim();
+          var rawType = m[2].toLowerCase();
+
+          // Discord channel names are ASCII-only; skip placeholder entries (e.g. locked channels)
+          if (!name || !/^[\x20-\x7E]+$/.test(name)) return;
+
+          var type = 'Text';
+          if (rawType.includes('voice')) type = 'Voice';
+          else if (rawType.includes('forum')) type = 'Forum';
+          else if (rawType.includes('announcement')) type = 'Announcement';
+          else if (rawType.includes('stage')) type = 'Stage';
+
+          results.push({ Index: results.length + 1, Channel: name, Type: type });
         });
-        
+
         return results;
       })()
     `);

package/src/clis/twitter/accept.ts

@@ -0,0 +1,213 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'accept',
+  description: 'Auto-accept DM requests containing specific keywords',
+  domain: 'x.com',
+  strategy: Strategy.UI,
+  browser: true,
+  timeoutSeconds: 600, // 10 min — batch operation iterating many conversations
+  args: [
+    { name: 'keyword', type: 'string', required: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
+    { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
+  ],
+  columns: ['index', 'status', 'user', 'message'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+
+    const keywords: string[] = kwargs.keyword.split(',').map((k: string) => k.trim()).filter(Boolean);
+    const maxAccepts: number = kwargs.max ?? 20;
+    const results: Array<{ index: number; status: string; user: string; message: string }> = [];
+    let acceptCount = 0;
+    // Track already-visited conversations to avoid infinite loops
+    const visited = new Set<string>();
+
+    for (let round = 0; round < maxAccepts + 50; round++) {
+      if (acceptCount >= maxAccepts) break;
+
+      // Step 1: Navigate to DM requests page
+      await page.goto('https://x.com/messages/requests');
+      await page.wait(4);
+
+      // Step 2: Get conversations with scroll-to-load
+      const convInfo = await page.evaluate(`(async () => {
+        try {
+          // Wait for initial items
+          let attempts = 0;
+          while (attempts < 10) {
+            const convs = document.querySelectorAll('[data-testid="conversation"]');
+            if (convs.length > 0) break;
+            await new Promise(r => setTimeout(r, 1000));
+            attempts++;
+          }
+
+          // Scroll to load more
+          const seenCount = new Set();
+          let noNewCount = 0;
+          for (let scroll = 0; scroll < 20; scroll++) {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const prevSize = seenCount.size;
+            convs.forEach((_, i) => seenCount.add(i));
+            if (convs.length >= ${maxAccepts + 10}) break;
+
+            // Scroll last item into view
+            if (convs.length > 0) {
+              convs[convs.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+            }
+            await new Promise(r => setTimeout(r, 1500));
+
+            if (seenCount.size <= prevSize) {
+              noNewCount++;
+              if (noNewCount >= 3) break;
+            } else {
+              noNewCount = 0;
+            }
+          }
+
+          const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+          if (convs.length === 0) return { ok: false, count: 0, items: [] };
+
+          const items = convs.map((conv, idx) => {
+            const text = conv.innerText || '';
+            const link = conv.querySelector('a[href]');
+            const href = link ? link.href : '';
+            const lines = text.split('\\n').filter(l => l.trim());
+            const user = lines[0] || 'Unknown';
+            return { idx, text, href, user };
+          });
+          return { ok: true, count: convs.length, items };
+        } catch(e) {
+          return { ok: false, error: String(e), count: 0, items: [] };
+        }
+      })()`);
+
+      if (!convInfo?.ok || convInfo.count === 0) {
+        if (results.length === 0) {
+          results.push({ index: 1, status: 'info', user: 'System', message: 'No message requests found' });
+        }
+        break;
+      }
+
+      let foundInThisRound = false;
+
+      // Step 3: Find first unvisited conversation with keyword match in preview
+      for (const item of convInfo.items) {
+        if (acceptCount >= maxAccepts) break;
+        const convKey = item.href || `conv-${item.idx}`;
+        if (visited.has(convKey)) continue;
+        visited.add(convKey);
+
+        // Check if preview text contains any keyword
+        const previewMatch = keywords.some((k: string) => item.text.includes(k));
+        if (!previewMatch) continue;
+
+        // Step 4: Click this conversation to open it
+        const clickResult = await page.evaluate(`(async () => {
+          try {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const conv = convs[${item.idx}];
+            if (!conv) return { ok: false, error: 'Conversation element not found' };
+            conv.click();
+            await new Promise(r => setTimeout(r, 2000));
+            return { ok: true };
+          } catch(e) {
+            return { ok: false, error: String(e) };
+          }
+        })()`);
+
+        if (!clickResult?.ok) continue;
+
+        // Wait for conversation to load
+        await page.wait(2);
+
+        // Step 5: Read full chat content and find Accept button
+        const res = await page.evaluate(`(async () => {
+          try {
+            const keywords = ${JSON.stringify(keywords)};
+
+            // Get username from conversation header
+            const heading = document.querySelector('[data-testid="conversation-header"]') ||
+                            document.querySelector('[data-testid="DM-conversation-header"]');
+            let username = 'Unknown';
+            if (heading) {
+              username = heading.innerText.trim().split('\\n')[0];
+            }
+
+            // Read full chat area text
+            const chatArea = document.querySelector('[data-testid="DmScrollerContainer"]') ||
+                             document.querySelector('[data-testid="DMConversationBody"]') ||
+                             document.querySelector('main [data-testid="cellInnerDiv"]')?.closest('section') ||
+                             document.querySelector('main');
+            const text = chatArea ? chatArea.innerText : '';
+
+            // Verify keyword match in full chat content
+            const matchedKw = keywords.filter(k => text.includes(k));
+            if (matchedKw.length === 0) {
+              return { status: 'skipped', user: username, message: 'No keyword match in full content' };
+            }
+
+            // Find the Accept button
+            const allBtns = Array.from(document.querySelectorAll('[role="button"]'));
+            const acceptBtn = allBtns.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return t === 'accept' || t === '接受';
+            });
+
+            if (!acceptBtn) {
+              return { status: 'no_button', user: username, message: 'Keyword matched but no Accept button (already accepted?)' };
+            }
+
+            // Click Accept
+            acceptBtn.click();
+            await new Promise(r => setTimeout(r, 2000));
+
+            // Check for confirmation dialog
+            const btnsAfter = Array.from(document.querySelectorAll('[role="button"]'));
+            const confirmBtn = btnsAfter.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return (t === 'accept' || t === '接受') && btn !== acceptBtn;
+            });
+            if (confirmBtn) {
+              confirmBtn.click();
+              await new Promise(r => setTimeout(r, 1000));
+            }
+
+            return { status: 'accepted', user: username, message: 'Accepted! Matched: ' + matchedKw.join(', ') };
+          } catch(e) {
+            return { status: 'error', user: 'system', message: String(e) };
+          }
+        })()`);
+
+        if (res?.status === 'accepted') {
+          acceptCount++;
+          foundInThisRound = true;
+          results.push({
+            index: acceptCount,
+            status: 'accepted',
+            user: res.user || 'Unknown',
+            message: res.message || 'Accepted',
+          });
+          // After accept, Twitter redirects to /messages — loop back to /messages/requests
+          await page.wait(2);
+          break; // break inner loop, outer loop will re-navigate to requests
+        } else if (res?.status === 'no_button') {
+          // Already accepted, skip
+          continue;
+        }
+      }
+
+      // If no match found in this round, we've exhausted all visible requests
+      if (!foundInThisRound) {
+        break;
+      }
+    }
+
+    if (results.length === 0) {
+      results.push({ index: 0, status: 'info', user: 'System', message: `No requests matched keywords "${keywords.join(', ')}"` });
+    }
+
+    return results;
+  }
+});

package/src/clis/twitter/followers.ts

@@ -15,65 +15,73 @@ cli({
   func: async (page, kwargs) => {
     let targetUser = kwargs.user;
 
-    // If no user is specified, we must figure out the logged-in user's handle
+    // If no user is specified, figure out the logged-in user's handle
     if (!targetUser) {
         await page.goto('https://x.com/home');
-        // wait for home page navigation
         await page.wait(5);
-        
+
         const href = await page.evaluate(`() => {
             const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
             return link ? link.getAttribute('href') : null;
         }`);
-        
+
         if (!href) {
             throw new Error('Could not find logged-in user profile link. Are you logged in?');
         }
         targetUser = href.replace('/', '');
     }
 
-    // 1. Navigate to user profile page
+    // 1. Navigate to profile page
     await page.goto(`https://x.com/${targetUser}`);
     await page.wait(3);
 
-    // 2. Inject interceptor for the followers GraphQL API
+    // 2. Install interceptor BEFORE SPA navigation.
+    //    goto() resets JS context, but SPA click preserves it.
     await page.installInterceptor('Followers');
-    
-    // 3. Click the followers link inside the profile page
-    await page.evaluate(`() => {
-        const target = '${targetUser}';
-        const link = document.querySelector('a[href="/' + target + '/followers"]');
-        if (link) link.click();
+
+    // 3. Click the followers link via SPA navigation (preserves interceptor).
+    //    Twitter uses /verified_followers instead of /followers now.
+    const safeUser = JSON.stringify(targetUser);
+    const clicked = await page.evaluate(`() => {
+        const target = ${safeUser};
+        const selectors = [
+            'a[href="/' + target + '/verified_followers"]',
+            'a[href="/' + target + '/followers"]',
+        ];
+        for (const sel of selectors) {
+            const link = document.querySelector(sel);
+            if (link) { link.click(); return true; }
+        }
+        return false;
     }`);
-    await page.wait(3);
+    if (!clicked) {
+        throw new Error('Could not find followers link on profile page. Twitter may have changed the layout.');
+    }
+    await page.wait(5);
 
-    // 4. Trigger API by scrolling
+    // 4. Scroll to trigger pagination API calls
     await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
 
-    // 4. Retrieve data from opencli's registered interceptors
-    const allRequests = await page.getInterceptedRequests();
-    const requestList = Array.isArray(allRequests) ? allRequests : [];
-    
+    // 5. Retrieve intercepted data
+    const requests = await page.getInterceptedRequests();
+    const requestList = Array.isArray(requests) ? requests : [];
+
     if (requestList.length === 0) {
        return [];
     }
-    
-    const requests = requestList.filter((r: any) => r?.url?.includes('Followers'));
-    if (!requests || requests.length === 0) {
-       return [];
-    }
 
     let results: any[] = [];
-    for (const req of requests) {
+    for (const req of requestList) {
       try {
-        let instructions = req.data?.data?.user?.result?.timeline?.timeline?.instructions;
+        // GraphQL response: { data: { user: { result: { timeline: ... } } } }
+        let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
         if (!instructions) continue;
 
         let addEntries = instructions.find((i: any) => i.type === 'TimelineAddEntries');
         if (!addEntries) {
              addEntries = instructions.find((i: any) => i.entries && Array.isArray(i.entries));
         }
-        
+
         if (!addEntries) continue;
 
         for (const entry of addEntries.entries) {
@@ -82,10 +90,9 @@ cli({
           const item = entry.content?.itemContent?.user_results?.result;
           if (!item || item.__typename !== 'User') continue;
 
-          // Twitter GraphQL sometimes nests `core` differently depending on the endpoint profile state
           const core = item.core || {};
           const legacy = item.legacy || {};
-          
+
           results.push({
             screen_name: core.screen_name || legacy.screen_name || 'unknown',
             name: core.name || legacy.name || 'unknown',
@@ -98,7 +105,7 @@ cli({
       }
     }
 
-    // Deduplicate by screen_name in case multiple scrolls caught the same
+    // Deduplicate by screen_name
     const unique = new Map();
     results.forEach(r => unique.set(r.screen_name, r));
     const deduplicatedResults = Array.from(unique.values());

package/src/clis/twitter/following.ts

@@ -15,45 +15,50 @@ cli({
   func: async (page, kwargs) => {
     let targetUser = kwargs.user;
 
-    // If no user is specified, we must figure out the logged-in user's handle
+    // If no user is specified, figure out the logged-in user's handle
     if (!targetUser) {
         await page.goto('https://x.com/home');
-        // wait for home page navigation
         await page.wait(5);
-        
+
         const href = await page.evaluate(`() => {
             const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
             return link ? link.getAttribute('href') : null;
         }`);
-        
+
         if (!href) {
             throw new Error('Could not find logged-in user profile link. Are you logged in?');
         }
         targetUser = href.replace('/', '');
     }
 
-    // 1. Navigate to user profile page
+    // 1. Navigate to profile page
     await page.goto(`https://x.com/${targetUser}`);
     await page.wait(3);
 
-    // 2. Inject interceptor for Following GraphQL API
+    // 2. Install interceptor BEFORE SPA navigation.
+    //    goto() resets JS context, but SPA click preserves it.
     await page.installInterceptor('Following');
-    
-    // 3. Click the following link inside the profile page
-    await page.evaluate(`() => {
-        const target = '${targetUser}';
+
+    // 3. Click the following link via SPA navigation (preserves interceptor)
+    const safeUser = JSON.stringify(targetUser);
+    const clicked = await page.evaluate(`() => {
+        const target = ${safeUser};
         const link = document.querySelector('a[href="/' + target + '/following"]');
-        if (link) link.click();
+        if (link) { link.click(); return true; }
+        return false;
     }`);
-    await page.wait(3);
+    if (!clicked) {
+        throw new Error('Could not find following link on profile page. Twitter may have changed the layout.');
+    }
+    await page.wait(5);
 
-    // 4. Trigger API by scrolling
+    // 4. Scroll to trigger pagination API calls
     await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
 
-    // 4. Retrieve data from opencli's registered interceptors
+    // 5. Retrieve intercepted data
     const requests = await page.getInterceptedRequests();
     const requestList = Array.isArray(requests) ? requests : [];
-    
+
     if (requestList.length === 0) {
        return [];
     }
@@ -61,14 +66,15 @@ cli({
     let results: any[] = [];
     for (const req of requestList) {
       try {
-        let instructions = req.data?.data?.user?.result?.timeline?.timeline?.instructions;
+        // GraphQL response: { data: { user: { result: { timeline: ... } } } }
+        let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
         if (!instructions) continue;
 
         let addEntries = instructions.find((i: any) => i.type === 'TimelineAddEntries');
         if (!addEntries) {
              addEntries = instructions.find((i: any) => i.entries && Array.isArray(i.entries));
         }
-        
+
         if (!addEntries) continue;
 
         for (const entry of addEntries.entries) {
@@ -77,10 +83,9 @@ cli({
           const item = entry.content?.itemContent?.user_results?.result;
           if (!item || item.__typename !== 'User') continue;
 
-          // Twitter GraphQL sometimes nests `core` differently depending on the endpoint profile state
           const core = item.core || {};
           const legacy = item.legacy || {};
-          
+
           results.push({
             screen_name: core.screen_name || legacy.screen_name || 'unknown',
             name: core.name || legacy.name || 'unknown',
@@ -93,7 +98,7 @@ cli({
       }
     }
 
-    // Deduplicate by screen_name in case multiple scrolls caught the same
+    // Deduplicate by screen_name
     const unique = new Map();
     results.forEach(r => unique.set(r.screen_name, r));
     const deduplicatedResults = Array.from(unique.values());

package/src/clis/twitter/notifications.ts

@@ -12,20 +12,30 @@ cli({
   ],
   columns: ['id', 'action', 'author', 'text', 'url'],
   func: async (page, kwargs) => {
-    // Install the interceptor before loading the notifications page so we
-    // capture the initial timeline request triggered during page load.
-    await page.goto('https://x.com');
-    await page.wait(2);
+    // 1. Navigate to home first (we need a loaded Twitter page for SPA navigation)
+    await page.goto('https://x.com/home');
+    await page.wait(3);
+
+    // 2. Install interceptor BEFORE SPA navigation
     await page.installInterceptor('NotificationsTimeline');
 
-    // 1. Navigate to notifications
-    await page.goto('https://x.com/notifications');
+    // 3. SPA navigate to notifications via history API
+    await page.evaluate(`() => {
+        window.history.pushState({}, '', '/notifications');
+        window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
+    }`);
     await page.wait(5);
 
-    // 3. Trigger API by scrolling (if we need to load more)
+    // Verify SPA navigation succeeded
+    const currentUrl = await page.evaluate('() => window.location.pathname');
+    if (currentUrl !== '/notifications') {
+        throw new Error('SPA navigation to notifications failed. Twitter may have changed its routing.');
+    }
+
+    // 4. Scroll to trigger pagination
     await page.autoScroll({ times: 2, delayMs: 2000 });
 
-    // 4. Retrieve data
+    // 5. Retrieve data
     const requests = await page.getInterceptedRequests();
     if (!requests || requests.length === 0) return [];
 
@@ -33,22 +43,20 @@ cli({
     const seen = new Set<string>();
     for (const req of requests) {
       try {
+        // GraphQL response: { data: { viewer: ... } } (one level of .data)
         let instructions: any[] = [];
-        if (req.data?.data?.viewer?.timeline_response?.timeline?.instructions) {
-             instructions = req.data.data.viewer.timeline_response.timeline.instructions;
-        } else if (req.data?.data?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {
-             instructions = req.data.data.viewer_v2.user_results.result.notification_timeline.timeline.instructions;
-        } else if (req.data?.data?.timeline?.instructions) {
-             instructions = req.data.data.timeline.instructions;
+        if (req.data?.viewer?.timeline_response?.timeline?.instructions) {
+             instructions = req.data.viewer.timeline_response.timeline.instructions;
+        } else if (req.data?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {
+             instructions = req.data.viewer_v2.user_results.result.notification_timeline.timeline.instructions;
+        } else if (req.data?.timeline?.instructions) {
+             instructions = req.data.timeline.instructions;
         }
 
         let addEntries = instructions.find((i: any) => i.type === 'TimelineAddEntries');
-        
-        // Sometimes it's the first object without a 'type' field but has 'entries'
         if (!addEntries) {
              addEntries = instructions.find((i: any) => i.entries && Array.isArray(i.entries));
         }
-        
         if (!addEntries) continue;
 
         for (const entry of addEntries.entries) {
@@ -66,24 +74,22 @@ cli({
 
         function processNotificationItem(itemContent: any, entryId: string) {
             if (!itemContent) return;
-            
-            // Twitter wraps standard notifications 
+
             let item = itemContent?.notification_results?.result || itemContent?.tweet_results?.result || itemContent;
 
             let actionText = 'Notification';
             let author = 'unknown';
             let text = '';
             let urlStr = '';
-            
+
             if (item.__typename === 'TimelineNotification') {
-                 // Greet likes, retweet, mentions
                  text = item.rich_message?.text || item.message?.text || '';
                  const fromUser = item.template?.from_users?.[0]?.user_results?.result;
-                 author = fromUser?.legacy?.screen_name || fromUser?.core?.screen_name || 'unknown';
+                 // Twitter moved screen_name from legacy to core
+                 author = fromUser?.core?.screen_name || fromUser?.legacy?.screen_name || 'unknown';
                  urlStr = item.notification_url?.url || '';
                  actionText = item.notification_icon || 'Activity';
-                 
-                 // If there's an attached tweet
+
                  const targetTweet = item.template?.target_objects?.[0]?.tweet_results?.result;
                  if (targetTweet) {
                     const targetText = targetTweet.note_tweet?.note_tweet_results?.result?.text || targetTweet.legacy?.full_text || '';
@@ -93,14 +99,15 @@ cli({
                     }
                  }
             } else if (item.__typename === 'TweetNotification') {
-                 // Direct mention/reply
                  const tweet = item.tweet_result?.result;
-                 author = tweet?.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                 const tweetUser = tweet?.core?.user_results?.result;
+                 author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
                  text = tweet?.note_tweet?.note_tweet_results?.result?.text || tweet?.legacy?.full_text || item.message?.text || '';
                  actionText = 'Mention/Reply';
                  urlStr = `https://x.com/i/status/${tweet?.rest_id}`;
             } else if (item.__typename === 'Tweet') {
-                 author = item.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                 const tweetUser = item.core?.user_results?.result;
+                 author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
                  text = item.note_tweet?.note_tweet_results?.result?.text || item.legacy?.full_text || '';
                  actionText = 'Mention';
                  urlStr = `https://x.com/i/status/${item.rest_id}`;

package/src/clis/twitter/post.ts

@@ -26,8 +26,15 @@ cli({
             const box = document.querySelector('[data-testid="tweetTextarea_0"]');
             if (box) {
                 box.focus();
-                // insertText is the most reliable way to trigger React's onChange events
-                document.execCommand('insertText', false, ${JSON.stringify(kwargs.text)});
+                // Simulate a paste event to properly handle newlines in Draft.js/React
+                const textToInsert = ${JSON.stringify(kwargs.text)};
+                const dataTransfer = new DataTransfer();
+                dataTransfer.setData('text/plain', textToInsert);
+                box.dispatchEvent(new ClipboardEvent('paste', {
+                    clipboardData: dataTransfer,
+                    bubbles: true,
+                    cancelable: true
+                }));
             } else {
                 return { ok: false, message: 'Could not find the tweet composer text area.' };
             }