portage-ucp-instagram 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f6de3c1bfd185403eb82d68015bea9a509ffe1611fcf438db56b66b40848d8c3
+  data.tar.gz: 859258fcf4198304fcc7a4fbd31c98e72f20db77711c8000f0ee14a13d40b3e9
+SHA512:
+  metadata.gz: ad5a5195f6e873cca743a6eb9d5227fe799f35ca3a140389d37bbcc9726201f0a8bf39728599f31b611144ee7f41f135aaa3c713fe6214704cbfe561233ef2bf
+  data.tar.gz: 2ed79e836dd1227ec848a529a8e2fca6c7f2558e35eaaa149945675db8d12e6c63252d1d6bc55ac1b51771dd9e4309e84d73bccc4ae85015d8cf00699c65a47a

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to this project are documented here. Format loosely follows
+[Keep a Changelog](https://keepachangelog.com/en/1.0.0/); this project is
+pre-1.0, so APIs may still shift between minor versions.
+
+## [0.1.0] - Unreleased
+
+- Initial pre-release. Instagram/Facebook Shops adapter against Meta's Graph
+  API Commerce Catalog — catalog real, checkout redirect-link only, order
+  lookup limited to "checkout on Instagram/Facebook" merchants.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tom Whitbread
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# portage-ucp-instagram
+
+Instagram/Facebook Shops adapter for [`portage-ucp`](../portage-ucp). Implements `Portage::Ucp::Adapter` against Meta's Graph API Commerce Catalog. Generic only — no merchant-specific business logic. Plain `Net::HTTP`, no Facebook SDK runtime dependency.
+
+## What it covers — and what it deliberately doesn't
+
+Like [`portage-ucp-etsy`](../portage-ucp-etsy), this is **catalog + redirect-link checkout + order**, not a full transactional adapter — for a more fundamental reason than Etsy. Instagram/Facebook Shops splits into two merchant populations:
+
+- **"Checkout on your website"** — each catalog product carries its own merchant-hosted `url`. Buying happens entirely on the merchant's own site, never through Meta. This is the population `create_checkout` is built for: it redirects to that `url`, same posture as Etsy's listing-page redirect.
+- **"Checkout on Instagram/Facebook"** — buying happens natively inside the Meta app, with **no exposed URL or API to drive it at all** — not even a redirect is possible here. Meta Commerce Orders from *this* population are the only ones `get_order` can ever see; this adapter can't originate a purchase for them, only read one back after the fact.
+
+| UCP capability | Backing Graph API | Notes |
+|---|---|---|
+| `dev.ucp.shopping.catalog` | Commerce Catalog | `search_catalog`, `get_product` |
+| `dev.ucp.shopping.checkout` | — | `create_checkout`/`get_checkout` only, redirect-link, "checkout on your website" catalogs only. `update_checkout`/`complete_checkout`/`cancel_checkout` raise `Portage::Ucp::NotImplementedError` — nothing to call. |
+| `dev.ucp.shopping.order` | Commerce Orders | `get_order` — only returns data for "checkout on Instagram/Facebook" merchants; 403/404s for everyone else, since their orders live entirely in their own system |
+| `dev.ucp.shopping.cart` | — | not implemented; no cart resource exists |
+| `dev.ucp.shopping.identity` | — | not implemented; Instagram/Facebook user login is a separate concern from the Page/catalog token used here |
+
+Same as Etsy: `create_checkout`'s Checkout objects are **not real Meta resources** — they live only in the `Adapter` instance's memory (`get_checkout` reads back what `create_checkout` stored), not surviving a process restart. `get_order`'s `checkout_id` is always blank for the same reason.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "portage-ucp-instagram"
+```
+
+```bash
+bundle install
+```
+
+## Setup
+
+You need a long-lived Page/catalog access token and your Commerce Catalog id.
+
+```ruby
+require "portage/ucp/instagram"
+
+client = Portage::Ucp::Instagram::Client.new(access_token: ENV.fetch("INSTAGRAM_ACCESS_TOKEN"))
+adapter = Portage::Ucp::Instagram::Adapter.new(client: client, catalog_id: ENV.fetch("INSTAGRAM_CATALOG_ID"))
+```
+
+### Getting a long-lived access token
+
+The initial short-lived token comes from Meta's interactive Business Login consent flow (outside this gem's scope). Exchange it for a long-lived one (~60 days):
+
+```ruby
+fetcher = Portage::Ucp::Instagram::AccessTokenFetcher.new(
+  client_id: ENV.fetch("INSTAGRAM_CLIENT_ID"),
+  client_secret: ENV.fetch("INSTAGRAM_CLIENT_SECRET"),
+  short_lived_token: ENV.fetch("INSTAGRAM_SHORT_LIVED_TOKEN")
+)
+
+result = fetcher.fetch
+result.access_token # => pass into Client.new
+result.expires_in    # => ~5,184,000 seconds (60 days) — re-run Business Login after that, no refresh grant exists
+```
+
+## Usage
+
+```ruby
+# Catalog — product_id is the Graph API product node id
+products = adapter.search_catalog(query: "mug", limit: 10)
+product  = adapter.get_product(product_id: products.first.id)
+
+# Checkout — a redirect, not a real transaction
+checkout = adapter.create_checkout(
+  line_items: [{ product_id: product.variants.first[:id], quantity: 1 }],
+  idempotency_key: SecureRandom.uuid
+)
+checkout.links.first.url # => hand this to the shopper/agent to complete the purchase on the merchant's site
+
+# Order — only works for "checkout on Instagram/Facebook" merchants
+order = adapter.get_order(order_id: some_commerce_order_id)
+```
+
+## Wiring into portage-ucp
+
+Drop the adapter into a `Dispatcher` (or the MCP server) the same as any other backend:
+
+```ruby
+dispatcher = Portage::Ucp::Dispatcher.new(adapter: adapter)
+
+dispatcher.call(
+  capability: "dev.ucp.shopping.checkout",
+  action: "create_checkout",
+  arguments: { line_items: [{ product_id: product_node_id, quantity: 1 }], idempotency_key: SecureRandom.uuid }
+)
+```
+
+## Errors
+
+```ruby
+Portage::Ucp::Instagram::Error    # base class
+Portage::Ucp::Instagram::ApiError # any non-2xx response from Meta's Graph API
+```
+
+## Development
+
+```bash
+bundle exec rspec   # tests (WebMock-stubbed, no live Meta account needed)
+bundle exec rubocop  # lint
+
+# exchange a real short-lived token for a long-lived one
+INSTAGRAM_CLIENT_ID=... INSTAGRAM_CLIENT_SECRET=... INSTAGRAM_SHORT_LIVED_TOKEN=... \
+  bundle exec rake instagram_access_token
+```
+
+## License
+
+[MIT](LICENSE) — Copyright (c) 2026 Tom Whitbread.

data/lib/portage/ucp/instagram/access_token_fetcher.rb

@@ -0,0 +1,41 @@
+require "net/http"
+require "json"
+
+module Portage
+  module Ucp
+    module Instagram
+      # Exchanges a short-lived user/page access token for a long-lived one
+      # (~60 days) via Graph API's `fb_exchange_token` grant.
+      #
+      # Doesn't handle the *initial* Business Login consent redirect that
+      # produces the short-lived token in the first place (that's an
+      # interactive, one-time setup step outside this gem's scope) — only
+      # the long-lived exchange a server needs to avoid re-running consent
+      # every few hours. Meta doesn't support refreshing past the ~60-day
+      # long-lived token's own expiry — re-running consent is the only way
+      # past that, there's no refresh_token here the way Etsy/Shopify have.
+      class AccessTokenFetcher
+        Result = Struct.new(:access_token, :expires_in, keyword_init: true)
+
+        def initialize(client_id:, client_secret:, short_lived_token:, api_version: Client::DEFAULT_API_VERSION)
+          @client_id = client_id
+          @client_secret = client_secret
+          @short_lived_token = short_lived_token
+          @api_version = api_version
+        end
+
+        def fetch
+          params = { grant_type: "fb_exchange_token", client_id: @client_id, client_secret: @client_secret,
+                     fb_exchange_token: @short_lived_token }
+          uri = URI("https://graph.facebook.com/#{@api_version}/oauth/access_token?#{URI.encode_www_form(params)}")
+
+          response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(Net::HTTP::Get.new(uri)) }
+          body = JSON.parse(response.body)
+          raise Portage::Ucp::Instagram::Error, "token exchange failed: #{body}" unless response.is_a?(Net::HTTPSuccess)
+
+          Result.new(access_token: body["access_token"], expires_in: body["expires_in"])
+        end
+      end
+    end
+  end
+end

data/lib/portage/ucp/instagram/adapter.rb

@@ -0,0 +1,118 @@
+require "json"
+require "uri"
+
+module Portage
+  module Ucp
+    module Instagram
+      # Generic Portage::Ucp::Adapter over Meta's Graph API Commerce Catalog
+      # — no merchant-specific business logic, same posture as the other
+      # adapters in this project.
+      #
+      # IMPORTANT: like Portage::Ucp::Etsy::Adapter, this is deliberately a
+      # **catalog + redirect-link checkout + order** adapter, not a full
+      # transactional one — and for a more fundamental reason than Etsy.
+      # Instagram/Facebook Shops split into two populations:
+      #
+      # - "Checkout on your website" catalogs: each product carries its own
+      #   merchant-hosted `url`. Buying happens entirely on the merchant's
+      #   own site, not through Meta at all — this is the case this
+      #   adapter's `create_checkout` is built for, redirecting to that
+      #   `url` per product, same posture as Etsy's listing-page redirect.
+      # - "Checkout on Instagram/Facebook" catalogs: buying happens
+      #   natively inside the Meta app, with **no exposed URL or API to
+      #   drive it** at all — not even a redirect is possible here. Meta
+      #   orders from *this* population are the only ones `get_order` can
+      #   ever see (see Portage::Ucp::Instagram::Mapper.order's comment);
+      #   this adapter can't originate a purchase for them, only read one
+      #   back after the fact.
+      #
+      # Same as Etsy: doesn't override `get_cart`/`create_cart`/
+      # `update_cart`/`cancel_cart` (no cart resource exists),
+      # `update_checkout`/`complete_checkout`/`cancel_checkout` (nothing to
+      # update/complete/cancel programmatically — calling them raises
+      # Portage::Ucp::NotImplementedError), or `link_identity` (Instagram/
+      # Facebook user login is a separate concern from the Page/catalog
+      # token used here). `create_checkout`'s Checkout objects are **not
+      # real Meta resources** — they live only in this Adapter instance's
+      # memory, same as Etsy's.
+      class Adapter < Portage::Ucp::Adapter
+        PRODUCT_FIELDS = "id,name,description,price,availability,url,item_group_id".freeze
+
+        # §9a dedup via Support::Idempotency, so an agent's retry on a
+        # dropped connection doesn't build a second, different in-memory
+        # Checkout for the same intent.
+        include Portage::Ucp::Support::Idempotency
+
+        def initialize(client:, catalog_id:)
+          super()
+          @client = client
+          @catalog_id = catalog_id
+          @checkouts = {}
+        end
+
+        def search_catalog(query:, limit:)
+          filter = URI.encode_www_form_component(JSON.generate(name: { i_contains: query }))
+          data = @client.get("/#{@catalog_id}/products?fields=#{PRODUCT_FIELDS}&limit=#{limit}&filter=#{filter}")
+          (data["data"] || []).map { |node| Mapper.product(node) }
+        end
+
+        def get_product(product_id:)
+          node = @client.get("/#{product_id}?fields=#{PRODUCT_FIELDS}")
+          return nil unless node["id"]
+
+          Mapper.product(with_variants(node))
+        rescue Portage::Ucp::Instagram::ApiError => e
+          raise unless [400, 404].include?(e.status)
+
+          nil
+        end
+
+        def create_checkout(line_items:, idempotency_key:)
+          dedup(idempotency_key) do
+            products = line_items.map { |li| product_with_quantity(li) }
+            checkout_id = "instagram-checkout-#{idempotency_key}"
+            checkout = Mapper.checkout(products, id: checkout_id, status: "incomplete")
+            @checkouts[checkout_id] = checkout
+            checkout
+          end
+        end
+
+        def get_checkout(checkout_id:)
+          @checkouts[checkout_id]
+        end
+
+        # See the class-level comment: this only ever returns data for
+        # "Checkout on Instagram/Facebook" merchants — everyone else's
+        # orders live entirely outside Meta's system.
+        def get_order(order_id:)
+          fields = "id,order_status,items{retailer_id,product_name,quantity,price_per_unit}," \
+                   "estimated_payment_details"
+          node = @client.get("/#{order_id}?fields=#{fields}")
+          node["id"] ? Mapper.order(node) : nil
+        rescue Portage::Ucp::Instagram::ApiError => e
+          raise unless [400, 403, 404].include?(e.status)
+
+          nil
+        end
+
+        private
+
+        # A product's own resource only carries its `item_group_id`, not
+        # its siblings — fetching the rest of the variant group is a second
+        # call, only made for #get_product's single-product path, same N+1
+        # reasoning as every other adapter's variant fetch.
+        def with_variants(node)
+          return node unless node["item_group_id"]
+
+          filter = URI.encode_www_form_component(JSON.generate(item_group_id: { eq: node["item_group_id"] }))
+          data = @client.get("/#{@catalog_id}/products?fields=id,name,availability,price&filter=#{filter}")
+          node.merge("variants_detail" => data["data"])
+        end
+
+        def product_with_quantity(line_item)
+          @client.get("/#{line_item[:product_id]}?fields=id,name,price,url").merge("quantity" => line_item[:quantity])
+        end
+      end
+    end
+  end
+end

data/lib/portage/ucp/instagram/client.rb

@@ -0,0 +1,35 @@
+require "net/http"
+require "json"
+
+module Portage
+  module Ucp
+    module Instagram
+      # Minimal REST client over Meta's Graph API
+      # (`graph.facebook.com/{api_version}`), used for both Instagram and
+      # Facebook Shops — they share one Commerce Catalog underneath.
+      #
+      # Deliberately plain Net::HTTP, not the `koala`/`facebook-ads-sdk`
+      # gems — a generic adapter that any Ruby app can drop in only needs a
+      # base URL and a bearer token, trivially stubbable with WebMock.
+      class Client
+        include Portage::Ucp::Support::HttpClient
+
+        DEFAULT_API_VERSION = "v21.0".freeze
+
+        def initialize(access_token:, api_version: DEFAULT_API_VERSION)
+          @access_token = access_token
+          @api_version = api_version
+        end
+
+        def get(path)
+          json_request(Net::HTTP::Get, "https://graph.facebook.com/#{@api_version}#{path}",
+                       headers: { "Authorization" => "Bearer #{@access_token}" })
+        end
+
+        private
+
+        def api_error_class = Portage::Ucp::Instagram::ApiError
+      end
+    end
+  end
+end

data/lib/portage/ucp/instagram/errors.rb

@@ -0,0 +1,24 @@
+module Portage
+  module Ucp
+    module Instagram
+      class Error < StandardError; end
+
+      # Raised for any non-2xx response from Meta's Graph API
+      # (`graph.facebook.com`) — a non-2xx status with a JSON
+      # `{error: {message, type, code}}` body.
+      class ApiError < Error
+        include Portage::Ucp::Support::ApiError
+
+        private
+
+        # Not just "Instagram": the same client and errors cover Facebook
+        # Shops, since both sit on one Meta Graph API surface.
+        def api_label = "Instagram/Graph"
+
+        def detail(body)
+          body.dig("error", "message") || body
+        end
+      end
+    end
+  end
+end

data/lib/portage/ucp/instagram/mapper.rb

@@ -0,0 +1,146 @@
+module Portage
+  module Ucp
+    module Instagram
+      # Converts Meta Graph API Commerce Catalog/Orders response bodies
+      # into the protocol-layer value objects from
+      # Portage::Ucp::ValueObjects — nothing Meta-shaped is allowed to leak
+      # past this file.
+      module Mapper
+        module_function
+
+        AVAILABLE_STATES = ["in stock", "available for order", "preorder"].freeze
+
+        # Meta's Catalog product `price` field is a single string combining
+        # amount and currency (`"25.00 USD"`), unlike every REST-based
+        # adapter in this project splitting those into separate fields —
+        # this is the one place that string needs parsing.
+        def money(price_string)
+          return Portage::Ucp::Money.new(amount_minor: 0, currency: nil) unless price_string
+
+          amount, currency = price_string.split
+          money_from_parts(amount, currency)
+        end
+
+        # Unlike the catalog Product's combined `"25.00 USD"` price
+        # string, the Commerce Orders API's amounts come as separate
+        # `amount`/`currency` fields — this is the shape #order and
+        # #order_line_item work with.
+        def money_from_parts(amount, currency)
+          Portage::Ucp::Support::Amounts.money(amount, currency)
+        end
+
+        # `node["variants_detail"]` is adapter-populated, not a real Meta
+        # field: variants of a catalog product are just *other whole
+        # product nodes* sharing the same `item_group_id` — there's no
+        # nested variant array to read off a single product the way
+        # Shopify/BigCommerce have one. Fetching the group's other members
+        # is a second call, made only for #get_product's single-product
+        # path, same N+1 reasoning as every other adapter's variant fetch.
+        def product(node, site_url: nil)
+          Portage::Ucp::Product.new(
+            id: node["id"],
+            title: node["name"],
+            description: node["description"],
+            price: money(node["price"]),
+            available: AVAILABLE_STATES.include?(node["availability"]),
+            variants: variants(node),
+            url: node["url"] || site_url
+          )
+        end
+
+        # A product with no `item_group_id` siblings is its own single
+        # implicit variant, same as a single-variant Shopify product using
+        # that variant's own id.
+        def variants(node)
+          detail = node["variants_detail"]
+          return [variant(node)] unless detail
+
+          detail.map { |v| variant(v) }
+        end
+
+        def variant(node)
+          { id: node["id"], title: node["name"], available: AVAILABLE_STATES.include?(node["availability"]),
+            price: money(node["price"]) }
+        end
+
+        # `id:` is caller-supplied: there's no real Meta checkout resource
+        # behind this at all for "checkout on your website" catalogs — see
+        # Portage::Ucp::Instagram::Adapter's class-level comment. `links`
+        # points at each product's own `url` (the merchant's own product
+        # page) rather than a cart, since Instagram/Facebook's public API
+        # has no way to deep-link a multi-item add-to-cart flow outside
+        # Meta's own native checkout.
+        def checkout(products, id:, status:)
+          line_items = products.map { |p| checkout_line_item(p) }
+          Portage::Ucp::Checkout.new(
+            id: id,
+            status: status,
+            line_items: line_items,
+            currency: products.first && money(products.first["price"]).currency,
+            totals: totals(products),
+            links: products.map { |p| Portage::Ucp::Link.new(type: "checkout", url: p["url"], title: p["name"]) }
+          )
+        end
+
+        def checkout_line_item(node)
+          unit_price = money(node["price"]).amount_minor
+          quantity = node["quantity"] || 1
+          line_total = unit_price * quantity
+          Portage::Ucp::LineItem.new(
+            id: node["id"],
+            item: Portage::Ucp::Item.new(id: node["id"], title: node["name"], price: unit_price),
+            quantity: quantity,
+            totals: Portage::Ucp::Support::Totals.line(line_total)
+          )
+        end
+
+        def totals(products)
+          subtotal = products.sum { |p| money(p["price"]).amount_minor * (p["quantity"] || 1) }
+          Portage::Ucp::Support::Totals.summary(subtotal: subtotal, total: subtotal)
+        end
+
+        # Meta's Commerce Order resource only exists at all for "Checkout on
+        # Instagram/Facebook" merchants — merchants using "checkout on your
+        # website" (the population Checkout#links above is built for) never
+        # have a Meta-side order; their orders live entirely in their own
+        # system (e.g. via the Shopify/WooCommerce/etc adapter for that
+        # side), and this method will 403/404 for them. `permalink_url` is
+        # left blank — Meta doesn't return a buyer-facing order link via
+        # this API. `checkout_id` is always blank too, same fundamental
+        # reason as Portage::Ucp::Etsy::Mapper.order.
+        ORDER_STATUS = { "COMPLETED" => "fulfilled", "CANCELLED" => "removed" }.freeze
+
+        def order(node)
+          status = Portage::Ucp::Support::LineItemStatus.from_table(ORDER_STATUS, node.dig("order_status", "state"))
+          items = node.dig("items", "data") || []
+          subtotal = money_from_parts(node.dig("estimated_payment_details", "subtotal", "amount"), nil).amount_minor
+          total = money_from_parts(node.dig("estimated_payment_details", "total_amount", "amount"), nil).amount_minor
+          Portage::Ucp::Order.new(
+            id: node["id"],
+            checkout_id: "",
+            permalink_url: "",
+            line_items: items.map { |n| order_line_item(n, status) },
+            fulfillment: Portage::Ucp::Fulfillment.new,
+            currency: node.dig("estimated_payment_details", "total_amount", "currency"),
+            totals: Portage::Ucp::Support::Totals.summary(subtotal: subtotal, total: total)
+          )
+        end
+
+        def order_line_item(node, status)
+          quantity = node["quantity"]
+          fulfilled = Portage::Ucp::Support::LineItemStatus.fulfilled_quantity(status, quantity)
+          unit_price = money_from_parts(node.dig("price_per_unit", "amount"), nil).amount_minor
+          line_total = unit_price * quantity
+          Portage::Ucp::OrderLineItem.new(
+            id: node["id"].to_s,
+            item: Portage::Ucp::Item.new(id: node["retailer_id"].to_s, title: node["product_name"],
+                                         price: unit_price),
+            quantity: { original: quantity, total: quantity, fulfilled: fulfilled },
+            totals: Portage::Ucp::Support::Totals.line(line_total),
+            status: status
+          )
+        end
+      end
+    end
+  end
+end

data/lib/portage/ucp/instagram/version.rb

@@ -0,0 +1,7 @@
+module Portage
+  module Ucp
+    module Instagram
+      VERSION = "0.1.0".freeze
+    end
+  end
+end

data/lib/portage/ucp/instagram.rb

@@ -0,0 +1,7 @@
+require "portage/ucp"
+require_relative "instagram/version"
+require_relative "instagram/errors"
+require_relative "instagram/client"
+require_relative "instagram/access_token_fetcher"
+require_relative "instagram/mapper"
+require_relative "instagram/adapter"

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: portage-ucp-instagram
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Whitbread
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: portage-ucp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.88'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.88'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.24'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Implements Portage::Ucp::Adapter against Meta's Graph API Commerce Catalog.
+  Catalog is real; checkout is redirect-link only (to each product's own merchant-hosted
+  URL) since Meta's public API has no cart/checkout endpoint for website-checkout
+  catalogs, and none at all for native Instagram/Facebook checkout. Generic only —
+  no merchant-specific business logic. Plain Net::HTTP, no Facebook SDK runtime dependency.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/portage/ucp/instagram.rb
+- lib/portage/ucp/instagram/access_token_fetcher.rb
+- lib/portage/ucp/instagram/adapter.rb
+- lib/portage/ucp/instagram/client.rb
+- lib/portage/ucp/instagram/errors.rb
+- lib/portage/ucp/instagram/mapper.rb
+- lib/portage/ucp/instagram/version.rb
+homepage: https://github.com/tomtom87/Portage/tree/main/portage-ucp-instagram
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/tomtom87/Portage/tree/main/portage-ucp-instagram
+  changelog_uri: https://github.com/tomtom87/Portage/blob/main/portage-ucp-instagram/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Instagram/Facebook Shops adapter for portage-ucp — catalog/order over MCP
+  and UCP, redirect-link checkout
+test_files: []