feat: add continue processing and start from current position functionality

Author: flowmitry

src/app/contexts/ProcessingContext.tsx

@@ -12,6 +12,8 @@ export interface ProcessingContextValue {
   refreshTwitterStatus: () => Promise<boolean>
   startProcessing: () => Promise<void>
   stopProcessing: () => Promise<void>
+  continueProcessing: () => Promise<void>
+  startFromCurrentPosition: () => Promise<void>
   resetProcessing: () => void
   updateProcessingState: (updates: Partial<ProcessingState>, options?: { persist?: boolean }) => void
 }

src/app/providers/ProcessingProvider.tsx

@@ -161,6 +161,74 @@ export function ProcessingProvider({ children }: { children: React.ReactNode })
     }, { persist: true })
   }, [updateProcessingState])
 
+  const continueProcessing = useCallback(async () => {
+    const onTwitter = await refreshStatus()
+    if (!onTwitter) {
+      alert('Please navigate to Twitter/X first')
+      return
+    }
+
+    const tab = await getActiveTab()
+    if (!tab?.id) {
+      alert('Extension could not locate the active tab. Please try again.')
+      return
+    }
+
+    updateProcessingState({
+      isProcessing: true,
+      isCompleted: false
+    }, { persist: true })
+
+    try {
+      await sendMessageToTab(tab.id, {
+        action: 'CONTINUE_PROCESSING',
+        settings
+      })
+    } catch (error) {
+      console.error('Error sending CONTINUE_PROCESSING message:', error)
+      alert('Extension failed to continue. Please refresh the Twitter/X page and try again.')
+      updateProcessingState({ isProcessing: false }, { persist: true })
+    }
+  }, [refreshStatus, settings, updateProcessingState])
+
+  const startFromCurrentPosition = useCallback(async () => {
+    const onTwitter = await refreshStatus()
+    if (!onTwitter) {
+      alert('Please navigate to Twitter/X first')
+      return
+    }
+
+    try {
+      await saveSettings()
+    } catch (error) {
+      console.error('Failed to persist settings before restarting:', error)
+    }
+
+    const tab = await getActiveTab()
+    if (!tab?.id) {
+      alert('Extension could not locate the active tab. Please try again.')
+      return
+    }
+
+    updateProcessingState({
+      isProcessing: true,
+      isCompleted: false,
+      processedCount: 0,
+      bookmarkedCount: 0
+    }, { persist: true })
+
+    try {
+      await sendMessageToTab(tab.id, {
+        action: 'RESTART_PROCESSING_FROM_CURRENT',
+        settings
+      })
+    } catch (error) {
+      console.error('Error sending RESTART_PROCESSING_FROM_CURRENT message:', error)
+      alert('Extension failed to restart. Please refresh the Twitter/X page and try again.')
+      updateProcessingState({ isProcessing: false }, { persist: true })
+    }
+  }, [refreshStatus, saveSettings, settings, updateProcessingState])
+
   const resetProcessing = useCallback(() => {
     updateProcessingState({
       ...INITIAL_PROCESSING_STATE
@@ -178,9 +246,11 @@ export function ProcessingProvider({ children }: { children: React.ReactNode })
     refreshTwitterStatus: refreshStatus,
     startProcessing,
     stopProcessing,
+    continueProcessing,
+    startFromCurrentPosition,
     resetProcessing,
     updateProcessingState
-  }), [isProcessingLoaded, isTwitterPage, refreshStatus, resetProcessing, startProcessing, state, stopProcessing, updateProcessingState])
+  }), [continueProcessing, isProcessingLoaded, isTwitterPage, refreshStatus, resetProcessing, startFromCurrentPosition, startProcessing, state, stopProcessing, updateProcessingState])
 
   return (
     <ProcessingContext.Provider value={value}>

src/content.ts

@@ -4,29 +4,65 @@ let isProcessing = false
 let processedCount = 0
 let bookmarkedCount = 0
 let settings: Settings
+let processedTweets = new Set<string>()
+
+interface StartProcessingOptions {
+  resetCounters?: boolean
+  scrollToTop?: boolean
+  resetProcessedTweets?: boolean
+}
 
 // Listen for messages from popup
 chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
   if (message.action === 'START_PROCESSING') {
     settings = message.settings
-    startProcessing()
+    void startProcessing({ resetCounters: true, scrollToTop: true, resetProcessedTweets: true })
+  } else if (message.action === 'CONTINUE_PROCESSING') {
+    settings = message.settings ?? settings
+    void startProcessing({ resetCounters: false, scrollToTop: false, resetProcessedTweets: false })
+  } else if (message.action === 'RESTART_PROCESSING_FROM_CURRENT') {
+    settings = message.settings ?? settings
+    void startProcessing({ resetCounters: true, scrollToTop: false, resetProcessedTweets: false })
   } else if (message.action === 'STOP_PROCESSING') {
     isProcessing = false
   }
 
   sendResponse({ success: true })
 })
 
-async function startProcessing() {
+async function startProcessing(options: StartProcessingOptions = {}) {
+  if (isProcessing) {
+    return
+  }
+
+  const {
+    resetCounters = true,
+    scrollToTop = true,
+    resetProcessedTweets = resetCounters
+  } = options
+
+  if (!settings) {
+    console.warn('No settings supplied for processing run')
+    return
+  }
+
+  if (resetCounters) {
+    processedCount = 0
+    bookmarkedCount = 0
+  }
+
+  if (resetProcessedTweets) {
+    processedTweets = new Set<string>()
+  }
+
   isProcessing = true
-  processedCount = 0
-  bookmarkedCount = 0
-  
-  // Scroll to top first
-  window.scrollTo(0, 0)
-  await sleep(1000)
-  
-  const processedTweets = new Set<string>()
+
+  if (scrollToTop) {
+    window.scrollTo(0, 0)
+    await sleep(1000)
+  } else {
+    await sleep(300)
+  }
 
   while (isProcessing && bookmarkedCount < settings.bookmarksLimit) {
     // Find all tweet articles on the page

src/features/popup/Popup.tsx

@@ -20,6 +20,8 @@ export function Popup() {
     bookmarkedCount,
     startProcessing,
     stopProcessing,
+    continueProcessing,
+    startFromCurrentPosition,
     resetProcessing,
     isTwitterPage
   } = useProcessingContext()
@@ -40,6 +42,14 @@ export function Popup() {
     resetProcessing()
   }, [resetProcessing])
 
+  const handleContinue = useCallback(() => {
+    void continueProcessing()
+  }, [continueProcessing])
+
+  const handleStartFromHere = useCallback(() => {
+    void startFromCurrentPosition()
+  }, [startFromCurrentPosition])
+
   const { progressPercentage, bookmarkRate } = useMemo(() => {
     const progress = settings.bookmarksLimit > 0
       ? (bookmarkedCount / settings.bookmarksLimit) * 100
@@ -56,6 +66,10 @@ export function Popup() {
   }, [bookmarkedCount, processedCount, settings.bookmarksLimit])
 
   const showProcessingState = isProcessing || isCompleted
+  const hasBookmarksGoal = settings.bookmarksLimit > 0
+  const hasReachedBookmarksGoal = hasBookmarksGoal && bookmarkedCount >= settings.bookmarksLimit
+  const showContinueButton = isCompleted && !hasReachedBookmarksGoal
+  const showStartFromHereButton = isCompleted && hasReachedBookmarksGoal
 
   return (
     <div className="x-posts-finder-container">
@@ -71,13 +85,40 @@ export function Popup() {
               bookmarkRate={bookmarkRate}
               isCompleted={isCompleted}
             />
+            {isProcessing ? (
+              <ActionButton
+                onClick={handleStop}
+                variant="stop"
+              >
+                Stop analysis
+              </ActionButton>
+            ) : (
+              <>
+                {showContinueButton && (
+                  <ActionButton
+                    onClick={handleContinue}
+                    variant="start"
+                  >
+                    Continue
+                  </ActionButton>
+                )}
 
-            <ActionButton
-              onClick={isCompleted ? handleReset : handleStop}
-              variant={isCompleted ? 'start' : 'stop'}
-            >
-              {isCompleted ? 'Back to setup' : 'Stop analysis'}
-            </ActionButton>
+                {showStartFromHereButton && (
+                  <ActionButton
+                    onClick={handleStartFromHere}
+                    variant="start"
+                  >
+                    Start from here
+                  </ActionButton>
+                )}
+
+                <ActionButton
+                  onClick={handleReset}
+                >
+                  Back to setup
+                </ActionButton>
+              </>
+            )}
           </>
         ) : (
           <>