instauto 8.0.0 → 9.1.0

package/README.md

@@ -9,6 +9,7 @@ Now there is a GUI application for those who don't want to code: [SimpleInstaBot
 ## Setup
 
 - First install [Node.js](https://nodejs.org/en/) 8 or newer.
+  - On MacOS, it's recommended to use [homebrew](https://brew.sh/): `brew install node`
 
 - Create a new directory with a file like [example.js](https://github.com/mifi/instauto/blob/master/example.js)
 

package/example.js

@@ -4,6 +4,10 @@ const puppeteer = require('puppeteer'); // eslint-disable-line import/no-extrane
 
 const Instauto = require('instauto'); // eslint-disable-line import/no-unresolved
 
+// Optional: Custom logger with timestamps
+const log = (fn, ...args) => console[fn](new Date().toISOString(), ...args);
+const logger = Object.fromEntries(['log', 'info', 'debug', 'error', 'trace', 'warn'].map((fn) => [fn, (...args) => log(fn, ...args)]));
+
 const options = {
   cookiesPath: './cookies.json',
 
@@ -42,6 +46,8 @@ const options = {
 
   // If true, will not do any actions (defaults to true)
   dryRun: false,
+  
+  logger,
 };
 
 (async () => {

package/index.js

@@ -136,28 +136,30 @@ const Instauto = async (db, browser, options) => {
   }
 
   async function checkReachedFollowedUserDayLimit() {
-    const reachedFollowedUserDayLimit = getNumFollowedUsersThisTimeUnit(dayMs) >= maxFollowsPerDay;
-    if (reachedFollowedUserDayLimit) {
+    if (getNumFollowedUsersThisTimeUnit(dayMs) >= maxFollowsPerDay) {
       logger.log('Have reached daily follow/unfollow limit, waiting 10 min');
       await sleep(10 * 60 * 1000);
     }
   }
 
   async function checkReachedFollowedUserHourLimit() {
-    const hasReachedFollowedUserHourLimit = getNumFollowedUsersThisTimeUnit(hourMs) >= maxFollowsPerHour;
-    if (hasReachedFollowedUserHourLimit) {
+    if (getNumFollowedUsersThisTimeUnit(hourMs) >= maxFollowsPerHour) {
       logger.log('Have reached hourly follow rate limit, pausing 10 min');
       await sleep(10 * 60 * 1000);
     }
   }
 
+  async function checkReachedLikedUserDayLimit() {
+    if (getNumLikesThisTimeUnit(dayMs) >= maxLikesPerDay) {
+      logger.log('Have reached daily like rate limit, pausing 10 min');
+      await sleep(10 * 60 * 1000);
+    }
+  }
+
   async function throttle() {
     await checkReachedFollowedUserDayLimit();
     await checkReachedFollowedUserHourLimit();
-  }
-
-  function hasReachedDailyLikesLimit() {
-    return getNumLikesThisTimeUnit(dayMs) >= maxLikesPerDay;
+    await checkReachedLikedUserDayLimit();
   }
 
   function haveRecentlyFollowedUser(username) {
@@ -210,6 +212,10 @@ const Instauto = async (db, browser, options) => {
     return safeGotoUser(url, username);
   }
 
+  async function navigateToUserWithCheck(username) {
+    if (!(await navigateToUser(username))) throw new Error('User not found');
+  }
+
   async function getPageJson() {
     return JSON.parse(await (await (await page.$('pre')).getProperty('textContent')).jsonValue());
   }
@@ -226,11 +232,11 @@ const Instauto = async (db, browser, options) => {
 
       const { user } = json.graphql;
 
-      await navigateToUser(username);
+      await navigateToUserWithCheck(username);
       return user;
     }
 
-    await navigateToUser(username);
+    await navigateToUserWithCheck(username);
 
     // eslint-disable-next-line no-underscore-dangle
     const sharedData = await page.evaluate(() => window._sharedData);
@@ -311,8 +317,8 @@ const Instauto = async (db, browser, options) => {
     return elementHandles[0];
   }
 
-  // NOTE: assumes we are on this page
-  async function followCurrentUser(username) {
+  async function followUser(username) {
+    await navigateToUserWithCheck(username);
     const elementHandle = await findFollowButton();
 
     if (!elementHandle) {
@@ -353,7 +359,8 @@ const Instauto = async (db, browser, options) => {
 
   // See https://github.com/timgrossmann/InstaPy/pull/2345
   // https://github.com/timgrossmann/InstaPy/issues/2355
-  async function unfollowCurrentUser(username) {
+  async function unfollowUser(username) {
+    await navigateToUserWithCheck(username);
     logger.log(`Unfollowing user ${username}`);
 
     const res = { username, time: new Date().getTime() };
@@ -549,9 +556,11 @@ const Instauto = async (db, browser, options) => {
   /* eslint-enable no-undef */
 
 
-  async function likeCurrentUserImages({ username, likeImagesMin, likeImagesMax } = {}) {
+  async function likeUserImages({ username, likeImagesMin, likeImagesMax } = {}) {
     if (!likeImagesMin || !likeImagesMax || likeImagesMax < likeImagesMin || likeImagesMin < 1) throw new Error('Invalid arguments');
 
+    await navigateToUserWithCheck(username);
+
     logger.log(`Liking ${likeImagesMin}-${likeImagesMax} user images`);
     try {
       await page.exposeFunction('instautoSleep', sleep);
@@ -564,10 +573,57 @@ const Instauto = async (db, browser, options) => {
     await page.evaluate(likeCurrentUserImagesPageCode, { dryRun, likeImagesMin, likeImagesMax });
   }
 
-  async function followUserFollowers(username, {
+  async function followUserRespectingRestrictions({ username, skipPrivate = false }) {
+    if (getPrevFollowedUser(username)) {
+      logger.log('Skipping already followed user', username);
+      return false;
+    }
+    const graphqlUser = await navigateToUserAndGetData(username);
+
+    const followedByCount = graphqlUser.edge_followed_by.count;
+    const followsCount = graphqlUser.edge_follow.count;
+    const isPrivate = graphqlUser.is_private;
+
+    // logger.log('followedByCount:', followedByCount, 'followsCount:', followsCount);
+
+    const ratio = followedByCount / (followsCount || 1);
+
+    if (isPrivate && skipPrivate) {
+      logger.log('User is private, skipping');
+      return false;
+    }
+    if (
+      (followUserMaxFollowers != null && followedByCount > followUserMaxFollowers) ||
+      (followUserMaxFollowing != null && followsCount > followUserMaxFollowing) ||
+      (followUserMinFollowers != null && followedByCount < followUserMinFollowers) ||
+      (followUserMinFollowing != null && followsCount < followUserMinFollowing)
+    ) {
+      logger.log('User has too many or too few followers or following, skipping.', 'followedByCount:', followedByCount, 'followsCount:', followsCount);
+      return false;
+    }
+    if (
+      (followUserRatioMax != null && ratio > followUserRatioMax) ||
+      (followUserRatioMin != null && ratio < followUserRatioMin)
+    ) {
+      logger.log('User has too many followers compared to follows or opposite, skipping');
+      return false;
+    }
+
+    await followUser(username);
+
+    await sleep(30000);
+    await throttle();
+
+    return true;
+  }
+
+  async function processUserFollowers(username, {
     maxFollowsPerUser = 5, skipPrivate = false, enableLikeImages, likeImagesMin, likeImagesMax,
   } = {}) {
-    logger.log(`Following up to ${maxFollowsPerUser} followers of ${username}`);
+    const enableFollow = maxFollowsPerUser > 0;
+
+    if (enableFollow) logger.log(`Following up to ${maxFollowsPerUser} followers of ${username}`);
+    if (enableLikeImages) logger.log(`Liking images of up to ${likeImagesMax} followers of ${username}`);
 
     await throttle();
 
@@ -579,86 +635,52 @@ const Instauto = async (db, browser, options) => {
       logger.log('User followers batch', followersBatch);
 
       for (const follower of followersBatch) {
-        if (getPrevFollowedUser(follower)) {
-          logger.log('Skipping already followed user', follower);
-        } else {
-          try {
-            if (numFollowedForThisUser >= maxFollowsPerUser) {
-              logger.log('Have reached followed limit for this user, stopping');
-              return;
-            }
-
-            const graphqlUser = await navigateToUserAndGetData(follower);
-
-            const followedByCount = graphqlUser.edge_followed_by.count;
-            const followsCount = graphqlUser.edge_follow.count;
-            const isPrivate = graphqlUser.is_private;
-
-            // logger.log('followedByCount:', followedByCount, 'followsCount:', followsCount);
-
-            const ratio = followedByCount / (followsCount || 1);
-
-            if (isPrivate && skipPrivate) {
-              logger.log('User is private, skipping');
-            } else if (
-              (followUserMaxFollowers != null && followedByCount > followUserMaxFollowers) ||
-              (followUserMaxFollowing != null && followsCount > followUserMaxFollowing) ||
-              (followUserMinFollowers != null && followedByCount < followUserMinFollowers) ||
-              (followUserMinFollowing != null && followsCount < followUserMinFollowing)
-            ) {
-              logger.log('User has too many or too few followers or following, skipping.', 'followedByCount:', followedByCount, 'followsCount:', followsCount);
-            } else if (
-              (followUserRatioMax != null && ratio > followUserRatioMax) ||
-              (followUserRatioMin != null && ratio < followUserRatioMin)
-            ) {
-              logger.log('User has too many followers compared to follows or opposite, skipping');
-            } else {
-              await followCurrentUser(follower);
-              numFollowedForThisUser += 1;
-
-              await sleep(10000);
+        await throttle();
 
-              if (!isPrivate && enableLikeImages && !hasReachedDailyLikesLimit()) {
-                try {
-                  await likeCurrentUserImages({ username: follower, likeImagesMin, likeImagesMax });
-                } catch (err) {
-                  logger.error(`Failed to follow user's images ${follower}`, err);
-                  await takeScreenshot();
-                }
-              }
+        try {
+          if (enableFollow && numFollowedForThisUser >= maxFollowsPerUser) {
+            logger.log('Have reached followed limit for this user, stopping');
+            return;
+          }
 
-              await sleep(20000);
-              await throttle();
+          if (enableFollow) {
+            if (await followUserRespectingRestrictions({ username: follower, skipPrivate })) {
+              numFollowedForThisUser += 1;
             }
-          } catch (err) {
-            logger.error(`Failed to process follower ${follower}`, err);
-            await sleep(20000);
           }
+
+          if (enableLikeImages) {
+            // Note: throws error if user isPrivate
+            await likeUserImages({ username: follower, likeImagesMin, likeImagesMax });
+          }
+        } catch (err) {
+          logger.error(`Failed to process follower ${follower}`, err);
+          await takeScreenshot();
+          await sleep(20000);
         }
       }
     }
   }
 
-  async function followUsersFollowers({ usersToFollowFollowersOf, maxFollowsTotal = 150, skipPrivate, enableLikeImages = false, likeImagesMin = 1, likeImagesMax = 2 }) {
-    if (!maxFollowsTotal || maxFollowsTotal <= 2) {
-      throw new Error(`Invalid parameter maxFollowsTotal ${maxFollowsTotal}`);
-    }
-
-
+  async function processUsersFollowers({ usersToFollowFollowersOf, maxFollowsTotal = 150, skipPrivate, enableFollow = true, enableLikeImages = false, likeImagesMin = 1, likeImagesMax = 2 }) {
     // If maxFollowsTotal turns out to be lower than the user list size, slice off the user list
     const usersToFollowFollowersOfSliced = shuffleArray(usersToFollowFollowersOf).slice(0, maxFollowsTotal);
 
-    // Round up or we risk following none
-    const maxFollowsPerUser = Math.floor(maxFollowsTotal / usersToFollowFollowersOfSliced.length) + 1;
+    const maxFollowsPerUser = enableFollow && usersToFollowFollowersOfSliced.length > 0 ? Math.floor(maxFollowsTotal / usersToFollowFollowersOfSliced.length) : 0;
+
+    if (maxFollowsPerUser === 0 && (!enableLikeImages || likeImagesMin < 1 || likeImagesMax < 1)) {
+      logger.warn('Nothing to follow or like');
+      return;
+    }
 
     for (const username of usersToFollowFollowersOfSliced) {
       try {
-        await followUserFollowers(username, { maxFollowsPerUser, skipPrivate, enableLikeImages, likeImagesMin, likeImagesMax });
+        await processUserFollowers(username, { maxFollowsPerUser, skipPrivate, enableLikeImages, likeImagesMin, likeImagesMax });
 
         await sleep(10 * 60 * 1000);
         await throttle();
       } catch (err) {
-        console.error('Failed to follow user followers, continuing', err);
+        logger.error('Failed to process user followers, continuing', username, err);
         await takeScreenshot();
         await sleep(60 * 1000);
       }
@@ -684,7 +706,7 @@ const Instauto = async (db, browser, options) => {
               await addPrevUnfollowedUser({ username, time: new Date().getTime(), noActionTaken: true });
               await sleep(3000);
             } else {
-              const { noActionTaken } = await unfollowCurrentUser(username);
+              const { noActionTaken } = await unfollowUser(username);
 
               if (noActionTaken) {
                 await sleep(3000);
@@ -718,6 +740,22 @@ const Instauto = async (db, browser, options) => {
     return j;
   }
 
+  async function safelyFollowUserList({ users, skipPrivate, limit }) {
+    logger.log('Following users, up to limit', limit);
+
+    for (const username of users) {
+      await throttle();
+
+      try {
+        await followUserRespectingRestrictions({ username, skipPrivate });
+      } catch (err) {
+        logger.error(`Failed to follow user ${username}, continuing`, err);
+        await takeScreenshot();
+        await sleep(20000);
+      }
+    }
+  }
+
   function getPage() {
     return page;
   }
@@ -901,15 +939,12 @@ const Instauto = async (db, browser, options) => {
 
   // --- END OF INITIALIZATION
 
-
   async function doesUserFollowMe(username) {
     try {
       logger.info('Checking if user', username, 'follows us');
       const userData = await navigateToUserAndGetData(username);
       const userId = userData.id;
 
-      if (!(await navigateToUser(username))) throw new Error('User not found');
-
       const elementHandles = await page.$x("//a[contains(.,' following')][contains(@href,'/following')]");
       if (elementHandles.length === 0) throw new Error('Following button not found');
 
@@ -924,7 +959,8 @@ const Instauto = async (db, browser, options) => {
 
       const { users } = JSON.parse(await foundResponse.text());
       if (users.length < 2) throw new Error('Unable to find user follows list');
-      return users.some((user) => user.pk === myUserId); // If they follow us, we will show at the top of the list
+      // console.log(users, myUserId);
+      return users.some((user) => String(user.pk) === String(myUserId) || user.username === myUsername); // If they follow us, we will show at the top of the list
     } catch (err) {
       logger.error('Failed to check if user follows us', err);
       return undefined;
@@ -1006,19 +1042,22 @@ const Instauto = async (db, browser, options) => {
   }
 
   return {
-    followUserFollowers,
+    followUserFollowers: processUserFollowers,
     unfollowNonMutualFollowers,
     unfollowAllUnknown,
     unfollowOldFollowed,
-    followCurrentUser,
-    unfollowCurrentUser,
+    followUser,
+    unfollowUser,
+    likeUserImages,
     sleep,
     listManuallyFollowedUsers,
     getFollowersOrFollowing,
     getUsersWhoLikedContent,
     safelyUnfollowUserList,
+    safelyFollowUserList,
     getPage,
-    followUsersFollowers,
+    followUsersFollowers: processUsersFollowers,
+    doesUserFollowMe,
   };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instauto",
-  "version": "8.0.0",
+  "version": "9.1.0",
   "description": "Instagram automation library written in Node.js",
   "main": "index.js",
   "scripts": {