nodejs-insta-private-api-mqt 1.3.70

package/dist/core/client.js

@@ -0,0 +1,419 @@
+const EventEmitter = require('events');
+const fs = require('fs');
+const path = require('path');
+
+const State = require('./state');
+const Request = require('./request');
+const AccountRepository = require('../repositories/account.repository');
+const UserRepository = require('../repositories/user.repository');
+const DirectRepository = require('../repositories/direct.repository');
+const DirectThreadRepository = require('../repositories/direct-thread.repository');
+const MediaRepository = require('../repositories/media.repository');
+const UploadRepository = require('../repositories/upload.repository');
+const StoryRepository = require('../repositories/story.repository');
+const FeedRepository = require('../repositories/feed.repository');
+const FriendshipRepository = require('../repositories/friendship.repository');
+const LocationRepository = require('../repositories/location.repository');
+const HashtagRepository = require('../repositories/hashtag.repository');
+const NewsRepository = require('../repositories/news.repository');
+const CollectionRepository = require('../repositories/collection.repository');
+const CloseFriendsRepository = require('../repositories/close-friends.repository');
+const ClipRepository = require('../repositories/clip.repository');
+const TimelineRepository = require('../repositories/timeline.repository');
+const InsightsRepository = require('../repositories/insights.repository');
+const NoteRepository = require('../repositories/note.repository');
+const NotificationRepository = require('../repositories/notification.repository');
+const SignupRepository = require('../repositories/signup.repository');
+const TOTPRepository = require('../repositories/totp.repository');
+const BloksRepository = require('../repositories/bloks.repository');
+const ChallengeRepository = require('../repositories/challenge.repository');
+const ShareRepository = require('../repositories/share.repository');
+const TrackRepository = require('../repositories/track.repository');
+const ExploreRepository = require('../repositories/explore.repository');
+const FBSearchRepository = require('../repositories/fbsearch.repository');
+const FundraiserRepository = require('../repositories/fundraiser.repository');
+const MultipleAccountsRepository = require('../repositories/multiple-accounts.repository');
+const CaptchaRepository = require('../repositories/captcha.repository');
+const HighlightsRepository = require('../repositories/highlights.repository');
+const SearchService = require('../services/search.service');
+const LiveService = require('../services/live.service');
+
+/**
+ * IgApiClient
+ *
+ * - Păstrăm în totalitate funcționalitatea existentă (login/logout/isLoggedIn/saveSession/loadSession/isSessionValid/destroy)
+ * - Am eliminat complet stratul Realtime (WebSocket). Orice cod dependent de realtime trebuie migrat separat.
+ * - Am adăugat un helper generic `retryAsync(fn, opts)` pentru retry/backoff la operații asincrone (utile pentru request-uri).
+ */
+class IgApiClient extends EventEmitter {
+  constructor() {
+    super();
+
+    this.state = new State();
+    this.request = new Request(this);
+    this.navChain = this.request.navChain;
+
+    // Initialize repositories
+    this.account = new AccountRepository(this);
+    this.user = new UserRepository(this);
+    this.direct = new DirectRepository(this);
+    this.directThread = new DirectThreadRepository(this);
+    this.media = new MediaRepository(this);
+    this.upload = new UploadRepository(this);
+    this.story = new StoryRepository(this);
+    this.feed = new FeedRepository(this);
+    this.friendship = new FriendshipRepository(this);
+    this.location = new LocationRepository(this);
+    this.hashtag = new HashtagRepository(this);
+    this.news = new NewsRepository(this);
+    this.collection = new CollectionRepository(this);
+    this.closeFriends = new CloseFriendsRepository(this);
+    this.clip = new ClipRepository(this);
+    this.timeline = new TimelineRepository(this);
+    this.insights = new InsightsRepository(this);
+    this.note = new NoteRepository(this);
+    this.notification = new NotificationRepository(this);
+    this.signup = new SignupRepository(this);
+    this.totp = new TOTPRepository(this);
+    this.bloks = new BloksRepository(this);
+    this.challenge = new ChallengeRepository(this);
+    this.share = new ShareRepository(this);
+    this.track = new TrackRepository(this);
+    this.explore = new ExploreRepository(this);
+    this.fbsearch = new FBSearchRepository(this);
+    this.fundraiser = new FundraiserRepository(this);
+    this.multipleAccounts = new MultipleAccountsRepository(this);
+    this.captcha = new CaptchaRepository(this);
+    this.highlights = new HighlightsRepository(this);
+
+    // Initialize services
+    this.search = new SearchService(this);
+    this.live = new LiveService(this);
+
+    // Create dm object for easier access (keeps backward compatibility)
+    this.dm = {
+      send: this.direct.send.bind(this.direct),
+      sendToGroup: this.directThread.sendToGroup.bind(this.directThread),
+      sendImage: this.direct.sendImage.bind(this.direct),
+      sendVideo: this.direct.sendVideo.bind(this.direct),
+      getInbox: this.direct.getInbox.bind(this.direct),
+      getThread: this.directThread.getThread.bind(this.directThread)
+    };
+
+    // Proxy debug / verbose
+    this.state.verbose = this.state.verbose || false;
+
+    // Default retry policy for the new helper retryAsync
+    this._defaultRetryPolicy = { retries: 3, delayMs: 500 };
+
+  }
+
+  /**
+   * Login -> uses account.login. Returns whatever account.login returns.
+   * NOTE: removed automatic realtime connection attempt.
+   */
+  async login(credentials) {
+    this.navChain.simulateAppOpen();
+    if (this.state.deviceId) {
+       try {
+         await this.preLoginFlow();
+       } catch (e) {
+         if (this.state.verbose) console.warn('[Pre-Login] Flow error (non-fatal):', e.message);
+       }
+    }
+    const result = await this.account.login(credentials);
+    try {
+      await this.postLoginFlow();
+    } catch (e) {
+      if (this.state.verbose) console.warn('[Post-Login] Flow error (non-fatal):', e.message);
+    }
+    return result;
+  }
+
+  /**
+   * Additional Android-specific behavior simulation
+   */
+  async simulateAndroidBehavior() {
+    if (this.state.verbose) console.log('[Anti-Bot] Simulating Android-specific background behaviors...');
+    
+    // 0. Pre-login notification suppression / Trust signal
+    try {
+      await this.request.send({
+        url: '/api/v1/accounts/get_presence_disabled/',
+        method: 'GET',
+      });
+    } catch (e) {}
+
+    // 1. Fetch Contact Permission (often requested on start/login)
+    try {
+      await this.request.send({
+        url: '/api/v1/accounts/contact_point_pref/',
+        method: 'GET',
+      });
+    } catch (e) {}
+
+    // 2. Fetch Zero Rating (Mobile data settings)
+    try {
+      await this.request.send({
+        url: '/api/v1/zero/get_headers/',
+        method: 'GET',
+      });
+    } catch (e) {}
+
+    // 3. Fetch Banyan (Explore/Search context)
+    try {
+      await this.request.send({
+        url: '/api/v1/banyan/banyan/',
+        method: 'GET',
+        qs: {
+          views: '["direct_user_search","direct_search_context","direct_share_sheet"]',
+        },
+      });
+    } catch (e) {}
+  }
+
+  async logout() {
+    return await this.account.logout();
+  }
+
+  isLoggedIn() {
+    try {
+      return !!this.state.cookieUserId;
+    } catch {
+      return false;
+    }
+  }
+
+  async saveSession() {
+    return await this.state.serialize();
+  }
+
+  async loadSession(session) {
+    const ret = await this.state.deserialize(session);
+    this.navChain.simulateAppOpen();
+    return ret;
+  }
+
+  async isSessionValid() {
+    try {
+      await this.account.currentUser();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  destroy() {
+    // Cleanup resources - keep original behaviour for request streams if present
+    try { this.request.error$.complete(); } catch (_) {}
+    try { this.request.end$.complete(); } catch (_) {}
+  }
+
+  // -------------------------------
+  // === UTILITY HELPER METHODS
+  // -------------------------------
+
+  async preLoginFlow() {
+    if (this.state.verbose) console.log('[Pre-Login] Starting pre-login flow (sync_launcher)...');
+    try {
+      await this.request.send({
+        url: '/api/v1/launcher/sync/',
+        method: 'POST',
+        form: this.request.sign({
+          id: this.state.uuid,
+          server_config_retrieval: '1',
+        }),
+      });
+      if (this.state.verbose) console.log('[Pre-Login] Launcher Sync: OK');
+    } catch (e) {
+      if (this.state.verbose) console.warn('[Pre-Login] Launcher Sync Failed (non-fatal):', e.message);
+    }
+    await new Promise(resolve => setTimeout(resolve, Math.random() * 700 + 175));
+  }
+
+  async postLoginFlow() {
+    if (this.state.verbose) console.log('[Post-Login] Starting post-login flow...');
+    try {
+      await this.request.send({
+        url: '/api/v1/feed/reels_tray/',
+        method: 'POST',
+        form: this.request.sign({
+          supported_capabilities_new: JSON.stringify(this.state.constants.SUPPORTED_CAPABILITIES),
+          reason: 'cold_start',
+          timezone_offset: String(this.state.timezoneOffset),
+          tray_session_id: this.state.traySessionId,
+          request_id: this.state.requestId,
+          _uuid: this.state.uuid,
+          page_size: 50,
+          reel_tray_impressions: {},
+        }),
+      });
+      if (this.state.verbose) console.log('[Post-Login] Reels tray: OK');
+    } catch (e) {
+      if (this.state.verbose) console.warn('[Post-Login] Reels tray failed (non-fatal):', e.message);
+    }
+    try {
+      const timelineData = JSON.stringify({
+        has_camera_permission: '1',
+        feed_view_info: '[]',
+        phone_id: this.state.phoneId,
+        reason: 'cold_start_fetch',
+        battery_level: 100,
+        timezone_offset: String(this.state.timezoneOffset),
+        device_id: this.state.uuid,
+        request_id: this.state.requestId,
+        _uuid: this.state.uuid,
+        is_charging: Math.random() > 0.5 ? 1 : 0,
+        is_dark_mode: 1,
+        will_sound_on: Math.random() > 0.5 ? 1 : 0,
+        session_id: this.state.clientSessionId,
+        bloks_versioning_id: this.state.bloksVersionId,
+        is_pull_to_refresh: '0',
+      });
+      await this.request.send({
+        url: '/api/v1/feed/timeline/',
+        method: 'POST',
+        data: timelineData,
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+          'X-Ads-Opt-Out': '0',
+          'X-DEVICE-ID': this.state.uuid,
+          'X-CM-Bandwidth-KBPS': '-1.000',
+          'X-CM-Latency': String(Math.floor(Math.random() * 5) + 1),
+        },
+      });
+      if (this.state.verbose) console.log('[Post-Login] Timeline feed: OK');
+    } catch (e) {
+      if (this.state.verbose) console.warn('[Post-Login] Timeline feed failed (non-fatal):', e.message);
+    }
+  }
+
+  async simulateAppStart() {
+    return this.preLoginFlow();
+  }
+
+  /**
+   * Generic retry helper for async functions.
+   *
+   * Usage:
+   * await client.retryAsync(() => client.request.post(...), { retries: 5, delayMs: 1000 });
+   *
+   * Options:
+   *  - retries: number (default from this._defaultRetryPolicy.retries)
+   *  - delayMs: base delay in ms (default from this._defaultRetryPolicy.delayMs)
+   *  - factor: multiplier for exponential backoff (default 1.5)
+   *  - onRetry: optional callback (err, attempt) called before next retry
+   */
+  async retryAsync(fn, options = {}) {
+    const retries = typeof options.retries === 'number' ? options.retries : this._defaultRetryPolicy.retries;
+    const delayMs = typeof options.delayMs === 'number' ? options.delayMs : this._defaultRetryPolicy.delayMs;
+    const factor = typeof options.factor === 'number' ? options.factor : 1.5;
+    const onRetry = typeof options.onRetry === 'function' ? options.onRetry : null;
+
+    let lastErr;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        if (this.state.verbose) {
+          console.log(`[Retry] attempt ${attempt + 1}/${retries + 1}`);
+        }
+        const res = await fn();
+        return res;
+      } catch (err) {
+        lastErr = err;
+        if (attempt === retries) break;
+        if (onRetry) {
+          try { onRetry(err, attempt + 1); } catch (_) {}
+        }
+        const backoff = Math.round(delayMs * Math.pow(factor, attempt));
+        if (this.state.verbose) {
+          console.warn(`[Retry] attempt ${attempt + 1} failed: ${err && err.message ? err.message : err}. Backoff ${backoff}ms`);
+        }
+        await new Promise(r => setTimeout(r, backoff));
+      }
+    }
+    throw lastErr || new Error('retryAsync failed without specific error');
+  }
+
+  /**
+   * Set default retry policy for retryAsync.
+   * Example: client.setDefaultRetryPolicy({ retries: 5, delayMs: 800 });
+   */
+  setDefaultRetryPolicy(policy = {}) {
+    if (typeof policy.retries === 'number') this._defaultRetryPolicy.retries = policy.retries;
+    if (typeof policy.delayMs === 'number') this._defaultRetryPolicy.delayMs = policy.delayMs;
+    return this._defaultRetryPolicy;
+  }
+
+  /**
+   * Save session object to a file. Path optional (defaults to ./session.json).
+   * Will call this.saveSession() internally.
+   */
+  async saveSessionToFile(filePath) {
+    const p = filePath || path.resolve(process.cwd(), 'session.json');
+    const data = await this.saveSession();
+    // Ensure JSON string
+    const json = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+    await fs.promises.writeFile(p, json, { mode: 0o600 });
+    if (this.state.verbose) console.log('[Session] Saved session to', p);
+    return p;
+  }
+
+  /**
+   * Load session from file path (defaults to ./session.json). Returns true on success.
+   */
+  async loadSessionFromFile(filePath) {
+    const p = filePath || path.resolve(process.cwd(), 'session.json');
+    if (!fs.existsSync(p)) {
+      if (this.state.verbose) console.warn('[Session] loadSessionFromFile: file not found', p);
+      return false;
+    }
+    const raw = await fs.promises.readFile(p, 'utf8');
+    let sessionObj;
+    try {
+      sessionObj = JSON.parse(raw);
+    } catch (e) {
+      if (this.state.verbose) console.warn('[Session] loadSessionFromFile: invalid JSON in', p);
+      throw e;
+    }
+    await this.loadSession(sessionObj);
+    if (this.state.verbose) console.log('[Session] Loaded session from', p);
+    return true;
+  }
+
+  /**
+   * Attempt to load session JSON if exists and valid, else false.
+   * Wrapper helper for convenience.
+   */
+  async tryLoadSessionFileIfExists(filePath) {
+    try {
+      const loaded = await this.loadSessionFromFile(filePath);
+      if (!loaded) return false;
+      return await this.isSessionValid();
+    } catch (e) {
+      if (this.state.verbose) console.warn('[Session] tryLoadSessionFileIfExists failed:', e && e.message);
+      return false;
+    }
+  }
+
+  /**
+   * Set verbose mode on/off.
+   */
+  setVerbose(flag) {
+    this.state.verbose = !!flag;
+    return this.state.verbose;
+  }
+
+  /**
+   * safeDestroy: a slightly more robust destroy which attempts to stop requests, etc.
+   */
+  async safeDestroy() {
+    try { if (this.request && this.request.error$ && typeof this.request.error$.complete === 'function') this.request.error$.complete(); } catch (_) {}
+    try { if (this.request && this.request.end$ && typeof this.request.end$.complete === 'function') this.request.end$.complete(); } catch (_) {}
+    
+    
+    // keep original destroy for backward compatibility
+    try { this.destroy(); } catch (_) {}
+  }
+}
+
+module.exports = IgApiClient;

package/dist/core/nav-chain.js

@@ -0,0 +1,282 @@
+'use strict';
+
+const { random } = require('lodash');
+
+const SCREEN_IDS = {
+  MAIN_FEED: 'MainFeedFragment',
+  FEED_TIMELINE: 'FeedTimelineFragment',
+  DIRECT_INBOX: 'DirectInboxFragment',
+  DIRECT_THREAD: 'DirectThreadFragment',
+  DIRECT_PENDING: 'DirectPendingInboxFragment',
+  SELF_PROFILE: 'SelfProfileFragment',
+  PROFILE: 'ProfileFragment',
+  PROFILE_MEDIA_TAB: 'ProfileMediaTabFragment',
+  EXPLORE: 'ExploreFragment',
+  REELS: 'ReelsFragment',
+  STORY_VIEWER: 'StoryViewerFragment',
+  SEARCH: 'SearchFragment',
+  ACTIVITY: 'ActivityFeedFragment',
+  SETTINGS: 'SettingsFragment',
+  MEDIA_VIEWER: 'MediaViewerFragment',
+};
+
+const MODULE_IDS = {
+  MAIN_FEED: 'feed_timeline',
+  DIRECT_INBOX: 'direct_inbox',
+  DIRECT_THREAD: 'direct_thread',
+  DIRECT_PENDING: 'direct_pending_inbox',
+  SELF_PROFILE: 'self_profile',
+  PROFILE: 'profile',
+  EXPLORE: 'explore_popular',
+  REELS: 'clips_viewer',
+  STORY_VIEWER: 'reel_feed_timeline',
+  SEARCH: 'search',
+  ACTIVITY: 'news',
+  SETTINGS: 'settings',
+  MEDIA_VIEWER: 'feed_contextual_profile',
+};
+
+const SHORT_CODES = {
+  feed_timeline: '9MV',
+  direct_inbox: 'QrA',
+  direct_thread: 'MpL',
+  direct_pending_inbox: 'QrB',
+  self_profile: '9Xf',
+  profile: '8wC',
+  explore_popular: '6xQ',
+  clips_viewer: '9Ly',
+  reel_feed_timeline: '5RE',
+  search: '7GJ',
+  news: '9HR',
+  settings: '4Dn',
+  feed_contextual_profile: '9z6',
+};
+
+const ALTERNATIVE_SHORT_CODES = {
+  feed_timeline: ['MainFeedFragment', '9MV', 'cold_start'],
+  direct_inbox: ['QrA', 'DirectInboxFragment', 'ig_direct'],
+  direct_thread: ['MpL', 'DirectThreadFragment', 'ig_direct_thread'],
+  self_profile: ['9Xf', 'SelfFragment', 'self_profile'],
+  profile: ['8wC', 'ProfileFragment', 'profile'],
+  explore_popular: ['6xQ', 'ExploreFragment', 'explore'],
+};
+
+class NavChainManager {
+  constructor() {
+    this._chain = [];
+    this._stepCounter = 0;
+    this._lastActionTimestamp = Date.now();
+    this._sessionStarted = false;
+    this._currentContext = null;
+  }
+
+  reset() {
+    this._chain = [];
+    this._stepCounter = 0;
+    this._lastActionTimestamp = Date.now();
+    this._sessionStarted = false;
+    this._currentContext = null;
+  }
+
+  _pickShortCode(moduleId) {
+    const alts = ALTERNATIVE_SHORT_CODES[moduleId];
+    if (alts && Math.random() < 0.3) {
+      return alts[Math.floor(Math.random() * alts.length)];
+    }
+    return SHORT_CODES[moduleId] || moduleId;
+  }
+
+  _addStep(screenOrShortCode, moduleId) {
+    this._stepCounter++;
+    const entry = `${screenOrShortCode}:${moduleId}:${this._stepCounter}`;
+    this._chain.push(entry);
+    if (this._chain.length > 8) {
+      this._chain = this._chain.slice(-6);
+    }
+    this._lastActionTimestamp = Date.now();
+    return entry;
+  }
+
+  simulateAppOpen() {
+    this.reset();
+    this._sessionStarted = true;
+
+    const openVariant = Math.random();
+    if (openVariant < 0.6) {
+      this._addStep(this._pickShortCode('feed_timeline'), 'feed_timeline');
+    } else if (openVariant < 0.85) {
+      this._addStep(this._pickShortCode('feed_timeline'), 'feed_timeline');
+      const delay = random(200, 800);
+      this._lastActionTimestamp = Date.now() - delay;
+    } else {
+      this._addStep('cold_start', 'feed_timeline');
+    }
+
+    this._currentContext = 'feed';
+    return this.getChainString();
+  }
+
+  navigateToInbox() {
+    if (!this._sessionStarted) {
+      this.simulateAppOpen();
+    }
+    this._addStep(this._pickShortCode('direct_inbox'), 'direct_inbox');
+    this._currentContext = 'direct_inbox';
+    return this.getChainString();
+  }
+
+  navigateToThread(threadId) {
+    if (this._currentContext !== 'direct_inbox' && this._currentContext !== 'direct_thread') {
+      this.navigateToInbox();
+    }
+    this._addStep(this._pickShortCode('direct_thread'), 'direct_thread');
+    this._currentContext = 'direct_thread';
+    return this.getChainString();
+  }
+
+  navigateToPendingInbox() {
+    if (this._currentContext !== 'direct_inbox') {
+      this.navigateToInbox();
+    }
+    this._addStep(this._pickShortCode('direct_pending_inbox'), 'direct_pending_inbox');
+    this._currentContext = 'direct_pending';
+    return this.getChainString();
+  }
+
+  navigateToProfile(isSelf = false) {
+    if (!this._sessionStarted) {
+      this.simulateAppOpen();
+    }
+    if (isSelf) {
+      this._addStep(this._pickShortCode('self_profile'), 'self_profile');
+      this._currentContext = 'self_profile';
+    } else {
+      this._addStep(this._pickShortCode('profile'), 'profile');
+      this._currentContext = 'profile';
+    }
+    return this.getChainString();
+  }
+
+  navigateToExplore() {
+    if (!this._sessionStarted) {
+      this.simulateAppOpen();
+    }
+    this._addStep(this._pickShortCode('explore_popular'), 'explore_popular');
+    this._currentContext = 'explore';
+    return this.getChainString();
+  }
+
+  navigateToFeed() {
+    if (!this._sessionStarted) {
+      this.simulateAppOpen();
+    } else {
+      this._addStep(this._pickShortCode('feed_timeline'), 'feed_timeline');
+    }
+    this._currentContext = 'feed';
+    return this.getChainString();
+  }
+
+  incrementForAction() {
+    if (!this._sessionStarted) {
+      this.simulateAppOpen();
+    }
+    const ctx = this._currentContext || 'feed_timeline';
+    const moduleMap = {
+      'feed': 'feed_timeline',
+      'direct_inbox': 'direct_inbox',
+      'direct_thread': 'direct_thread',
+      'direct_pending': 'direct_pending_inbox',
+      'self_profile': 'self_profile',
+      'profile': 'profile',
+      'explore': 'explore_popular',
+    };
+    const moduleId = moduleMap[ctx] || 'feed_timeline';
+    this._addStep(this._pickShortCode(moduleId), moduleId);
+    return this.getChainString();
+  }
+
+  getChainForDMBroadcast(isNewThread = false) {
+    if (!this._sessionStarted) {
+      this.simulateAppOpen();
+    }
+
+    if (this._currentContext !== 'direct_thread') {
+      if (this._currentContext !== 'direct_inbox') {
+        this.navigateToInbox();
+      }
+      this.navigateToThread();
+    }
+
+    this._stepCounter++;
+    this._lastActionTimestamp = Date.now();
+    return this.getChainString();
+  }
+
+  getChainForDMSequence(messageIndex) {
+    if (messageIndex === 0 || !this._sessionStarted) {
+      this.simulateAppOpen();
+      this.navigateToInbox();
+      this.navigateToThread();
+    } else {
+      this._stepCounter++;
+      const lastEntry = this._chain[this._chain.length - 1];
+      if (lastEntry) {
+        const parts = lastEntry.split(':');
+        if (parts.length === 3) {
+          parts[2] = String(this._stepCounter);
+          this._chain[this._chain.length - 1] = parts.join(':');
+        }
+      }
+    }
+
+    this._lastActionTimestamp = Date.now();
+    return this.getChainString();
+  }
+
+  getChainForBulkDM(recipientIndex, totalRecipients) {
+    if (recipientIndex === 0) {
+      this.simulateAppOpen();
+      this.navigateToInbox();
+    }
+
+    this.navigateToThread();
+
+    this._stepCounter++;
+    this._lastActionTimestamp = Date.now();
+
+    if (recipientIndex > 0 && recipientIndex % random(3, 6) === 0) {
+      this.navigateToInbox();
+      this.navigateToThread();
+    }
+
+    return this.getChainString();
+  }
+
+  getChainString() {
+    if (this._chain.length === 0) {
+      this.simulateAppOpen();
+    }
+    return this._chain.join(',');
+  }
+
+  getCurrentContext() {
+    return this._currentContext;
+  }
+
+  getStepCounter() {
+    return this._stepCounter;
+  }
+
+  setContext(contextName) {
+    this._currentContext = contextName;
+    if (!this._sessionStarted) {
+      this.simulateAppOpen();
+    }
+  }
+}
+
+NavChainManager.SCREEN_IDS = SCREEN_IDS;
+NavChainManager.MODULE_IDS = MODULE_IDS;
+NavChainManager.SHORT_CODES = SHORT_CODES;
+
+module.exports = NavChainManager;

package/dist/core/repository.js

@@ -0,0 +1,7 @@
+class Repository {
+  constructor(client) {
+    this.client = client;
+  }
+}
+
+module.exports = Repository;