heathrow 0.7.0

data/lib/heathrow/sources/instagram.rb

@@ -0,0 +1,307 @@
+require 'digest'
+require 'json'
+require 'shellwords'
+require 'time'
+require_relative 'base'
+
+module Heathrow
+  module Sources
+    class Instagram < Base
+      COOKIE_DIR = File.join(Dir.home, '.heathrow', 'cookies')
+      COOKIE_FILE = File.join(COOKIE_DIR, 'instagram.json')
+      INBOX_URL = 'https://www.instagram.com/api/v1/direct_v2/inbox/'
+      APP_ID = '936619743392459'
+
+      REQUIRED_COOKIES = %w[sessionid csrftoken]
+      OPTIONAL_COOKIES = %w[ds_user_id ig_did mid]
+
+      def initialize(name, config, db)
+        super
+        @cookies = config['cookies'] || load_cookies
+      end
+
+      def sync(source_id)
+        return 0 unless valid_cookies?
+
+        begin
+          inbox = fetch_inbox
+          return 0 unless inbox
+
+          count = 0
+          threads = inbox['inbox']&.dig('threads') || []
+          threads.each do |thread|
+            count += process_thread(source_id, thread)
+          end
+          count
+        rescue SessionExpiredError => e
+          STDERR.puts "Instagram session expired: #{e.message}" if ENV['DEBUG']
+          save_session_error("Session expired. Please refresh cookies.")
+          0
+        rescue => e
+          STDERR.puts "Instagram error: #{e.message}\n#{e.backtrace.first(3).join("\n")}" if ENV['DEBUG']
+          0
+        end
+      end
+
+      def fetch
+        return [] unless enabled?
+        source = @db.get_source_by_name(@name)
+        return [] unless source
+        sync(source['id'])
+        update_last_fetch
+        []
+      end
+
+      def valid_cookies?
+        return false unless @cookies.is_a?(Hash)
+        REQUIRED_COOKIES.all? { |k| @cookies[k] && !@cookies[k].empty? }
+      end
+
+      def save_cookies(cookies = nil)
+        cookies ||= @cookies
+        Dir.mkdir(COOKIE_DIR) unless Dir.exist?(COOKIE_DIR)
+        File.write(COOKIE_FILE, cookies.to_json)
+        File.chmod(0600, COOKIE_FILE)
+        @cookies = cookies
+      end
+
+      SEND_SCRIPT = File.join(__dir__, 'instagram_send_marionette.py')
+
+      def send_message(thread_id, _subject, body)
+        return { success: false, message: "No thread ID" } unless thread_id
+        return { success: false, message: "Empty message" } if body.nil? || body.strip.empty?
+
+        result = `python3 #{Shellwords.escape(SEND_SCRIPT)} #{Shellwords.escape(thread_id)} #{Shellwords.escape(body.strip)} 2>/dev/null`
+
+        data = JSON.parse(result) rescue nil
+        if data
+          data.transform_keys!(&:to_sym)
+          data
+        else
+          { success: false, message: "Instagram send: no response from script" }
+        end
+      rescue => e
+        { success: false, message: "Instagram send error: #{e.message}" }
+      end
+
+      private
+
+      class SessionExpiredError < StandardError; end
+
+      def load_cookies
+        return {} unless File.exist?(COOKIE_FILE)
+        JSON.parse(File.read(COOKIE_FILE))
+      rescue
+        {}
+      end
+
+      def cookie_header
+        @cookies.map { |k, v| "#{k}=#{v}" }.join('; ')
+      end
+
+      def csrf_token
+        @cookies['csrftoken'] || ''
+      end
+
+      FETCH_SCRIPT = File.join(__dir__, 'instagram_fetch.py')
+
+      def fetch_inbox
+        # Use Marionette (real Firefox tab) since Meta blocks API calls from non-browsers
+        result = `python3 #{Shellwords.escape(FETCH_SCRIPT)} 2>/dev/null`
+
+        return nil if result.nil? || result.strip.empty?
+
+        begin
+          data = JSON.parse(result)
+          if data['error']
+            STDERR.puts "Instagram fetch error: #{data['error']}" if ENV['DEBUG']
+            return nil
+          end
+          if data['status'] != 'ok'
+            raise SessionExpiredError, "API returned status: #{data['status']}"
+          end
+          data
+        rescue JSON::ParserError => e
+          STDERR.puts "Instagram JSON parse error: #{e.message}" if ENV['DEBUG']
+          nil
+        end
+      end
+
+      def process_thread(source_id, thread)
+        return 0 unless thread
+
+        thread_id = thread['thread_id']
+        return 0 unless thread_id
+
+        # Get thread participants
+        users = thread['users'] || []
+        other_users = users.map { |u| u['full_name'].to_s.empty? ? u['username'] : u['full_name'] }
+        thread_title = thread['thread_title']
+        thread_title = other_users.join(', ') if thread_title.nil? || thread_title.empty?
+        thread_title = 'Unknown' if thread_title.empty?
+
+        items = thread['items'] || []
+        return 0 if items.empty?
+
+        count = 0
+        items.each do |item|
+          next unless item
+
+          content = extract_message_content(item)
+          timestamp = (item['timestamp'].to_i / 1_000_000) rescue Time.now.to_i
+
+          ext_id = "ig_#{thread_id}_#{item['item_id']}"
+
+          # Determine sender
+          sender_id = item['user_id'].to_s
+          sender = users.find { |u| u['pk'].to_s == sender_id }
+          sender_name = if sender
+                          sender['full_name'].to_s.empty? ? sender['username'] : sender['full_name']
+                        else
+                          thread_title
+                        end
+
+          attachments = extract_attachments(item)
+
+          data = {
+            source_id: source_id,
+            external_id: ext_id,
+            thread_id: thread_id,
+            sender: sender_name,
+            sender_name: sender_name,
+            recipients: [thread_title],
+            subject: thread_title,
+            content: content,
+            html_content: nil,
+            timestamp: timestamp,
+            received_at: Time.now.to_i,
+            read: item == items.first ? false : true,
+            starred: false,
+            archived: false,
+            labels: ['Instagram'],
+            attachments: attachments.empty? ? nil : attachments,
+            metadata: {
+              thread_id: thread_id,
+              item_id: item['item_id'],
+              participants: other_users,
+              is_group: thread['is_group'],
+              platform: 'instagram'
+            },
+            raw_data: { thread_id: thread_id, sender: sender_name }
+          }
+
+          begin
+            @db.insert_message(data)
+            count += 1
+          rescue SQLite3::ConstraintException
+            # Already exists
+          end
+        end
+        count
+      end
+
+      def extract_message_content(item)
+        case item['item_type']
+        when 'text'
+          item['text'] || ''
+        when 'media', 'media_share'
+          media = item['media'] || item['media_share'] || {}
+          caption = media.dig('caption', 'text') || ''
+          "[Media] #{caption}".strip
+        when 'raven_media'
+          '[Disappearing photo/video]'
+        when 'voice_media'
+          '[Voice message]'
+        when 'animated_media'
+          '[GIF]'
+        when 'clip'
+          clip = item['clip'] || {}
+          caption = clip.dig('clip', 'caption', 'text') || ''
+          "[Reel] #{caption}".strip
+        when 'story_share'
+          story = item['story_share'] || {}
+          "[Shared story] #{story['title'] || ''}".strip
+        when 'link'
+          link = item['link'] || {}
+          text = link['text'] || ''
+          url = link.dig('link_context', 'link_url') || ''
+          "#{text} #{url}".strip
+        when 'like'
+          '❤️'
+        when 'reel_share'
+          reel = item['reel_share'] || {}
+          "[Reel share] #{reel['text'] || ''}".strip
+        when 'xma'
+          '[Shared content]'
+        else
+          item['text'] || "[#{item['item_type'] || 'unknown'}]"
+        end
+      end
+
+      def extract_attachments(item)
+        attachments = []
+        case item['item_type']
+        when 'media', 'media_share'
+          media = item['media'] || item['media_share'] || {}
+          url = best_image_url(media)
+          if url
+            attachments << { 'url' => url, 'content_type' => media_type(media), 'name' => 'image.jpg' }
+          end
+        when 'raven_media'
+          media = item.dig('visual_media', 'media') || {}
+          url = best_image_url(media)
+          if url
+            attachments << { 'url' => url, 'content_type' => media_type(media), 'name' => 'disappearing.jpg' }
+          end
+        when 'animated_media'
+          images = item.dig('animated_media', 'images') || {}
+          url = images.dig('fixed_height', 'url') || images.values.first&.dig('url')
+          if url
+            attachments << { 'url' => url, 'content_type' => 'image/gif', 'name' => 'animation.gif' }
+          end
+        when 'clip'
+          media = item.dig('clip', 'clip') || {}
+          url = best_image_url(media)
+          if url
+            attachments << { 'url' => url, 'content_type' => 'image/jpeg', 'name' => 'reel_thumbnail.jpg' }
+          end
+        when 'story_share'
+          media = item.dig('story_share', 'media') || {}
+          url = best_image_url(media)
+          if url
+            attachments << { 'url' => url, 'content_type' => 'image/jpeg', 'name' => 'story.jpg' }
+          end
+        when 'xma'
+          # Shared content may have preview images
+          xma = (item['xma'] || []).first || {}
+          url = xma.dig('preview_url_info', 'url') || xma['header_icon_url']
+          if url
+            attachments << { 'url' => url, 'content_type' => 'image/jpeg', 'name' => 'shared.jpg' }
+          end
+        end
+        attachments
+      end
+
+      def best_image_url(media)
+        # Try candidates: highest quality first
+        candidates = media.dig('image_versions2', 'candidates') || []
+        best = candidates.max_by { |c| (c['width'] || 0) * (c['height'] || 0) }
+        best&.dig('url')
+      end
+
+      def media_type(media)
+        case media['media_type']
+        when 1 then 'image/jpeg'
+        when 2 then 'video/mp4'
+        else 'image/jpeg'
+        end
+      end
+
+      def save_session_error(message)
+        error_file = File.join(COOKIE_DIR, 'instagram_error.txt')
+        Dir.mkdir(COOKIE_DIR) unless Dir.exist?(COOKIE_DIR)
+        File.write(error_file, "#{Time.now.iso8601}: #{message}\n", mode: 'a')
+      end
+    end
+  end
+end

data/lib/heathrow/sources/instagram_fetch.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Fetch Instagram DM inbox via Firefox Marionette.
+
+Connects to Firefox Marionette on port 2828, finds the Instagram tab,
+and executes a fetch() call to get inbox data. Outputs JSON to stdout.
+Debug info goes to stderr.
+"""
+
+import json
+import sys
+
+def main():
+    client = None
+    try:
+        from marionette_driver.marionette import Marionette
+
+        print("Connecting to Marionette...", file=sys.stderr)
+        client = Marionette(host='127.0.0.1', port=2828)
+        client.start_session()
+
+        # Find the Instagram tab
+        ig_found = False
+        for h in client.window_handles:
+            client.switch_to_window(h)
+            url = client.get_url()
+            if 'instagram.com' in url:
+                ig_found = True
+                print(f"Found Instagram tab: {url}", file=sys.stderr)
+                break
+
+        if not ig_found:
+            print("No Instagram tab found in Firefox", file=sys.stderr)
+            json.dump({"error": "No Instagram tab found in Firefox", "inbox": {"threads": []}}, sys.stdout)
+            return
+
+        # Fetch inbox data via the Instagram private API
+        js = (
+            'let resolve = arguments[arguments.length - 1];'
+            'fetch("/api/v1/direct_v2/inbox/?limit=20&thread_message_limit=10", {'
+            '  credentials: "include",'
+            '  headers: {"x-ig-app-id": "936619743392459", "x-requested-with": "XMLHttpRequest"}'
+            '})'
+            '.then(function(r) { return r.text(); })'
+            '.then(function(text) { resolve(text); })'
+            '.catch(function(e) { resolve("ERROR: " + e.message); });'
+        )
+
+        print("Fetching inbox...", file=sys.stderr)
+        result = client.execute_async_script(js, script_timeout=15000)
+
+        if result is None:
+            print("Marionette returned None", file=sys.stderr)
+            json.dump({"error": "No response from Instagram API", "inbox": {"threads": []}}, sys.stdout)
+            return
+
+        if isinstance(result, str) and result.startswith("ERROR:"):
+            print(f"Fetch error: {result}", file=sys.stderr)
+            json.dump({"error": result, "inbox": {"threads": []}}, sys.stdout)
+            return
+
+        # Parse the JSON response
+        try:
+            data = json.loads(result)
+        except json.JSONDecodeError as e:
+            print(f"JSON parse error: {e}", file=sys.stderr)
+            print(f"Raw response (first 500 chars): {result[:500]}", file=sys.stderr)
+            json.dump({"error": f"JSON parse error: {e}", "inbox": {"threads": []}}, sys.stdout)
+            return
+
+        # Check for API errors
+        status = data.get("status", "")
+        if status != "ok":
+            msg = data.get("message", f"API returned status: {status}")
+            if "login" in msg.lower() or "login" in str(data).lower():
+                msg = "Instagram login required. Please log in to Instagram in Firefox."
+            print(f"API error: {msg}", file=sys.stderr)
+            json.dump({"error": msg, "inbox": {"threads": []}}, sys.stdout)
+            return
+
+        # Success: output the full response
+        threads = data.get("inbox", {}).get("threads", [])
+        print(f"Fetched {len(threads)} threads", file=sys.stderr)
+        json.dump(data, sys.stdout)
+
+    except ImportError:
+        json.dump({"error": "marionette_driver not installed (pip install marionette-driver)", "inbox": {"threads": []}}, sys.stdout)
+    except ConnectionRefusedError:
+        json.dump({"error": "Cannot connect to Firefox Marionette on port 2828. Start Firefox with --marionette.", "inbox": {"threads": []}}, sys.stdout)
+    except Exception as e:
+        print(f"Unexpected error: {type(e).__name__}: {e}", file=sys.stderr)
+        json.dump({"error": f"{type(e).__name__}: {e}", "inbox": {"threads": []}}, sys.stdout)
+    finally:
+        if client is not None:
+            try:
+                client.delete_session()
+                print("Session closed.", file=sys.stderr)
+            except Exception:
+                pass
+
+if __name__ == '__main__':
+    main()

data/lib/heathrow/sources/instagram_send.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Send an Instagram DM by opening the thread in the user's browser.
+
+Usage: instagram_send.py <thread_id> <message>
+Outputs JSON: { "success": true/false, "message": "..." }
+
+Since Instagram blocks all non-browser API access, this opens the DM thread
+in the user's real browser with the message pre-copied to clipboard.
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+
+def output(success, message):
+    print(json.dumps({"success": success, "message": message}))
+    sys.exit(0)
+
+
+def main():
+    if len(sys.argv) < 3:
+        output(False, "Usage: instagram_send.py <thread_id> <message>")
+
+    thread_id = sys.argv[1]
+    message = sys.argv[2]
+
+    if not thread_id or not message.strip():
+        output(False, "Thread ID and message are required")
+
+    url = f"https://www.instagram.com/direct/t/{thread_id}/"
+
+    # Copy message to clipboard
+    try:
+        proc = subprocess.Popen(
+            ["xclip", "-selection", "clipboard"],
+            stdin=subprocess.PIPE,
+        )
+        proc.communicate(message.strip().encode())
+    except Exception:
+        pass
+
+    # Open in browser
+    subprocess.Popen(
+        ["xdg-open", url],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+    output(True, "Opened Instagram DM in browser. Message copied to clipboard (Ctrl+V to paste).")
+
+
+if __name__ == "__main__":
+    main()

data/lib/heathrow/sources/instagram_send_marionette.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Send an Instagram DM via Firefox Marionette.
+
+Connects to Firefox, finds the Instagram tab, navigates to the DM thread,
+types the message and presses Enter.
+
+Usage: instagram_send_marionette.py <thread_id> <message>
+Outputs JSON: { "success": true/false, "message": "..." }
+"""
+
+import json
+import sys
+import time
+
+
+def output(success, message):
+    print(json.dumps({"success": success, "message": message}))
+    sys.exit(0)
+
+
+def main():
+    if len(sys.argv) < 3:
+        output(False, "Usage: instagram_send_marionette.py <thread_id> <message>")
+
+    thread_id = sys.argv[1]
+    message = sys.argv[2].strip()
+
+    if not thread_id or not message:
+        output(False, "Thread ID and message are required")
+
+    try:
+        from marionette_driver.marionette import Marionette
+        from marionette_driver.keys import Keys
+    except ImportError:
+        output(False, "marionette_driver not installed")
+
+    client = None
+    try:
+        client = Marionette(host='127.0.0.1', port=2828)
+        client.start_session()
+
+        # Find Instagram tab
+        ig_handle = None
+        for h in client.window_handles:
+            client.switch_to_window(h)
+            if 'instagram.com' in client.get_url():
+                ig_handle = h
+                break
+
+        if not ig_handle:
+            output(False, "No Instagram tab found in Firefox")
+
+        # Navigate to DM thread
+        client.navigate(f"https://www.instagram.com/direct/t/{thread_id}/")
+
+        # Wait for message input to appear
+        for _ in range(20):
+            found = client.execute_script("""
+                var el = document.querySelector('textarea[placeholder]')
+                      || document.querySelector('[role="textbox"][contenteditable="true"]');
+                return el ? el.tagName : null;
+            """)
+            if found:
+                break
+            time.sleep(0.5)
+        else:
+            output(False, "Could not find message input")
+
+        # Find and interact with the input
+        from marionette_driver.by import By
+        time.sleep(0.3)
+
+        # Try textarea first, then contenteditable
+        try:
+            el = client.find_element(By.CSS_SELECTOR, 'textarea[placeholder]')
+        except Exception:
+            el = client.find_element(By.CSS_SELECTOR, '[role="textbox"][contenteditable="true"]')
+
+        el.click()
+        time.sleep(0.2)
+
+        # Use clipboard to paste (avoids character interpretation issues with <, > etc.)
+        import subprocess
+        proc = subprocess.Popen(["xclip", "-selection", "clipboard"], stdin=subprocess.PIPE)
+        proc.communicate(message.encode())
+
+        el.send_keys(Keys.CONTROL + "v")
+        time.sleep(0.3)
+        el.send_keys(Keys.ENTER)
+
+        output(True, "Message sent via Instagram")
+
+    except Exception as e:
+        output(False, f"Instagram send error: {e}")
+    finally:
+        if client:
+            try:
+                client.delete_session()
+            except Exception:
+                pass
+
+
+if __name__ == '__main__':
+    main()