instauto 8.0.1 → 9.1.1

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/package.json

@@ -1,12 +1,15 @@
 {
   "name": "instauto",
-  "version": "8.0.1",
+  "version": "9.1.1",
   "description": "Instagram automation library written in Node.js",
-  "main": "index.js",
+  "main": "src/index.js",
   "scripts": {
     "lint": "eslint .",
     "test": "exit 0"
   },
+  "files": [
+    "src"
+  ],
   "author": "Mikael Finstad <finstaden@gmail.com>",
   "repository": "mifi/instauto",
   "license": "MIT",

package/{index.js → src/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);
@@ -303,6 +309,9 @@ const Instauto = async (db, browser, options) => {
     const elementHandles3 = await page.$x("//header//button[*//span[@aria-label='Following']]");
     if (elementHandles3.length > 0) return elementHandles3[0];
 
+    const elementHandles4 = await page.$x("//header//button[*//*[name()='svg'][@aria-label='Following']]");
+    if (elementHandles4.length > 0) return elementHandles4[0];
+
     return undefined;
   }
 
@@ -311,8 +320,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 +362,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 +559,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 +576,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 +638,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 +709,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 +743,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 +942,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');
 
@@ -1007,19 +1045,21 @@ 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/.eslintrc

@@ -1,36 +0,0 @@
-{
-  "env": {
-    "node": true
-  },
-  "extends": "airbnb/base",
-  "parserOptions": {
-    "sourceType": "script",
-    "ecmaVersion": 2022
-  },
-  "globals": {
-    "window": true,
-    "document": true
-  },
-  "rules": {
-    "max-len": 0,
-    "arrow-parens": 0,
-    "no-console": 0,
-    "no-await-in-loop": 0,
-    "object-curly-newline": 0,
-    'no-restricted-syntax': [
-      'error',
-      {
-        selector: 'ForInStatement',
-        message: 'for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array.',
-      },
-      {
-        selector: 'LabeledStatement',
-        message: 'Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand.',
-      },
-      {
-        selector: 'WithStatement',
-        message: '`with` is disallowed in strict mode because it makes code impossible to predict and optimize.',
-      },
-    ],
-  }
-}

package/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: mifi
-custom: https://mifi.no/thanks

package/example.js

@@ -1,101 +0,0 @@
-'use strict';
-
-const puppeteer = require('puppeteer'); // eslint-disable-line import/no-extraneous-dependencies
-
-const Instauto = require('instauto'); // eslint-disable-line import/no-unresolved
-
-const options = {
-  cookiesPath: './cookies.json',
-
-  username: 'your-ig-username',
-  password: 'your-ig-password',
-
-  // Global limit that prevents follow or unfollows (total) to exceed this number over a sliding window of one hour:
-  maxFollowsPerHour: 20,
-  // Global limit that prevents follow or unfollows (total) to exceed this number over a sliding window of one day:
-  maxFollowsPerDay: 150,
-  // (NOTE setting the above parameters too high will cause temp ban/throttle)
-
-  maxLikesPerDay: 50,
-
-  // Don't follow users that have a followers / following ratio less than this:
-  followUserRatioMin: 0.2,
-  // Don't follow users that have a followers / following ratio higher than this:
-  followUserRatioMax: 4.0,
-  // Don't follow users who have more followers than this:
-  followUserMaxFollowers: null,
-  // Don't follow users who have more people following them than this:
-  followUserMaxFollowing: null,
-  // Don't follow users who have less followers than this:
-  followUserMinFollowers: null,
-  // Don't follow users who have more people following them than this:
-  followUserMinFollowing: null,
-
-  // NOTE: The dontUnfollowUntilTimeElapsed option is ONLY for the unfollowNonMutualFollowers function
-  // This specifies the time during which the bot should not touch users that it has previously followed (in milliseconds)
-  // After this time has passed, it will be able to unfollow them again.
-  // TODO should remove this option from here
-  dontUnfollowUntilTimeElapsed: 3 * 24 * 60 * 60 * 1000,
-
-  // Usernames that we should not touch, e.g. your friends and actual followings
-  excludeUsers: [],
-
-  // If true, will not do any actions (defaults to true)
-  dryRun: false,
-};
-
-(async () => {
-  let browser;
-
-  try {
-    browser = await puppeteer.launch({ headless: false });
-
-    // Create a database where state will be loaded/saved to
-    const instautoDb = await Instauto.JSONDB({
-      // Will store a list of all users that have been followed before, to prevent future re-following.
-      followedDbPath: './followed.json',
-      // Will store all unfollowed users here
-      unfollowedDbPath: './unfollowed.json',
-      // Will store all likes here
-      likedPhotosDbPath: './liked-photos.json',
-    });
-
-    const instauto = await Instauto(instautoDb, browser, options);
-
-    // This can be used to unfollow people:
-    // Will unfollow auto-followed AND manually followed accounts who are not following us back, after some time has passed
-    // The time is specified by config option dontUnfollowUntilTimeElapsed
-    // await instauto.unfollowNonMutualFollowers();
-    // await instauto.sleep(10 * 60 * 1000);
-
-    // Unfollow previously auto-followed users (regardless of whether or not they are following us back)
-    // after a certain amount of days (2 weeks)
-    // Leave room to do following after this too (unfollow 2/3 of maxFollowsPerDay)
-    const unfollowedCount = await instauto.unfollowOldFollowed({ ageInDays: 14, limit: options.maxFollowsPerDay * (2 / 3) });
-
-    if (unfollowedCount > 0) await instauto.sleep(10 * 60 * 1000);
-
-    // List of usernames that we should follow the followers of, can be celebrities etc.
-    const usersToFollowFollowersOf = ['lostleblanc', 'sam_kolder'];
-
-    // Now go through each of these and follow a certain amount of their followers
-    await instauto.followUsersFollowers({
-      usersToFollowFollowersOf,
-      maxFollowsTotal: options.maxFollowsPerDay - unfollowedCount,
-      skipPrivate: true,
-      enableLikeImages: true,
-      likeImagesMax: 3,
-    });
-
-    await instauto.sleep(10 * 60 * 1000);
-
-    console.log('Done running');
-
-    await instauto.sleep(30000);
-  } catch (err) {
-    console.error(err);
-  } finally {
-    console.log('Closing browser');
-    if (browser) await browser.close();
-  }
-})();

package/instabot.yml

@@ -1,5 +0,0 @@
-apps:
-  - script: example.js
-    name: instabot
-    restart_delay: 60000
-    log_date_format: 'YYYY-MM-DD HH:mm Z'