instagram_connect 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfea76e8f86d1da429ba916fdf03124bb3eb0a4f0cc8d50bdeb5db838282026a
-  data.tar.gz: b55274a8583dcad12bedca7025517fbfcea36865479f28c520c7c103e8e4d49a
+  metadata.gz: c6cdab9c7a77b05738f216055248fb49663ce358ab496612c37be3b065b329dc
+  data.tar.gz: 2ff8e7866abc44e383509240659cb2403f1e1ce803b55d3cbbf6d28fc7fe394c
 SHA512:
-  metadata.gz: b9d2f5d664868d9444883e603684bf22e65880d8e75ef65d6014c14a7a6065cdf5d199b1d77c6c3c2f3178c7c804ebc921cdf08966d6c68b2ee18686a1c3a3f4
-  data.tar.gz: d21363ec67aa080df5ff76747cf6f97db0b81963fe66716e7df44e44456dab3cf5b528e502f43c441a967a8d029459d2bb1dcef343b215979524bcc9c068bbbe
+  metadata.gz: d2dc22ae8f6c88e3a7f3ab210f3211a884c65fc0ea688e10dd9da63377b8fe91b21bb419420e875634783844e0daa84c9c6e458d0344fba6de4d11f35c1eaba3
+  data.tar.gz: 8dc40c7345f8a292e4370977c1233f46a77f7a551c0ebfd55db89fd30a769fd453023a5229bfaf9df43a47ae788202b5a0a9cab7bc62d52916604a6410b1b675

data/CHANGELOG.md

@@ -6,6 +6,46 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.3.2] - 2026-07-26
+
+### Added
+
+- **Existing conversations are now imported.** The gem only ever created threads from inbound
+  webhooks, and webhooks only announce NEW activity — so a freshly connected account showed an
+  empty inbox beside an Instagram account full of conversations, and stayed empty until somebody
+  happened to message in. `SyncConversationsJob` pulls every thread and the 20 most recent messages
+  in each, which is the whole history Meta exposes to any app. It runs on connect and is safe to
+  re-run: threads are located by igsid and messages dedupe on `ig_message_id`.
+- `Client#list_conversations` and `Client#conversation_messages`.
+
+### Note
+
+The Conversations API is a **Page-token** operation. An account still holding the OAuth user token
+gets `(#3) Application does not have the capability to make this API call` — verified against a live
+account. `AccountReadinessJob` performs that swap, so it must have run before a sync can succeed.
+
+
+## [0.3.1] - 2026-07-26
+
+### Fixed
+
+- **Connecting an account failed when the Page came from the Login-for-Business asset picker.**
+  `/me/accounts` lists only the Pages a token may *enumerate*. A Page granted through the picker is
+  absent from that listing while reading perfectly well by id, so the list came back empty and the
+  connect was refused — on an account that was correctly linked and fully granted. Identity
+  resolution now falls back to the assets the token actually carries (`/debug_token` granular
+  scopes, which needs no permission beyond the app's own credentials) and reads those Pages by id.
+- **A failed Graph call was reported as a missing account.** `resolve_identity` never checked
+  `Result#success?`, so an expired token or an HTTP 400 produced the same message as an empty list.
+  API failures now raise `ApiError` carrying Meta's own message.
+- **The error message asserted a cause it had not verified.** It claimed no Instagram account was
+  linked to a Page, which was false in exactly the case that triggered it. It now states what was
+  actually checked.
+- **`AccountReadinessJob` had the same flaw**, hunting for a known Page inside `/me/accounts`
+  instead of reading it by id — so the Page-token swap and the webhook subscription failed for the
+  same accounts, silently.
+
+
 ## [0.3.0] - 2026-07-26
 
 Conversations and engagement. The gem parsed 2 of the 15 webhook fields Meta can

data/app/jobs/instagram_connect/account_readiness_job.rb

@@ -87,8 +87,10 @@ module InstagramConnect
         return
       end
 
-      pages = graph_get(account, "/me/accounts", fields: "id,access_token")
-      page = Array(pages["data"]).find { |p| p["id"].to_s == account.page_id.to_s }
+      # Read the Page directly rather than hunting for it in /me/accounts: we
+      # already know its id, and the listing omits Pages granted through the
+      # Login-for-Business asset picker even though they read fine by id.
+      page = graph_get(account, "/#{account.page_id}", fields: "id,access_token")
 
       if page.nil? || page["access_token"].blank?
         account.update!(needs_reconnect: true,

data/app/jobs/instagram_connect/sync_conversations_job.rb

@@ -0,0 +1,81 @@
+module InstagramConnect
+  # Pulls the threads that already exist on the account.
+  #
+  # Webhooks only ever announce NEW activity, so a freshly connected account
+  # shows an empty inbox until somebody happens to message in — even though the
+  # operator has years of conversations sitting in Instagram. This fetches what
+  # Meta will give us: every thread, and the 20 most recent messages in each,
+  # which is the entire history the API exposes to any app.
+  #
+  # Safe to re-run. Threads are located by igsid and messages are deduped on
+  # ig_message_id, so a second pass updates rather than duplicates.
+  class SyncConversationsJob < ApplicationJob
+    queue_as :default
+
+    def perform(account_id)
+      account = Account.find_by(id: account_id)
+      return if account.nil? || !account.active?
+
+      threads = account.client.list_conversations
+      return unless threads.success?
+
+      Array(threads.data["data"]).each { |thread| sync_thread(account, thread["id"]) }
+    end
+
+    private
+
+    def sync_thread(account, conversation_id)
+      result = account.client.conversation_messages(conversation_id: conversation_id)
+      return unless result.success?
+
+      messages = Array(result.data.dig("messages", "data"))
+      # A thread with no readable messages tells us nothing and would show as an
+      # empty row in the inbox, so it is skipped rather than created.
+      return if messages.empty?
+
+      conversation = Conversation.locate(account: account, igsid: counterpart(messages, account))
+      messages.reverse_each { |message| import(conversation, account, message) }
+    end
+
+    # Meta reports both ends of every message; the thread belongs to whichever
+    # participant is not us.
+    def counterpart(messages, account)
+      messages.each do |message|
+        [ message.dig("from", "id"), *Array(message.dig("to", "data")).map { |t| t["id"] } ]
+          .compact.each { |id| return id.to_s if id.to_s != account.ig_user_id.to_s }
+      end
+      account.ig_user_id.to_s
+    end
+
+    def import(conversation, account, payload)
+      mid = payload["id"].to_s
+      return if mid.blank?
+
+      message = Message.find_or_initialize_by(conversation_id: conversation.id, ig_message_id: mid)
+      return unless message.new_record?
+
+      outbound = payload.dig("from", "id").to_s == account.ig_user_id.to_s
+      message.assign_attributes(
+        direction: outbound ? "outbound" : "inbound",
+        # Historical rows: an outbound message we are reading back has already
+        # been delivered, and an inbound one has already arrived.
+        status: outbound ? "sent" : "received",
+        body: payload["message"],
+        source: "sync",
+        sent_at: parse_time(payload["created_time"])
+      )
+      message.account_id = account.id
+      message.save!
+      conversation.register_message(message)
+    rescue ActiveRecord::RecordNotUnique
+      # Raced a webhook for the same message. The webhook's copy is the one that
+      # matters; ours would have been identical.
+    end
+
+    def parse_time(value)
+      Time.zone.parse(value.to_s)
+    rescue ArgumentError, TypeError
+      nil
+    end
+  end
+end

data/lib/instagram_connect/client.rb

@@ -157,6 +157,40 @@ module InstagramConnect
       get("/me/accounts", { fields: "id,name,access_token,instagram_business_account" })
     end
 
+    # Threads that already exist on the account. Webhooks only ever tell us about
+    # NEW activity, so without this an inbox starts empty and stays empty until
+    # somebody happens to message in. Meta returns the 20 most recent messages
+    # per thread and no more — that is the whole history available to any app.
+    def list_conversations(ig_user_id: @ig_user_id, limit: 50)
+      collect("/#{require_ig_user_id(ig_user_id)}/conversations",
+              { platform: "instagram", fields: "id,updated_time", limit: limit })
+    end
+
+    def conversation_messages(conversation_id:, limit: 20)
+      get("/#{conversation_id}",
+          { fields: "messages.limit(#{limit}){id,created_time,from,to,message}" })
+    end
+
+    # One Page by id. /me/accounts answers for the Pages a token may *enumerate*;
+    # this answers for a Page it may *read*. Those are not the same set — a Page
+    # granted through the Login-for-Business asset picker is readable here while
+    # absent from the listing.
+    def page(page_id)
+      get("/#{page_id}", { fields: "id,name,access_token,instagram_business_account" })
+    end
+
+    # The asset ids this token actually carries, from Meta's own record of the
+    # consent. Needs no permission beyond the app's own credentials.
+    def granted_asset_ids
+      result = get("/debug_token", { input_token: access_token,
+                                     access_token: "#{config.app_id}|#{config.app_secret}" })
+      return [] unless result.success?
+
+      Array(result.data.dig("data", "granular_scopes"))
+        .flat_map { |scope| Array(scope["target_ids"]) }
+        .uniq
+    end
+
     # Walks a Graph collection to the end, following Meta's own cursors.
     #
     # Offsets are not safe here: a collection can shift between calls, so an

data/lib/instagram_connect/connect.rb

@@ -25,6 +25,10 @@ module InstagramConnect
       )
       account.connected_by_id = connected_by_id unless connected_by_id.nil?
       account.save!
+      # Webhooks only announce new activity, so without this the operator
+      # connects and stares at an empty inbox beside an Instagram account full
+      # of conversations.
+      SyncConversationsJob.perform_later(account.id)
       account
     end
 
@@ -35,11 +39,34 @@ module InstagramConnect
     def resolve_identity(data)
       return { ig_user_id: data[:ig_user_id], page_id: data[:page_id] } if data[:ig_user_id]
 
-      result = Client.new(access_token: data[:access_token], config: @config).list_pages
-      page = Array(result.data["data"]).find { |p| p["instagram_business_account"] }
-      raise ConfigurationError, "no Instagram business account is linked to a Page" unless page
+      client = Client.new(access_token: data[:access_token], config: @config)
+      page = candidate_pages(client).find { |p| p["instagram_business_account"] }
+      unless page
+        raise ConfigurationError,
+          "connected, but no Page with a linked Instagram business account was found — " \
+          "checked the Pages this token can list and the assets it was granted"
+      end
 
-      { ig_user_id: page.dig("instagram_business_account", "id"), page_id: page["id"] }
+      { ig_user_id: page.dig("instagram_business_account", "id").to_s, page_id: page["id"].to_s }
+    end
+
+    # /me/accounts lists only the Pages a token may enumerate, and a Page granted
+    # through the Login-for-Business asset picker is not one of them — the list
+    # comes back empty while the Page itself reads fine. So when the listing has
+    # nothing usable, ask the token which assets it carries and read those.
+    def candidate_pages(client)
+      listed = client.list_pages
+      unless listed.success?
+        raise ApiError, "could not read Pages from Instagram: #{listed.error_message}"
+      end
+
+      pages = Array(listed.data["data"])
+      return pages if pages.any? { |p| p["instagram_business_account"] }
+
+      client.granted_asset_ids.filter_map do |id|
+        result = client.page(id)
+        result.data if result.success?
+      end
     end
   end
 end

data/lib/instagram_connect/version.rb

@@ -1,3 +1,3 @@
 module InstagramConnect
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: instagram_connect
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Kshitiz Sinha
@@ -100,6 +100,7 @@ files:
 - app/jobs/instagram_connect/refresh_tokens_job.rb
 - app/jobs/instagram_connect/replay_events_job.rb
 - app/jobs/instagram_connect/send_message_job.rb
+- app/jobs/instagram_connect/sync_conversations_job.rb
 - app/models/instagram_connect/account.rb
 - app/models/instagram_connect/api_budget.rb
 - app/models/instagram_connect/application_record.rb