coffeeinabit 0.0.1

package/tools/get_new_messages.js

@@ -0,0 +1,423 @@
+import axios from 'axios';
+
+export async function executeGetNewMessages(page, action, accessToken) {
+  let lastChecked = action.parameters?.last_checked;
+  if (!lastChecked) {
+    lastChecked = 0;
+  }
+
+  let lastCheckedTimestamp = parseInt(lastChecked, 10);
+  if (lastCheckedTimestamp < 1e12) {
+    lastCheckedTimestamp = lastCheckedTimestamp * 1000;
+  }
+
+  const allMessageEntities = [];
+  const processedMessages = new Set();
+  const conversationParticipantsMap = new Map();
+
+  const routeHandler = async (route) => {
+    const url = route.request().url();
+    
+    /////
+    if (url.includes('voyagerMessagingGraphQL')) {
+      const requestBody = route.request().postData();
+      if (requestBody) {
+        try {
+          const parsed = JSON.parse(requestBody);
+          console.log(`[GetNewMessages] GraphQL request: ${parsed.queryId || 'unknown'}`);
+        } catch (e) {
+        }
+      }
+    }
+    
+    if (url.includes('messengerConversations')) {
+      const response = await route.fetch();
+      
+      try {
+        const responseBody = await response.text();
+        const data = JSON.parse(responseBody);
+        
+        if (data?.data?.messengerConversationsBySyncToken?.elements) {
+          const conversations = data.data.messengerConversationsBySyncToken.elements;
+          conversations.forEach(conv => {
+            const convUrn = conv.backendUrn;
+            const participants = conv.conversationParticipants || [];
+            const otherPerson = participants.find(p => {
+              const member = p.participantType?.member;
+              return member && member.distance !== 'SELF';
+            });
+            
+            if (otherPerson && otherPerson.hostIdentityUrn) {
+              const encodedUrl = otherPerson.hostIdentityUrn.includes('urn:li:fsd_profile:')
+                ? otherPerson.hostIdentityUrn.split('urn:li:fsd_profile:')[1]
+                : '';
+              if (encodedUrl) {
+                conversationParticipantsMap.set(convUrn, encodedUrl);
+              }
+            }
+          });
+        }
+      } catch (error) {
+        console.error('[GetNewMessages] Error parsing conversations:', error);
+      }
+      
+      try {
+        await route.fulfill({ response });
+      } catch (fulfillError) {
+      }
+      return;
+    }
+    
+    if (url.includes('messengerMessages')) {
+      const response = await route.fetch();
+      
+      try {
+        const responseBody = await response.text();
+        const data = JSON.parse(responseBody);
+        
+        console.log(`[GetNewMessages] Intercepted messengerMessages response`);
+        
+        if (data?.data?.messengerMessagesBySyncToken?.elements) {
+          const elements = data.data.messengerMessagesBySyncToken.elements;
+          console.log(`[GetNewMessages] Found messengerMessagesBySyncToken with ${elements.length} messages`);
+          
+          let addedCount = 0;
+          let duplicateCount = 0;
+          
+          elements.forEach(msg => {
+            const senderInfo = msg.sender || msg.actor;
+            const senderMember = senderInfo?.participantType?.member;
+            const authorId = senderInfo?.backendUrn || 'unknown';
+            const authorName = senderMember 
+              ? `${senderMember.firstName?.text || ''} ${senderMember.lastName?.text || ''}`.trim()
+              : 'Unknown';
+            
+            const hostIdentityUrn = senderInfo?.hostIdentityUrn || '';
+            const authorUrl = hostIdentityUrn.includes('urn:li:fsd_profile:') 
+              ? hostIdentityUrn.split('urn:li:fsd_profile:')[1] 
+              : '';
+            
+            const conversationId = msg.backendConversationUrn || '';
+            const isSelf = senderMember?.distance === 'SELF';
+            
+            const messageText = msg.body?.text || '';
+            const deliveredAt = msg.deliveredAt;
+
+            const messageKey = `${conversationId}-${deliveredAt}-${messageText}`;
+            
+            if (messageText && deliveredAt && !processedMessages.has(messageKey)) {
+              processedMessages.add(messageKey);
+              allMessageEntities.push({
+                authorId: authorId,
+                authorName: authorName,
+                authorUrl: authorUrl,
+                conversationId: conversationId,
+                isSelf: isSelf,
+                messageText: messageText,
+                deliveredAt: deliveredAt
+              });
+              addedCount++;
+            } else if (processedMessages.has(messageKey)) {
+              duplicateCount++;
+            }
+          });
+          
+          console.log(`[GetNewMessages] Added ${addedCount} new messages, ${duplicateCount} duplicates, total now: ${allMessageEntities.length}`);
+        }
+      } catch (error) {
+        console.error('[GetNewMessages] Error parsing response:', error);
+      }
+      
+      try {
+        await route.fulfill({ response });
+      } catch (fulfillError) {
+      }
+      return;
+    }
+    
+    await route.continue();
+  };
+
+  try {
+    await page.route('**/voyagerMessagingGraphQL/**', routeHandler);
+
+    await page.goto('https://www.linkedin.com/messaging/', {
+      waitUntil: 'domcontentloaded',
+      timeout: 60000
+    });
+
+    await page.waitForLoadState('domcontentloaded');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    console.log('[GetNewMessages] Waiting for conversations list to load...');
+    
+    try {
+      await page.waitForSelector('.msg-conversations-container__conversations-list', {
+        timeout: 30000,
+        state: 'visible'
+      });
+    } catch (error) {
+      console.log('[GetNewMessages] Timeout waiting for conversations list');
+      try {
+        await page.unroute('**/voyagerMessagingGraphQL/**', routeHandler);
+      } catch (unrouteError) {
+        console.log('[GetNewMessages] Error unrouting (non-critical):', unrouteError.message);
+      }
+      return { newMessagesCount: 0, messages: [] };
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    console.log('[GetNewMessages] Looking for conversations list...');
+    const conversationsList = await page.locator('.msg-conversations-container__conversations-list').first();
+    const listCount = await conversationsList.count();
+    console.log('[GetNewMessages] Conversations list count:', listCount);
+    
+    if (listCount === 0) {
+      console.log('[GetNewMessages] No conversations list found, exiting');
+      try {
+        await page.unroute('**/voyagerMessagingGraphQL/**', routeHandler);
+      } catch (unrouteError) {
+        console.log('[GetNewMessages] Error unrouting (non-critical):', unrouteError.message);
+      }
+      return { newMessagesCount: 0, messages: [] };
+    }
+
+    console.log('[GetNewMessages] Waiting for conversation items to load...');
+    try {
+      await page.waitForSelector('li.msg-conversation-listitem .msg-conversation-listitem__link', {
+        timeout: 15000,
+        state: 'visible'
+      });
+    } catch (error) {
+      console.log('[GetNewMessages] No conversation items found');
+      try {
+        await page.unroute('**/voyagerMessagingGraphQL/**', routeHandler);
+      } catch (unrouteError) {
+        console.log('[GetNewMessages] Error unrouting (non-critical):', unrouteError.message);
+      }
+      return { newMessagesCount: 0, messages: [] };
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    const conversationItems = await conversationsList.locator('li.msg-conversation-listitem .msg-conversation-listitem__link').all();
+    console.log('[GetNewMessages] Found', conversationItems.length, 'conversation items');
+
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const initialMessageCount = allMessageEntities.length;
+    console.log(`[GetNewMessages] Messages from initially opened conversation: ${initialMessageCount}`);
+
+    let shouldContinue = true;
+    for (let i = 0; i < conversationItems.length && shouldContinue; i++) {
+      const item = conversationItems[i];
+      
+      try {
+        const messageCountBefore = allMessageEntities.length;
+        
+        await item.scrollIntoViewIfNeeded();
+        await new Promise(resolve => setTimeout(resolve, 300));
+        await item.click({ timeout: 10000, force: false });
+        await new Promise(resolve => setTimeout(resolve, 2500));
+        
+        const messageContainer = await page.locator('.msg-s-message-list.scrollable').first();
+        const containerExists = await messageContainer.count();
+        
+        if (containerExists > 0) {
+          let reachedOldMessages = false;
+          let scrollAttempts = 0;
+          const maxScrollAttempts = 20;
+          
+          await messageContainer.hover();
+          await new Promise(resolve => setTimeout(resolve, 500));
+          
+          let noNewMessagesRetries = 0;
+          
+          while (!reachedOldMessages && scrollAttempts < maxScrollAttempts) {
+            const beforeScrollCount = allMessageEntities.length;
+            console.log(`[GetNewMessages] Scroll cycle ${scrollAttempts + 1}, current messages: ${beforeScrollCount}`);
+            
+
+            for (let i = 0; i < 5; i++) {
+              await messageContainer.evaluate(el => {
+                el.scrollBy({ top: -2000, behavior: 'smooth' });
+              });
+              console.log(`[GetNewMessages] Scrolled up -2000px (${i + 1}/5)`);
+              await new Promise(resolve => setTimeout(resolve, 1000));
+            }
+            
+            console.log(`[GetNewMessages] Waiting for LinkedIn to load older messages...`);
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            
+            const afterScrollCount = allMessageEntities.length;
+            const newMessagesLoaded = afterScrollCount - beforeScrollCount;
+            console.log(`[GetNewMessages] After 5 scrolls: ${afterScrollCount} messages (${newMessagesLoaded} new)`);
+            
+            if (newMessagesLoaded === 0) {
+              noNewMessagesRetries++;
+              console.log(`[GetNewMessages] No new messages loaded, retry ${noNewMessagesRetries}/2`);
+              
+              if (noNewMessagesRetries >= 2) {
+                console.log('[GetNewMessages] No new messages after 2 retries, reached the top');
+                break;
+              }
+            } else {
+              noNewMessagesRetries = 0;
+              console.log(`[GetNewMessages] Loaded ${newMessagesLoaded} new messages, continuing...`);
+            }
+            
+            const oldestMessage = allMessageEntities
+              .filter(msg => msg.deliveredAt)
+              .sort((a, b) => a.deliveredAt - b.deliveredAt)[0];
+            
+            if (oldestMessage && oldestMessage.deliveredAt < lastCheckedTimestamp) {
+              reachedOldMessages = true;
+              console.log('[GetNewMessages] Reached messages older than lastChecked in this conversation');
+            }
+            
+            scrollAttempts++;
+          }
+          
+          console.log(`[GetNewMessages] Finished scrolling after ${scrollAttempts} attempts`);
+        }
+        
+        const messageCountAfter = allMessageEntities.length;
+        const newMessages = messageCountAfter - messageCountBefore;
+        console.log(`[GetNewMessages] Total messages from conversation ${i + 1}: ${newMessages}`);
+        
+        if (newMessages > 0) {
+          const conversationMessages = allMessageEntities.slice(messageCountBefore);
+          const latestInThisConversation = conversationMessages
+            .filter(msg => msg.deliveredAt)
+            .sort((a, b) => b.deliveredAt - a.deliveredAt)[0];
+          
+          if (latestInThisConversation && latestInThisConversation.deliveredAt < lastCheckedTimestamp) {
+            console.log('[GetNewMessages] Latest message in conversation is older than lastChecked, stopping conversation loop');
+            shouldContinue = false;
+          }
+        }
+      } catch (error) {
+        console.error('[GetNewMessages] Error with conversation:', error.message);
+      }
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    try {
+      await page.unroute('**/voyagerMessagingGraphQL/**', routeHandler);
+    } catch (error) {
+      console.log('[GetNewMessages] Error unrouting (non-critical):', error.message);
+    }
+
+    console.log('[GetNewMessages] Total messages collected:', allMessageEntities.length);
+    console.log('[GetNewMessages] Conversations with participants mapped:', conversationParticipantsMap.size);
+
+    const newMessages = allMessageEntities.filter(msg => msg.deliveredAt > lastCheckedTimestamp);
+    newMessages.sort((a, b) => a.deliveredAt - b.deliveredAt);
+    console.log('[GetNewMessages] New messages count:', newMessages.length);
+
+    const newMessagesByConversation = {};
+    newMessages.forEach(msg => {
+      if (!newMessagesByConversation[msg.conversationId]) {
+        newMessagesByConversation[msg.conversationId] = [];
+      }
+      newMessagesByConversation[msg.conversationId].push(msg);
+    });
+
+    console.log('[GetNewMessages] Conversations with new messages:', Object.keys(newMessagesByConversation).length);
+
+    const encodedUrlMap = new Map();
+    for (const conversationId in newMessagesByConversation) {
+      const encodedUrl = conversationParticipantsMap.get(conversationId);
+      if (encodedUrl) {
+        encodedUrlMap.set(encodedUrl, null);
+      } else {
+        console.log(`[GetNewMessages] No participant found for conversation:`, conversationId);
+      }
+    }
+    console.log('[GetNewMessages] Unique profiles to decode:', encodedUrlMap.size);
+
+    const decodedUrlMap = new Map();
+    for (const encodedUrl of encodedUrlMap.keys()) {
+      try {
+        await page.goto(`https://www.linkedin.com/in/${encodedUrl}`, {
+          waitUntil: 'domcontentloaded',
+          timeout: 30000
+        });
+        await page.waitForLoadState('domcontentloaded');
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
+        const currentUrl = page.url();
+        const match = currentUrl.match(/linkedin\.com\/in\/([^\/\?]+)/);
+        if (match && match[1]) {
+          decodedUrlMap.set(encodedUrl, match[1]);
+        }
+      } catch (error) {
+        console.error(`[GetNewMessages] Failed to decode URL:`, error.message);
+      }
+    }
+
+    let sentCount = 0;
+    let failedCount = 0;
+    let totalToSend = 0;
+
+    for (const conversationId in newMessagesByConversation) {
+      const messages = newMessagesByConversation[conversationId];
+      const encodedUrl = conversationParticipantsMap.get(conversationId);
+      const linkedinUrl = encodedUrl ? decodedUrlMap.get(encodedUrl) : null;
+
+      if (!linkedinUrl) {
+        console.log(`[GetNewMessages] Skipping conversation ${conversationId} - could not find or decode other person's URL`);
+        continue;
+      }
+
+      console.log(`[GetNewMessages] Sending ${messages.length} messages to ${linkedinUrl}`);
+      totalToSend += messages.length;
+
+      for (const msg of messages) {
+        try {
+          const payload = {
+            linkedin_url: linkedinUrl,
+            message: msg.messageText,
+            is_receipent: !msg.isSelf,
+            timestamp: msg.deliveredAt
+          };
+
+          console.log(`[GetNewMessages] Posting message: "${msg.messageText.substring(0, 50)}..." (${msg.deliveredAt})`);
+
+          await axios.post('https://api.coffeeinabit.com/messages', payload, {
+            headers: {
+              'Authorization': `Bearer ${accessToken}`,
+              'Content-Type': 'application/json'
+            }
+          });
+
+          sentCount++;
+        } catch (error) {
+          failedCount++;
+          console.error(`[GetNewMessages] Failed to send message to ${linkedinUrl}: "${msg.messageText.substring(0, 50)}..."`);
+          console.error(`[GetNewMessages] Error:`, error.message);
+          if (error.response) {
+            console.error(`[GetNewMessages] Response status:`, error.response.status);
+            console.error(`[GetNewMessages] Response data:`, error.response.data);
+          }
+        }
+      }
+    }
+
+    console.log(`[GetNewMessages] Successfully sent ${sentCount}/${totalToSend} messages${failedCount > 0 ? ` (${failedCount} failed)` : ''}`);
+
+    return {
+      newMessagesCount: newMessages.length,
+      messages: newMessages
+    };
+
+  } catch (error) {
+    console.error('[GetNewMessages] Error:', error.message);
+    try {
+      await page.unroute('**/voyagerMessagingGraphQL/**', routeHandler);
+    } catch (unrouteError) {
+      console.log('[GetNewMessages] Error unrouting (non-critical):', unrouteError.message);
+    }
+    throw error;
+  }
+}

package/tools/get_profile.js

@@ -0,0 +1,255 @@
+export async function executeGetProfile(page, action) {
+  if (!page) {
+    throw new Error('No page available');
+  }
+  
+  let username = action.parameters?.username;
+  if (!username) {
+    throw new Error('Missing username for get_profile');
+  }
+
+  try{
+    if (username === 'self') {
+      await page.goto('https://www.linkedin.com/feed/', {
+        waitUntil: 'domcontentloaded',
+        timeout: 60000
+      });
+      
+      await page.waitForLoadState('domcontentloaded');
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      const profileCard = await page.locator('.profile-card-member-details').first();
+      if (await profileCard.count() === 0) {
+        throw new Error('Could not find profile card on /feed');
+      }
+
+      const profileNameLink = await profileCard.locator('.profile-card-name').first();
+      if (await profileNameLink.count() === 0) {
+        throw new Error('Could not find profile name link on /feed');
+      }
+
+      await profileNameLink.click();
+      await page.waitForLoadState('domcontentloaded');
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      const currentUrl = page.url();
+      const match = currentUrl.match(/\/in\/([^/]+)/);
+      if (!match) {
+        throw new Error('Could not extract username from profile URL');
+      }
+      username = match[1];
+    }
+    
+    const profileUrl = `https://www.linkedin.com/in/${username}`;
+    await page.goto(profileUrl, {
+      waitUntil: 'domcontentloaded',
+      timeout: 60000
+    });
+
+    await page.waitForLoadState('domcontentloaded');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    for (let i = 0; i < 3; ++i) {
+      await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
+      await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+    }
+    await page.evaluate(() => window.scrollTo(0, 0));
+    await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 1000) + 500));
+
+    const profileText = await page.evaluate(() => {
+      const mainContent = document.querySelector('main');
+      if (!mainContent) return '';
+      function getAllText(element) {
+        let text = '';
+        for (const node of element.childNodes) {
+          if (node.nodeType === 3) {
+            text += node.textContent.trim() + ' ';
+          } else if (node.nodeType === 1) {
+            text += getAllText(node) + ' ';
+          }
+        }
+        return text.trim();
+      }
+      return getAllText(mainContent);
+    });
+
+    const { moreButtonOptions, isFirstDegreeConnection } = await getDropdownOptions(page);
+
+    const recentActivityUrl = `https://www.linkedin.com/in/${username}/recent-activity/all/`;
+    let recentPosts = {};
+    
+    try {
+      await page.goto(recentActivityUrl, {
+        waitUntil: 'domcontentloaded',
+        timeout: 60000
+      });
+
+      await page.waitForLoadState('domcontentloaded');
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      for (let i = 0; i < 5; ++i) {
+        await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
+        await new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * 2000) + 500));
+      }
+
+      recentPosts = await page.evaluate(() => {
+        const mainContent = document.querySelector('main');
+        if (!mainContent) return {};
+        const postContainers = mainContent.querySelectorAll('article, [data-urn*="activity"], .feed-shared-update-v2, .feed-shared-text');
+        const posts = {};
+        let postIndex = 1;
+        
+        if (postContainers.length === 0) {
+          const allElements = mainContent.querySelectorAll('*');
+          const textElements = [];
+          for (const element of allElements) {
+            const text = element.innerText || element.textContent || '';
+            if (text.length > 100 &&
+              text.includes('ago') &&
+              (text.includes('\u2022') || text.includes('Visible to')) &&
+              !text.includes('Like') &&
+              !text.includes('Comment') &&
+              !text.includes('Repost') &&
+              !text.includes('Send')) {
+              let cleanedText = text;
+              cleanedText = cleanedText.replace(/\d+\s*(Like|Comment|Repost|Send)/g, '');
+              cleanedText = cleanedText.replace(/\d+\s*comment/g, '');
+              cleanedText = cleanedText.replace(/Like\s*Comment\s*Repost\s*Send/g, '');
+              cleanedText = cleanedText.replace(/Activate to view larger image,/g, '');
+              cleanedText = cleanedText.replace(/\u2026more/g, '');
+              if (cleanedText.trim().length > 50) {
+                textElements.push(cleanedText.trim());
+              }
+            }
+          }
+          const uniquePosts = [...new Set(textElements)].slice(0, 5);
+          uniquePosts.forEach((post, index) => {
+            posts[index + 1] = { PostText: post, PostLink: null };
+          });
+        } else {
+          for (let i = 0; i < Math.min(5, postContainers.length); i++) {
+            const container = postContainers[i];
+            const text = container.innerText || container.textContent || '';
+            let postUrl = null;
+            let urn = container.getAttribute('data-urn');
+            if (!urn) {
+              const urnDiv = container.querySelector('[data-urn*="activity"]');
+              if (urnDiv) urn = urnDiv.getAttribute('data-urn');
+            }
+            if (urn && urn.startsWith('urn:li:activity:')) {
+              const activityId = urn.split(':').pop();
+              postUrl = `https://www.linkedin.com/feed/update/urn:li:activity:${activityId}`;
+            }
+            if (text.trim() && text.length > 50) {
+              posts[postIndex] = { PostText: text.trim(), PostLink: postUrl };
+              postIndex++;
+            }
+          }
+        }
+        return posts;
+      });
+
+    } catch (error) {
+    }
+
+    return {
+      profileText,
+      recentPosts,
+      moreButtonOptions,
+      isFirstDegreeConnection
+    };
+
+  } catch (error) {
+    console.error('[GetProfile] Error:', error.message);
+    throw error;
+  }
+}
+
+async function getDropdownOptions(page) {
+  let moreButtonOptions = [];
+  let isFirstDegreeConnection = null;
+  
+  try {
+    const moreButton = await getButtonByText(page, 'More', true);
+    
+    if (moreButton && await moreButton.isVisible()) {
+      try {
+        await moreButton.click();
+        } catch (error) {
+          try {
+            await moreButton.click();
+          } catch (error) {
+          }
+        }
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      const dropdownOptions = await page.evaluate(() => {
+        const options = [];
+        const dropdownItems = document.querySelectorAll('[role="menuitem"], [role="option"], .artdeco-dropdown__content-inner li, .artdeco-dropdown__content-inner button');
+        
+        dropdownItems.forEach((item, index) => {
+          const text = item.textContent?.trim() || item.innerText?.trim() || '';
+          const ariaLabel = item.getAttribute('aria-label') || '';
+          const title = item.getAttribute('title') || '';
+          
+          if (text || ariaLabel || title) {
+            options.push({
+              index: index + 1,
+              text: text,
+              ariaLabel: ariaLabel,
+              title: title,
+              fullText: `${text} ${ariaLabel} ${title}`.trim()
+            });
+          }
+        });
+        
+        return options;
+      });
+      
+      moreButtonOptions = dropdownOptions;
+      
+      const hasRemoveConnection = dropdownOptions.some(option => 
+        option.text.includes('Remove Connection') || 
+        option.ariaLabel.includes('Remove your connection')
+      );
+      
+      if (hasRemoveConnection) {
+        isFirstDegreeConnection = true;
+      }
+    }
+  } catch (error) {
+  }
+  
+  return { moreButtonOptions, isFirstDegreeConnection };
+}
+
+async function getButtonByText(page, text, inMain = false) {
+  let buttons = [];
+  
+  if (inMain) {
+    const mainContent = page.locator('main');
+    buttons = await mainContent.locator('button').all();
+    const spans = await page.locator('div[role="button"] span').all();
+    buttons = [...buttons, ...spans];
+  } else {
+    buttons = await page.locator('button').all();
+    const spans = await page.locator('div[role="button"] span').all();
+    buttons = [...buttons, ...spans];
+  }
+
+  for (let i = 0; i < buttons.length; i++) {
+    const button = buttons[i];
+    try {
+      if (!(await button.isVisible())) {
+        continue;
+      }
+      const buttonText = await button.textContent() || await button.innerText() || '';
+      if (buttonText.trim() === text) {
+        return button;
+      }
+    } catch (error) {
+    }
+  }
+  
+  return null;
+}